Datasets:

hodza

/

BlackBox-2.0-a1

like 0

ComAggregate Example This example shows how aggregation is implemented using the COM compiler. The example is described in detail in chapter two of the book "Inside OLE". With aggregation, an object which implements one or several interfaces is reused without modification and without the need to forward each method of the reused interfaces. The reused object is called the inner one, and the object which reuses the inner object is called the outer object. The inner object delegates all calls to QueryInterface to the outer object, and the outer object has a reference to the inner object's IUnknown interface. This latter interface must not forward the QueryInterface calls, otherwise this would produce an infinite recursion. This implies that an aggregatable object must provide a separate implementation of the IUnknown interface, i.e. an aggregatable object consists of at least two records which both implement the IUnknown interface, where one QueryInterface method is forwarded, while the other is not. These two records will be linked by references from one to the other. The interface which is reused has the IAnimal interface, IAnimal = POINTER TO ABSTRACT RECORD ["{00021143-0000-0000-C000-000000000046}"] (COM.IUnknown) (this: IAnimal) Eat (): COM.RESULT, NEW, ABSTRACT; (this: IAnimal) Sleep (): COM.RESULT, NEW, ABSTRACT; (this: IAnimal) Procreate (): COM.RESULT, NEW, ABSTRACT; END; and the two objects which implement the aggregatable implementation of this interface are defined below. CAnimal = POINTER TO RECORD (COM.IUnknown) impl: CImpIAnimal END; CImpIAnimal = POINTER TO RECORD (IAnimal) obj: CAnimal END; The CAnimal record implements the IUnknown interface and the CImplAnimal record implements the IAnimal interface. If the object is aggregated, the calls to the QueryInterface method of the latter record are forwarded to the outer object. Since objects are created inside-out, the outer object is passed as a parameter to the procedure which creates an IAnimal object. If the reference to the outer object is not NIL, then the IAnimal object is aggregated. It is a convention of COM that then the IUnknown interface of the aggregated object must be requested upon object creation. As the outer object has a reference to the inner one, and the inner one a reference to the outer one, there is a cycle of references which would prevent garbage collection. To avoid this, the reference from the inner to the outer object is a special reference which is not reference counted. Such references can be generated with the two-argument NEW. The default implementation of QueryInterface then automatically forwards the requests to the outer object. If the object is not aggregated, we use the CAnimal record as "outer" object for the CImplAnimal object. This is the same pattern as in the ComObject example, i.e. a COM object which implements several interfaces. The whole procedure to create an IAnimal object is given below. The first parameter (outer) determines whether the object is aggregated or not. PROCEDURE CreateAnimal (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR new: CAnimal; BEGIN IF (outer # NIL) & (iid # COM.ID(COM.IUnknown)) THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN IF outer = NIL THEN NEW(new.impl, new) ELSE NEW(new.impl, outer) END; IF new.impl # NIL THEN new.impl.obj := new; StdLog.String("Animal allocated"); StdLog.Ln; RETURN new.QueryInterface(iid, int) END END; RETURN WinApi.E_OUTOFMEMORY END CreateAnimal; The inner object's explicit IUnknown interface must control the inner object's reference count and implement the QueryInterface behavior for only the inner object. The procedure which is doing this has the following form: PROCEDURE (this: CAnimal) QueryInterface (IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; BEGIN IF COM.QUERY(this, iid, int) OR COM.QUERY(this.impl, iid, int) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END END QueryInterface; Note that the COM.QUERY command on the CImplAnimal interface is not forwarded. It succeeds if the IAnimal interface is requested. Note that in the example, the outer object which implements the IKoala interface is also designed to support aggregation. The object is separated into two records, one implementing the IUnknown interface and the other the IKoala interface. This design is easy to extend if additional interfaces have to be supported. The example finally provides some commands which allow to test the functionality of the IKoala-IAnimal implementation. ComAggregatesources

Com/Docu/Aggregate.odc

ComConnect Example This example shows how connectable objects are implemented using the COM compiler. The example is described in detail in chapter four of the book "Inside OLE". Connectable objects offer an interface which allows to install interfaces which can be called back by the connectable object. A connectable object has to implement the interface IConnectionPointContainer with the two methods FindConnectionPoint and EnumConnectionPoints. With the first method, the connectable object can be asked for a specific outgoing interface. If the interface is supported, then a pointer to the IConnectionPoint is returned, the interface through which the callback interface can be installed. With the method EnumConnectionPoints the supported outgoing interfaces can be requested. The list of supported interfaces is returned in the form of an enumeration interface, IEnumConnectionPoints. In our example, the connectable object keeps a list of the supported interfaces as an instance variable. The IConnectionPoint interface allows to establish a connection between the connectable object and the client through the Advise method. A cookie (key) is returned as result. A connection point can support any number of connections. In our example, the constant connMax defines the number of connections that can be established. With the Unadvise method a connection can be terminated. The connection cookie must be passed as argument. As argument of the Advise method the sink object's IUnknown interface is passed. From this interface the outgoing interface is requested and stored in the connection (the object implementing IConnectionPoint). Besides these two methods, the IConnectionPoint interface supports the methods EnumConnections, GetConnectionPointContainer and GetConnectionInterface. The implementation of the latter two functions is straight-forward. The EnumConnections function returns an enumeration of all the currently installed connections. This enumeration interface is implemented with CEnumConnections. The implementation of IConnectionPoint has the following instance variables: CConnectionPoint = POINTER TO RECORD (WinOle.IConnectionPoint) obj: CConnObject; iid: COM.GUID; unk: ARRAY connMax OF COM.IUnknown; cookies: ARRAY connMax OF INTEGER; conn: INTEGER; next: INTEGER END; The obj reference refers to the connectable object, i.e. to the object implementing the IConnectionPointContainer interface. The GUID of the outgoing interface, which is supported by the concrete connection, is stored in the field iid. In our example this is always COM.GUID(IDuckEvents). All installed connections are stored in the unk array. If an event is distributed through all conected interfaces, then the necessary interface is requested though the IUnknown interfaces installed in the unk array. The cookies corresponding to the connections are stored in the cookies array. They are necessary to search a connection when Unadvise is called. The conn field counts the number of installed connections, and the next field finally contains the last distributed cookie. The IDuckEvents interface is used in this example as the outgoing interface. This interface supports the following three functions: IDuckEvents = POINTER TO ABSTRACT RECORD ["{00021145-0000-0000-C000-000000000046}"] (COM.IUnknown) (this: IDuckEvents) Quack (): COM.RESULT, NEW, ABSTRACT; (this: IDuckEvents) Flap (): COM.RESULT, NEW, ABSTRACT; (this: IDuckEvents) Paddle (): COM.RESULT, NEW, ABSTRACT; END; In its instance variable, the concrete implementation of this interface keeps an identifier and the cookie which is obtained when the interface is installed in the connectable object. The implementation of the methods write a text to the log indicating that they have been called. They also write their identifier into the log. In our example, the connectable object CConnObject offers the additional method TriggerEvent. With this method, an event can be sent through all registered IDuckEvents interfaces. The module ComConnect offers the following commands Init creates two objects which implement the IDuckEvents interface Release disconnects all connections and frees the connectable object and the sink objects ObjectCreate creates the connectable object ObjectRelease releases the connectable object SinkXConnect connects a sink object to the connectable object SinkXDisconnect disconnects a sink object from the connectable object TriggerQuack calls the Quack method of all connected IDuckEvents interfaces TriggerFlap calls the Flap method of all connected IDuckEvents interfaces TriggerPaddle calls the Paddle method of all connected IDuckEvents interfaces This example is coded rather in a general way. It would be easy to extend the implementation to support more connections or more outgoing interfaces. If only one outgoing interface were supported, the code could be simplified at several places. ComConnectsources

Com/Docu/Connect.odc

DevComDebug see documentationoftheDirect-To-COMCompilerenvironment.

Com/Docu/Debug.odc

Direct-To-COM Compiler The Component Object Model The Component Object Model (COM) is an object model which allows independently developed binary software components to connect to and communicate with each other in a well-defined manner. COM defines a binary standard for object interoperability which is programming-language and compiler independent. The primary architectural feature of COM is that an object exposes a set of interfaces to a client. An interface is a set of semantically related functions. Every object can provide multiple interfaces. COM objects can only be accessed through pointers to interfaces (interface pointers). Direct access to an object's internal variables is not possible. This allows for encapsulation of data and processing, a fundamental requirement of a true component software standard. Another fundamental concept of the COM model is reference counting. Reference counting allows objects to track their own lifetime and delete themselves when appropriate. The following figure visualizes a COM object as large black box, which is accessible from the outside only via pointers to its exported interfaces. Internally, a COM object typically contains a large number of simpler objects, which constitute its hidden implementation. Note that there are pointers from each interface record of the COM object to each other interface record, directly or indirectly. Also, every implementation object is connected to the interfaces through one or several pointer chains. Pointer chains may contain cycles. Binary Standard COM defines a standardized way to layout the concrete implementation of interfaces. Every COM object provides the implementation of each method specified in the interface. The pointers to the method implementations are stored in an array, a so called virtual function table (vtable). The interface record is a structure whose first entry is a pointer to a vtable; it may contain additional private object data. COM clients only interact with a COM object through pointers to interfaces, i.e. with pointers to pointers to vtables. It is through such a pointer that the client accesses the object's implementation of the interface. Therefore, any language that can call functions via pointers (using the StdCall calling conventions) can be used to write and use COM components. interface pointer interface vtable Reference Counting in COM COM uses reference counting as a simple form of (manual) garbage collection. Reference counting is performed through two standard methods called AddRef and Release. Whenever a new reference to an interface is established, AddRef must be called. When the interface is no longer needed, Release must be called. Reference counting is done at the interface level, i.e., every interface must support the two methods AddRef and Release. They are defined in the interface IUnknown which is the base interface of every COM interface. Internally, the interface implementation counts the number of AddRef and Release calls, and thereby knows when it is safe to free the memory that it occupies. Conceptually, reference counting is performed at the interface level. However, as a COM object can support several interfaces, it is free to implement one central reference count per object, instead of one reference count per interface. However, a client should never assume that an object uses the same counter for several interfaces; i.e., it should increment the reference count always through the interface which is about to be used. The following two simple rules define how reference counts have to be managed. Interface pointer variables are variables which hold interface pointers. Such variables may be located in memory or in processor registers. 1) Whenever an interface pointer is stored in an interface pointer variable, AddRef must be called through this interface pointer. 2) Immediately before an interface pointer variable is cleared, overwritten, or destroyed, Release must be called on the interface pointer presently in the variable. Rule 1 implies that a function that returns an interface pointer must call AddRef on this interface, as it stores a new interface pointer in a register or in memory (i.e., at a place where access is still possible). Examples of such functions are IUnknown.QueryInterface and IFactory.CreateInstance. Rule 2 implies that Release must be called on old values of an interface pointer variable before assigning a new value, and on local interface pointers before leaving the scope. The example below demonstrates the use of these two rules: IFactory* pFactory; HRESULT hr = GetFactory(IID_IFactory, (void**)&pFactory); if (SUCCEEDED(hr)) // Reference count of factory has been incremented by GetFactory { IAnimal* pAnimal1; hr = pFactory->CreateInstance(0, IID_IAnimal, (void**)&pAnimal1); // (2) if (SUCCEEDED(hr)) // Reference count of pAnimal1 incremented by CreateInstance { IAnimal* pAnimal2 = pAnimal1; pAnimal2->AddRef(); // Increment Reference Count (1) pAnimal2->Sleep(); // Do something through pAnimal2 pAnimal1->Release(); // Release Interface before assigning a new animal (1) (3) hr = factory->CreateInstance(0, IID_IAnimal, (void**)&pAnimal1); if (SUCCEEDED(hr)) // Reference count of pAnimal1 incremented by CreateInstance { pAnimal1->Eat(); // Do something with second animal pAnimal1->Release(); // scope in which pAnimal1 is declared will be closed soon } pAnimal2->Release(); // scope in which pAnimal2 is declared will be closed } pFactory->Release(); // scope in which pFactory is declared wil be closed soon } In principle, every assignment to an interface pointer must be accompanied by a Release call (except for NULL or uninitialized interface pointers) and an AddRef call. However, in some special situations, AddRef and Release pairs can be omitted safely. Unfortunately, the COM specification defines some special rules for interface parameters of methods. An interface may specify that some arguments of its methods are passed only in one direction; i.e., only from the client to the server or vice versa. This minimizes communication overhead for calls across process or machine boundaries (remote procedure calls), but it complicates the rules for the COM programmer.

Com/Docu/DTC-COM.odc

Direct-To-COM Compiler Contents COMCompilerExtensions COMSysflagsforInterfaceStructures COMsysflagsforVARparameters TheModuleCOM NewPredefinedProcedures Unions COMProgrammingHints CompilerImplementationRestrictions The Direct-To-COM (DTC) compiler is a Component Pascal compiler that supports Microsoft's Component Object Model (COM) binary interface standard. In DTC Component Pascal, COM objects are declared and implemented in a superset of the Component Pascal language. They can be used from any other language, and COM objects implemented in any language can be used from Component Pascal. In Component Pascal, COM interfaces are mapped to special Component Pascal records. Interface pointers are pointers to such records. The virtual function table is the method table of the Component Pascal type descriptor. It is hidden from the programmer. A COM interface can be defined in the following way: ILookup* = POINTER TO ABSTRACT RECORD ["{C4910D71-BA7D-11CD-94E8-08001701A8A3}"] (COM.IUnknown) END; PROCEDURE (this: ILookup) LookupByName*( name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: ILookup) LookupByNumber*( number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; Interface definitions can be derived from one another using Component Pascal subtyping. The above interface is a subtype of the interface COM.IUnknown. The interface identifier (IID) is specified in the declaration of the interface. The interface is declared to be abstract and cannot be instantiated. Concrete implementations of interface objects are extensions of interface records. In contrast to the interface records which are referenced through (reference-counted) interface pointers, the implementation records are referenced through regular Component Pascal pointers. The COM standard uses reference counting as its memory management strategy. Reference counting errors, however, are the most difficult and dangerous errors when programming to the OLE interfaces. The "Safer OLE" technology of the DTC compiler adds automatic memory management to COM objects. In contrast to C and C++, programmers using the DTC Component Pascal compiler do not need to worry about reference counting. The compiler automatically generates calls of an object's AddRef and Release methods where necessary, and the compiler also automatically implements the AddRef and Release methods for interfaces implemented in Component Pascal. When a COM object is no longer used, it is automatically removed from memory. Components written in DTC Component Pascal become more reliable and maintainable. In Component Pascal, the above example looks as follows: VAR factory: IFactory; animal1, animal2: IAnimal; hr: COM.RESULT; BEGIN hr := GetFactory(COM.ID(IFactory), factory); IF hr >= 0 THEN hr := factory.CreateInstance(NIL, COM.ID(animal1), animal1); IF hr >= 0 THEN animal2 := animal1; animal2.Sleep(); hr := factory.CreateInstance(NIL, COM.ID(animal1), animal1); IF hr >= 0 THEN animal1.Eat() END END END END Calls to the reference counting methods are generated for assignments to interface pointer variables. The garbage collector recognizes COM interface implementations and does not remove such objects with a reference count greater than zero. If the garbage collector finds a COM interface object with reference count zero, then all interface pointers stored in this object are released before the object is collected. The same holds for local variables if the scope is left and for global variables that are stored in a component to be unloaded. This automatic garbage collection mechanism just generates code that would have to be written manually in any case. Thus it does not require any extra run time and is fully compatible with other components, created with other tools. The DTC compiler is integrated in the development environment BlackBox. The debugger allows to inspect components and objects on a symbolic level. In order to browse through dynamic memory, you use hypertext links to follow pointers. Effective support for COM in Component Pascal requires special language constructs, e.g. to specify the unique id of a COM interface. We clearly separate these language extensions from the core language. The reason is that such interfacing features should and need not be used in normal Component Pascal modules, and moreover, COM is only one of an increasing number of object models which could be supported. Modules using the special language constructs must flag this fact in the module header. If you look at the beginning of a module source, it should immediately be clear whether this is an (unportable) module and whether it is unsafe or not. We already have followed this principle in earlier products: system flags and other similar features are only allowed in modules which import the pseudo-module SYSTEM. This module and the necessary compiler extensions are not considered part of the language definition proper. In a similar vein, a pseudo-module COM needs to be imported in order to make the special COM features available in a module. This module is not considered a part of Component Pascal itself. To quote Prof. N. Wirth from the ETH technical report #82 (From Modula to Oberon): "It appears preferrable to drop the pretense of portability of programs that import a "standard", yet system-specific module. Both, the module SYSTEM and the type transfer functions are therefore eliminated, and with them also the types ADDRESS and WORD. Individual implementations are free to provide system-dependent modules, but they do not belong to the general language definition. Their use then declares a program to be patently implementation-specific, and thereby non-portable." In this spirit, procedural DLLs and COM DLLs are system-specific. A software system should minimize the number and size of modules directly using them, and encapsulate the latter such that their module interfaces only use the core Component Pascal features wherever possible (abstraction!). For this reason it is considered good software engineering practice to structure the implementation of a complex COM object such that the number of objects (and their modules) that contain references to interfaces are minimized and they are concentrated at the "top" and "bottom" of the module hierarchy, so that the intermediate layer consists of pure Component Pascal modules which don't use any special COM features: This leads to a module structure such as the following, where the top-level module implements the COM interfaces (export), the bottom-level modules implement access to existing COM interfaces (import), while the intermediate modules are implemented in portable, safe, and non-COM-specific modules: COM Compiler Extensions The compiler features added in order to support COM are modest. In particular, new sysflags for interface records and VAR parameters have been defined and union records are provided. Some additional types and functions are defined in the pseudo module COM. In order to access these extended facilities, the pseudo module COM must be imported. In the following, the special COM extensions are explained. COM Sysflags for Interface Structures Interface records are marked by the interface sysflag or by a GUID (globally unique identifier) flag. The GUID string must be a valid GUID constant spelled out in hex and wrapped in braces. TYPE IExample = POINTER TO ABSTRACT RECORD ["{91C074A1-C2D7-11CF-A4A1-444553540000}"] (COM.IUnknown) END; PROCEDURE (e: IExample) MethodA(): COM.RESULT, NEW, ABSTRACT; Instead of an explicit GUID, an interface record can also be marked with the interface sysflag. Such interfaces however cannot be requested through a QueryInterfacecall as they have no identifier. They can be used to implement outgoing interfaces which are not explicitely requested. TYPE IExample = POINTER TO ABSTRACT RECORD [interface] (COM.IUnknown) END; PROCEDURE (e: IExample) MethodA(): COM.RESULT, NEW, ABSTRACT Interface records and interface pointers must be (direct or indirect) extensions of COM.IUnknown. Interface records must be abstract and therefore must not contain any fields. Procedures bound to interface records must also be abstract. Abstract records cannot be allocated. The only legal usage of an interface record is as a record or pointer base type or as type of an interface pointer variable. An implementation extension of an interface must overwrite all abstract procedures bound to the interface record. Exceptions are the procedures defined by COM.IUnknown: The following example defines an implementation of the IExample interface. By convention, type names of interface pointers start with an I, and type names of (implementing) classes with a C. TYPE CExample = POINTER TO RECORD (IExample) END; PROCEDURE (e: CExample) MethodA(): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END MethodA; COM Sysflags for VAR Parameters [nil] The nil flag for VAR parameters indicates that NIL may also be used as an actual parameter. With the function VALID (see below) it can be tested whether an actual VAR parameter is valid, i.e. is not NIL. If the actual parameter is not valid (i.e. is NIL), then it must neither be read nor written. It may only be passed as actual parameter for another nil-parameter. Attempts to read or write an invalid nil parameter leads to a NIL dereference trap. [new] [iid] The iid and new VAR parameter flags allow to specify polymorphic out parameters. They allow to implement QueryInterface-like operations. The new and iid parameters must always be paired in a parameter list. A new parameter must be followed by a corresponding iid parameter or vice versa. A parameter list may contain only one new-iid pair. The iid parameter must be an IN parameter of type GUID, and the new parameter must be an OUT parameter of an interface type. The type passed as iid parameter defines the static type of the polymorphic out parameter. The dynamic type of the out parameter can be a subtype of the asserted static type. The actual parameter passed for the interface parameter may be a base type of the asserted static type and may be an extension of the formal parameter. In other words, the following relation must be satisfied for the actual parameters of a polymorphic out parameter (<= refers to the subtype relation) type of formal new parameter <= static type of actual new parameter <= type specified through iid parameter <= dynamic type of actual new parameter (on return) The following program fragment shows some examples of the use of polymorphic out parameters. TYPE IExample = POINTER TO ABSTRACT RECORD ["{91C074A1-C2D7-11CF-A4A1-444553540000}"] (COM.IUnknown) END; IExample2 = POINTER TO ABSTRACT RECORD ["{91C074A2-C2D7-11CF-A4A1-444553540000}"] (IExample) END; PROCEDURE GetInterface(IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown); END GetInterface; PROCEDURE Test; VAR i0: COM.IUnknown; i1: IExample; i2: IExample2; BEGIN GetInterface(COM.ID(i1), i0); (* valid *) GetInterface(COM.ID(i1), i1); (* valid *) GetInterface(COM.ID(i1), i2); (* compiler error: wrong [iid] - [new] pair *) END Test; A procedure like PROCEDURE QueryInterface (IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown); can be called in four different ways: - QueryInterface(COM.ID(p1), p0) where p0 is an extension of COM.IUnknown and p1 is an extension of p0. VAR i1: IExample; i2: IExample2; QueryInterface(COM.ID(i2), i1); - QueryInterface(COM.ID(T), p) where p is an extension of COM.IUnknown and T is a subtype of the type of p. VAR i1: IExample; QueryInterface(COM.ID(IExample2), i1); - QueryInterface(id, p) where id is an arbitrary GUID and p is of type COM.IUnknown. VAR p: COM.IUnknown; QueryInterface("{91C074A1-C2D7-11CF-A4A1-444553540000}", p); - QueryInterface(id, int) where id and int are another [iid], [new] pair. PROCEDURE P (IN [iid] id: COM.GUID; OUT [new] int: COM.IUnknown); BEGIN QueryInterface(id, int) END P; In a procedure with an iid-new parameter pair, the interface parameter cannot be assigned directly, but id and int can be used as formal parameters to another [new], [iid] pair or to COM.QUERY (see below). The Module COM The module COM contains certain types and procedures that are necessary to implement COM components. As module SYSTEM, module COM is a pseudo module, i.e., no symbol file exists for module COM. If module COM is imported, this is only a declaration for the compiler. A pseudo description of the interface is shown below: DEFINITION COM; TYPE RESULT = INTEGER; GUID = ARRAY 16 OF BYTE; (* modified compare semantics *) IUnknown = POINTER TO ABSTRACT RECORD ["{00000000-0000-0000-C000-000000000046}"] (this: IUnknown) QueryInterface (IN [iid] iid: GUID; OUT [new] int: IUnknown): RESULT, NEW, ABSTRACT; (this: IUnknown) AddRef, NEW, ABSTRACT; (* hidden, can neither be called nor overwritten *) (this: IUnknown) Release, NEW, ABSTRACT; (* hidden, can neither be caled nor overwritten *) (this: IUnknown) RELEASE-, NEW, EXTENSIBLE; END; PROCEDURE QUERY (p: IUnknown; IN [iid] id: GUID; OUT [new] ip: IUnknown): BOOLEAN; PROCEDURE ID (t: INTERFACETYPE): GUID; PROCEDURE ID (p: IUnknown): GUID; PROCEDURE ID (s: ARRAY OF CHAR): GUID; END COM. TYPE RESULT Result type of most COM operations (alias of INTEGER). The error translator of the Direct-To-COM development environment can be used to obtain a meaningful description from such a result. TYPE GUID Type for globally unique identifiers (GUIDs). A GUID is a 128 bit identifier. String constant expressions representing a valid GUID can be assigned to a GUID variable. VAR id: COM.GUID; id := "{12345678-1000-11cf-adf0-444553540000}"; TYPE IUnknown COM Interface, ABSTRACT The type IUnknown is the base type of all COM interfaces. IUnknown is a pointer to an abstract record. PROCEDURE (this: IUnknown) AddRef; NEW, HIDDEN PROCEDURE (this: IUnknown) Release; NEW, HIDDEN The AddRef and Release methods are necessary to control the reference count of a COM object. AddRef and Release are always handled implicitly, they can neither be overwritten nor called. PROCEDURE (this: IUnknown) QueryInterface (IN [iid] iid: GUID; OUT [new] int: IUnknown): RESULT; NEW, DEFAULT QueryInterface is used to ask for interfaces a COM object supports. It is implemented by default but may be overwritten if special behaviour is needed (e.g. for objects which support several interfaces). For an example see module ComObject. The default implementation of QueryInterface has the following form. The pointer this.outer is a hidden reference to another COM object which can be specified with the two-argument NEW procedure (see below). PROCEDURE (this: IUnknown) QueryInterface ( IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; BEGIN IF this.outer # NIL THEN RETURN this.outer.QueryInterface(iid, int) ELSE IF COM.QUERY(this, iid, int) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END END END QueryInterface; PROCEDURE (this: IUnknown) RELEASE-; NEW, EMPTY The RELEASE method is called whenever the reference cout drops from one to zero. Note that if the system calls the RELEASE method, the interface is not necessarily removed by the garbage collector as Component Pascal pointer references to the object may still exist. RELEASE gives additional control over COM objects besides the FINALIZE method which is provided for all (tagged) Component Pascal records. In contrast to the FINALIZE method, the RELEASE method may be called several times. PROCEDURE ID (t: INTERFACETYPE): GUID The actual parameter must be the name of a type. Returns the GUID associated with interface type t (pointer or record). PROCEDURE ID (p: IUnknown): GUID Returns the GUID associated with the static type of the actual parameter passed for p. PROCEDURE ID (s: ARRAY OF CHAR): GUID Returns the GUID from a textual representation (string constant). PROCEDURE QUERY (p: COM.IUnknown; IN [iid] id: COM.GUID, OUT [new] ip: COM.IUnknown): BOOLEAN; QUERY allows safe assignments to polymorphic out parameters. If there exists a type t with the following properties: - t is an interface type - p points to an extension of t - ID(t) = id then p is assigned to ip and the function returns TRUE. Otherwise ip remains unchanged and the function returns FALSE. COM.QUERY allows safe and simple implementations of QueryInterface without any restrictions. New Predefined Procedures In the Direct-To-COM compiler the following additional predefined procedures are available. Function procedures VALID (v: VARPAR): BOOLEAN; v (a VAR [nil] parameter) is not nil Proper procedures NEW(VAR p: COM.IUnknown); allocates p^ NEW(VAR p: COM.IUnknown; outer: COM.IUnknown); allocates p^ as subobject of outer The two-argument version of NEW is used when implementing aggregation (see example ComAggregate) or to implement COM objects supporting several interfaces (see example ComObject). AddRef, Release, and QueryInterface calls are forwarded to the outer object. If AddRef or Release of p is called, then both the reference count of p and of the outer interface are incremented or decremented respectively. Unions In order to simplify the mapping of C data structures, the Direct-To-COM compiler supports union records. In a union record all fields are aligned at offset 0. The size of a union record is the maximal size of its fields. The semantics of union records are the one of C union structures and not the one of Pascal-like variant records. With nested records and union records, Pascal-like variant records can be simulated also. A union record is marked with the union sysflag. Example: TYPE Complex = RECORD type: SHORTINT; u: RECORD [union] cart: RECORD x, y: LONGREAL END; polar: RECORD phi, rho: LONGREAL END END END Warning: pointers in union records are unsafe and are ignored by the garbage collector! COM Programming Hints If you want to free an interface explicitly for some reason, just assign NIL to the interface pointer. This will call Release() on the pointer and additionally prevents you from using the (no longer valid) pointer accidentally. The golden rule of COM programming in Component Pascal: Never use an interface pointer if you can use a Component Pascal pointer instead. Although interface pointers are safely handled by the compiler, there are still unsafe constructs which must be handled carefully. This specifically applies to C pointers which are not interface pointers, like pointers to strings. The lifecycle of such pointers must be controlled by explicit Allocate and Deallocate calls. It also applies to structures containing C-style unions. Pointers in such structures (including interface pointers) must be handled manually. See the ComTools documentation for an example of how such a structure can be used safely. Compiler Implementation Restrictions - Untagged open arrays (arrays with unspecified length) containing interface pointers may not be assigned as a whole. Workaround: Assign the individual elements. - The array supplied for an out parameter of type "untagged array of interface pointer" may not be open. Workaround: Use an array with defined length. - Out parameters of type "untagged open array of pointer" are not initialized to NIL. Workaround: Initialize them manually.

Com/Docu/DTC-Comp.odc

Direct-To-COM Compiler The Integrated Development Environment Contents Linker InterfaceBrowser COMInterfaceInspector OtherCOMCommands Besides the compiler (which is described in COM Compiler Extension documentation), the DTC development environment offers some special facilities. Most of them are accessible through the COM menu. Linker With the linker Component Pascal modules can be linked to DLL (in process servers) or to EXE (out of process servers) files. Furthermore it can be decided whether a dynamic module loader should be added or not. This leads to the following four link commands: EXE DLL unextensible DevLinker.LinkExe DevLinker.LinkDll extensible DevLinker.Link DevLinker.LinkDynDll For further information about the linker we also refer to the DevLinker Documentation. DevLinker.Link This command links a module set containing a dynamic module loader to an EXE file. At startup the body of the main module is called. Initialization and termination of the dynamically loaded modules must be done by the runtime system. DevLinker.LinkExe This command links an nonextensible module set to an EXE file. At startup the bodies of all modules are called in the correct order. If the last body terminates, the terminators of all modules are called in reverse order. No runtime system is needed for initialization and termination. For an example see ComKoalaExe. DevLinker.LinkDll This command links a non-extensible module set to a DLL file. When the DLL is attached to a process, the bodies of all modules are called in the correct order. When the DLL is released from the process, the terminators of all modules are called in reverse order. No runtime system is needed for initialization and termination. For an example see ComKoalaDll. DevLinker.LinkDynDll (rarely used, present for completeness) Links a module set containing a dynamic module loader to a DLL file. When the DLL is attached to a process, the body of the main module is called. When the DLL is released from the process, the terminator of the main module is called. Initialization and termination of the dynamically loaded modules must be done by the runtime system. Interface Browser To quickly retrieve the actual definition of an interface, a special interface browser is available under the menu command COM->Interface Info. In contrast to the BlackBox browser, the COM interface browser displays additional information such as the number of the functions in the interface. Note that the first three entries of every interface are used by the functions of the IUnknown interface. If you select WinOle.IEnumUnknown and execute COM->Interface Info the following window is opened: COM Interface Inspector The COM interface inspector is the most important tool for the development of COM objects. It allows to inspect all currently allocated interface records. The browser is opened with the command COM->Show Interfaces. For every interface the actual value of its reference count is displayed. After the name and the address of an interface, a diamond mark allows to follow the pointer to the record to which it points (by clicking on the diamond mark). If the interface is anchored globally through a Component Pascal reference, the global anchor is also shown. With the Update link the interface inspector can be updated, and the All link allows to toggle between the display of all interfaces and of only the non-BlackBox-internal ones. Interfaces with reference count zero are no longer referenced through an interface pointer, however they might still be referenced by a Component Pascal pointer. Interfaces which are neither referenced through an interface pointer nor through a Component Pascal pointer are garbage collected upon the next run of the garbage collector. The run of the garbage collector can be enforced through the menu command COM->Collect. The collected interfaces disappear when the interface inspector is updated. Note: If you look at the ComObject example, you will see that every ComObject.Object interface contains Component Pascal pointers to the three interfaces ComObject.IOleObject, ComObject.IDataObject and ComObject.IPersistStorage, i.e. they are not removed by the garbage collector as long as interface pointers refer to a ComObject.Object. Other COM Commands Show Error Almost all COM and OLE API functions and nearly every interface method returns a value of type COM.RESULT. COM.RESULT is an alias type to INTEGER. A result code consists of a severity bit (success or error), a facility code and an error code. If result >= 0, then it is a success code, otherwise it is an error code. The menu command COM->Show Error can be used to obtain a full text description of the selected result. As input a selected integer is taken. The integer may be given in decimal or hexadecimal notation. E.g. if you select 1236 and execute COM->Show Error, the following window is opened: For the use in programs the most common error codes are defined in module WinApi. New GUID The command COM->New GUID generates a text which contains 10 interface GUIDs. It calls the OLE procedure CoCreateGuid. Collect The command COM->Collect explicitly calls the garbage collector.

Com/Docu/DTC-Env.odc

Map to the Direct-To-COM Compiler Documentation Introduction Direct-To-COM Compiler Tutorials TheComponentObjectModel HowtoDevelopnewCOMObjects TheDirect-To-COMCompiler Direct-To-COMExamples TheDevelopmentEnvironment Related Documentation ComponentPascelLanguageReport Platform-SpecificIssues BlackBoxDocumentation WindowsProgrammingInterfaces

Com/Docu/DTC-Help.odc

Direct-To-COM Compiler How to Develop new COM Objects This text gives an overview of the typical way in which new OLE objects are developed. It summarizes the most important aspects of what is detailed in the BlackBox user's guide. BlackBox is the integrated development environment (IDE) for the Direct-To-COM Component Pascal compiler with Safer OLE technology. In a first step, a subsystem name for the project is chosen, and a suitable directory created (with its Code, Mod, and Sym directories). This directory must be in the BlackBox directory itself, i.e. at the same location where the System, Std, etc. directories are. Note that there are no environment variables or path name lists in BlackBox. File lookup is static and determined by module names, not by configurable search paths or similar constructs. It can be convenient to provide a subsystem for private software, like test modules or personal tool commands, e.g. a subsystem Priv. It is helpful to set up a text document which contains the names of all the subsystem's modules, starting with the one lowest in the module hierarchy. Such a tool text can be used as input to the Dev->OpenModuleList command. This command opens the source file of the module whose name is selected. This is convenient since it can almost eliminate the need to navigate through the directory hierarchy. As a mnemonic aid, the keyboard equivalent for Dev->OpenModuleList is the digit "0", while the keyboard equivalent of the File->Open... command is the letter "O". Dev->OpenModuleList even allows to open several files at the same time, if the selection includes several module names. Now you are ready to create the module sources, which should be placed in your subsystem's Mod directory. In order to take advantage of autoindentation, you should use tab characters for indentation. You can directly compile the module on which you are working with the Dev->Compile command. This command compiles, but does not yet load, the module. The command Dev->CompileModuleList takes a list of module names and compiles them all. In order to load the module, you can execute one of its exported parameterless procedures, either by executing the Dev->Execute menu command on the command's name (e.g. on Dialog.Beep), or you can augment your tool text with commanders, e.g. Dialog.Beep (execute Tools->InsertCommander). Once loaded, a module remains loaded, unless you explicitly unload it. Unloading can be done by executing Unload when the source code is focused, or by selecting a module name and calling Dev->UnloadModuleList. This command also works on a sequence of module names, similar to Dev->CompileModuleList. Note that modules must be unloaded from top to bottom, since only modules which are not imported anymore may be unloaded. The loaded modules are displayed in the correct order by the command Info->Loaded Moules. This command opens a text which lists all loaded modules. The command Dev->Unload Module List may directly be called on a selection in this text. In this text, top-level modules, i.e. modules which are not imported by other modules, have a clients count of 0. For the unloading of top-level modules, there is a shortcut if you use a commander: ctrl-click on the commander first unloads the old version of the module, then loads the new version, and then calls the procedure. In order to get quick access to a module's definition or documentation, you can use the commands Info->Interface, or Info->Documentation, respectively. Info->Interface calls the browser to construct a definition text out of a module's symbol file. Note that in this text you can select further module names (or names of imported constants, variables, types, or procedures) and get the interface of those by calling the same command again. If there is a documentation file available for a module, you can execute Info->Documentation after selecting the module's name. This command opens the documentation text. If you have selected not only the module name (e.g. Math) but an object of this module (e.g. Math.Sin), the command tries to find the first occurence of the object's name which is written in boldface. The name is selected, and the window scrolls to the selection's position. In the rare cases where this first occurence is not the one you need, you may call Text->FindAgain to search for the next occurence. In order to test a module, you can use module Out to write debugging output into the Log window. In order to set breakpoints, you can introduce HALT statements and recompile the module. The trap text which is opened when the HALT is reached gives you information about the call chain (stack) as it has been at the moment the command was interrupted. Note that at no point in time the normal BlackBox environment is left; debugging takes place completely inside BlackBox. It is recommended to check preconditions and important invariants systematically in all programs, using the ASSERT statement. This debugging strategy is called static debugging, since error conditions are specified statically (even though they can be checked only at run-time). In an object-oriented environment, where the control flow tends to become too convoluted to follow step-by-step, the systematic application of assertions proves to keep debugging times shorter than any interactive debugging ever could. There is a global menu configuration text. It can be opened with command Info->Menus, edited, and then made the current configuration by calling Info->UpdateMenus. A menu item may not only have an action command, but also a guard command. Guards mainly determine whether a menu item is currently enabled or disabled. Distribution of a COM object basically consists of distributing a linked EXE file (application) or a linked DLL (e.g. a control). How does the dynamic loading facility of BlackBox, as described above, relate to COM binaries? Basically, dynamic loading of individual modules is convenient during development, so you don't need a separate linking step every time before trying out a new version of your code. Only before distributing the code you need to link it into an EXE or DLL. For example, if you develop an OLE object as one Component Pascal module, you typically load the module by executing its command that registers the object with OLE. Then you switch to some other application which is an OLE client (i.e. a container), such as MS Word. There you can insert the new object and try it out. If you detect some erroneous behavior, close the document and return to BlackBox, i.e. to the OLE server. Unload the module, correct the error in the Component Pascal module(s), recompile, and then continue again with loading the new version of the module. When working in this way, in principle you can use all BlackBox features for debugging, e.g. the Out module which writes into the Log text, or the symbolic debugger of BlackBox. Only when you're completely satisfied with the object's behavior, you link it together into a DLL. Unfortunately, for historical reasons ActiveX controls are treated somewhat differently than ordinary OLE objects. For example, controls require the existence of a DLL. For you, this means that you need to link the program into a DLL after each modification and compilation of the sources. Furthermore, for testing you need a program which is a control container; normal OLE containers are not sufficient.

Com/Docu/DTC-HowTo.odc

Direct-To-COM Compiler Introduction COM Microsoft's Component Object Model (COM) is a language and compiler independent interface standard for object interoperability on the binary level. COM specifies how objects implemented in one component can access services provided by objects implemented in another component. The services provided by objects are grouped in interfaces, which are sets of semantically related functions. For example, an ActiveX control is a COM object that extends OLE, by implementing concrete implementations of the necessary OLE interfaces. COM makes it possible that an extended software component can be updated without invalidating extending components, e.g., a new release of OLE can be introduced without breaking existing ActiveX controls. In such an evolving, decentrally constructed system it is difficult to decide whether an object is still used or whether it can be removed from the system. The client of an object does not know whether other clients still have access to the same object, and a server does not know whether a client passed its reference to other clients. This lack of global knowledge can make it hard to determine whether an object is no longer referenced, and thus could be released. If an object is released prematurely, then unpredictable errors will occur. The problem is critical in component software environments, because an erroneous component of one vendor may destroy objects implemented by other vendors' components. It may even take some time until the destroyed objects begin to visibly malfunction. For the end user, it is next to impossible to determine which vendor is to blame. As a consequence, some form of automatic garbage collection mechanism must be provided. In contrast to closed systems, this is a necessity with component software, and not merely an option or a convenience feature. COM uses reference counting as a rather simple form of garbage collection. Whenever a client gets access to a COM object, it must inform the object that a new reference exists. As soon as the client releases the COM object, it must inform the object that a reference will disappear. A COM object counts its references and thus can control its own lifetime. Direct-To-COM Compiler The problem with reference counting is that it depends on the discipline of the programmer. The situation is aggravated by additional subtle rules about who is responsible for the management of the reference counts if COM objects are passed as function arguments. Reliable software construction requires the management of reference counts to be automated. The Direct-To-COM compiler for Component Pascal completely automates memory management. The compiler and its small run-time system (module Kernel) hides the reference counting mechanism, i.e., a program need not call nor implement the AddRef and Release methods. For programmers, the integration of COM into a strongly typed, garbage-collected language has two major advantages. Firstly, it brings all the amenities of automatic garbage collection to COM. Secondly, it makes the handling of COM interfaces typesafe. Getting Started How should you start to get acquainted with this product? Note that all documentation is available on-line, and can be reached from the help screen. After the Installation of the BlackBox Component Builder, we suggest that you start with the introduction text ABriefHistoryofPascal. Then move on to the chapters of the user guide which deal with text editing and with the development tools (TextSubsystem and DevSubsystem). After you thus have gained a working knowledge of BlackBox, it is time to delve into the COM-specific parts of the IDE and the Component Pascal compiler extensions for COM. The section HowtoDevelopnewCOMobjects (p. 20) summarizes the main points of the user guide as far as it pertains to COM development. Then proceed with the various example implementations of COM objects, which demonstrate all basic aspects of COM programming. Knowledge of the Windows APIs (e.g. OLE) is assumed. Further Reading We recommend the following books on COM, OLE and ActiveX: Kraig Brockschmidt, Inside OLE, 2nd Edition, Microsoft Press, 1995. David Chappell, Understanding ActiveX and OLE, Microsoft Press, 1996, ISBN 1-57231-216-5. Adam Denning, OLE Controls Inside Out, Microsoft Press, 1995. Dale Rogerson, Inside COM, Microsoft Press, 1997, ISBN 1-57231-349-8, Don Box, Creating Components with DCOM and C++, Addison Wesley, 1997. Microsoft COM Home Page, http://www.microsoft.com/com

Com/Docu/DTC-Intro.odc

ComEnum ComEnum is a library containing implementations for the following standard enumerators: - IEnumUnknown - IEnumString - IEnumFormatEtc - IEnumOleVerb To use one of the enumerators, import the corresponding creation procedure and call it with your actual data. PROCEDURE CreateIEnumFORMATETC (num: INTEGER; IN format: ARRAY OF INTEGER; IN aspect, tymed: ARRAY OF SET; OUT enum: WinOle.IEnumFORMATETC); Creates an IEnumFormatEtc enumerator with num entries. The enumerated entries (of type FORMATETC) are initialized from the values in format[i], aspect[i], and tymed[i]. PROCEDURE CreateIEnumOLEVERB (num: INTEGER; IN verb: ARRAY OF INTEGER; IN name: ARRAY OF ARRAY OF CHAR; IN flags, attribs: ARRAY OF SET; OUT enum: WinOle.IEnumOLEVERB); Creates an IEnumOleVerb enumerator with num entries. The enumerated entries (of type OLEVERB) are initialized from the values in verb[i], name[i], flags[i], and attribs[i]. PROCEDURE CreateIEnumString (num: INTEGER; IN data: ARRAY OF ARRAY OF CHAR; OUT enum: WinOle.IEnumString); Creates an IEnumFormatEtc enumerator with num entries. The enumerated entries (of type WinApi.PtrWSTR) are initialized from the strings in data[i]. PROCEDURE CreateIEnumUnknown (num: INTEGER; IN data: ARRAY OF COM.IUnknown; OUT enum: WinOle.IEnumUnknown); Creates an IEnumFormatEtc enumerator with num entries. The enumerated entries (of type IUnknown) are initialized from the values in data[i]. Alternatively, the source code of the module can be used as a starting point for customized implementations or implementations of other enumerators. ComEnumsources

Com/Docu/Enum.odc

ComEnumRect Example This is a simple example adapted form the same example in the book "Inside OLE". The interface IEnumRECT (an enumerator for rectangles) is defined and implemented in this module. The interface consists of the following four methods: IEnumRECT = POINTER TO ABSTRACT RECORD ["{00021140-0000-0000-C000-000000000046}"] (COM.IUnknown) (this: IEnumRECT) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinApi.RECT; OUT [nil] fetched: INTEGER): COM.RESULT, NEW, ABSTRACT; (this: IEnumRECT) Skip (num: INTEGER): COM.RESULT, NEW, ABSTRACT (this: IEnumRECT) Reset (): COM.RESULT, NEW, ABSTRACT; (this: IEnumRECT) Clone (OUT enum: IEnumRECT): COM.RESULT, NEW, ABSTRACT; END; For the implementation, an array of length 15 is used. As the interface is implemented in one record (EnumRECT), the default implementation for QueryInterface can be used. ComEnumRectsources

Com/Docu/EnumRect.odc

DevComInterfaceGen DEFINITION DevComInterfaceGen; IMPORT Dialog; VAR dialog: RECORD library: Dialog.List; fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR END; PROCEDURE Browse; PROCEDURE GenAutomationInterface; PROCEDURE GenCustomInterface; PROCEDURE BrowseTypeLib; PROCEDURE InitDialog; PROCEDURE Open; PROCEDURE Close; PROCEDURE ListBoxNotifier (op, from, to: INTEGER); PROCEDURE TextFieldNotifier (op, from, to: INTEGER); ... plus some private items ... END DevComInterfaceGen. Module DevComInterfaceGen provides services to automatically generate COM interface modules. Interface modules are used by BlackBox to access COM components in several different ways. One of them is Automation. Any application (server) supporting Automation can be controlled from within another application (controller). The interface of a server application, i.e., the objects provided by the application and the operations on these objects, are described in a COM type library. In order to write a controller in BlackBox, an interface module is used which contains a Component Pascal object for each COM object in the type library. These objects can be accessed like other Component Pascal objects in a convenient and typesafe way. They hide the details of the Automation standard. The Ctl subsystem includes several such Automation interface modules. (Basically for MS Office Automation servers.) Module DevComInterfaceGen provides services to automatically generate Automation interfaces from the corresponding type libraries. In certain situations, however, the automatically generated interface module does not compile without errors. Here some minimal manual work is required. So far we have encountered three kinds of difficulties that may occur: 1. Formal parameter name is equal to parameter type name. Solution: Change the formal parameter name in the parameter list and procedure body. 2. Formal parameter name is equal to return type name. Solution: Change the formal parameter name in the parameter list and procedure body. 3. Constant name is equal to some type name. Solution: Change constant name. VAR dialog: RECORD The interactor for the Generate Automation Interface dialog. library: Dialog.List A list representing all type library entries that are registered in the system's registration database. fileName: ARRAY 256 OF CHAR Complete path name of the type library. modName: ARRAY 64 OF CHAR Module name of the Automation interface module to be generated from the corresponding type library. PROCEDURE Browse Open a standard open file dialog box, to let the user choose a type library or DLL file. PROCEDURE GenAutomationInterface Generates the automation interface module according to the parameters in dialog. PROCEDURE GenCustomInterface Generates the custom interface module according to the parameters in dialog. PROCEDURE BrowseTypeLib Generates an interface module suitable for browsing the contents of the type library according to the parameters in dialog. PROCEDURE InitDialog Initializes the dialog interactor. PROCEDURE Open Calls InitDialog and opens the dialog if it was closed. Otherwise brings the dialog to front. PROCEDURE Close Closes the dialog and clears the state. PROCEDURE ListBoxNotifier (op, from, to: INTEGER) PROCEDURE TextFieldNotifier (op, from, to: INTEGER) Notifiers used by the Generate Automation Interface dialog.

Com/Docu/InterfaceGen.odc

ComKoala Example This example is one of the simplest COM examples. It provides a component which implements the IUnknown interface. In DTC Component Pascal, a concrete extension of the base interface must be defined. The two methods AddRef and Release are implemented by the compiler, and for QueryInterface, the default implementation can be taken. Thus, only the following two lines are necessary to implement this simple interface. TYPE Koala = POINTER TO RECORD (COM.IUnknown) END; A set of interfaces is implemented in a COM class. A COM class may be identified by a unique class identifier (CLSID) which is also a GUID. A run-time instantiation of a COM class is called a COM object. Each COM class is implemented in a COM server. The server is a piece of code compiled into an executable (EXE file) or into a dynamic link library (DLL file). For every COM class, the server must provide a factory object through which a new instance can be constructed. This factory object can be registered in the Windows registry. CONST KoalaId = "{00021146-0000-0000-C000-000000000046}"; (* the CLSID *) TYPE KoalaFactory = POINTER TO RECORD (WinOle.IClassFactory) END; The interface of the factory supports two methods: CreateInstance and LockServer. The methods of the IUnknown interface are again implemented by the compiler. Through CreateInstance new Koala objects are requested. The required interface of the new object is passed as parameter iid. The implementation simply creates a new Koala object (using NEW) and asks QueryInterface of the newly generated object to return the requested interface. PROCEDURE (this: KoalaFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: Koala; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN RETURN new.QueryInterface(iid, int) ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; In module ComKoalaTst some test routines are implemented which demonstrate the use of ComKoala and which in particular illustrate the usual szenario when creating COM objects. First, the ComKoala server must instantiate a class factory and register it with the command WinOle.CoRegisterClassObject under its CLSID. This is implemented in the command ComKoala.Register If you now look at the interface inspector you see that interface ComKoala.KoalaFactory is allocated and has a reference count of one (the reference in the registry). Now the client can request a pointer to the class factory by calling WinOle.CoGetClassObject. As second argument we specify that the local server (i.e. BlackBox) has to be used. Now the reference count of the factory has been incremented to two (the reference in the registry and the reference we just created). ComKoalaTst.CreateClass Through the factory object a Koala object can now be generated. The factory creates an instance of ComKoala.Koala and returns a pointer to the IUnknown interface. The interface browser now shows a new allocated interface. ComKoalaTst.CreateInstance With the commands ComKoalaTst.AddRef and ComKoalaTst.Release the number of references can be incremented or decremented. Look at the updated interface browser from time to time. Whenever the command CreateInstance is called again, a new instance is created. ComKoalaTst.AddRef ComKoalaTst.Release The factory reference which is held by module ComKoalaTst can be released with the command ComKoalaTst.ReleaseClass and the reference in the Windows registry is removed by calling WinOle.CoRevokeClassObject. The latter operation is implemented in the command ComKoala.Release Note that the two references to the factory can be released in any order. As soon as the registry reference is released, no new classes can be generated through WinOle.CoGetClassObject, and as soon as the factory reference in module ComKoalaTst is released, no new instances can be created. The implementation can also be tested with the ObjUser.exe program which is provided in the Inside OLE book. Before you can use it, you must register the factory (ComKoala.Register) and you must set the ObjUser.exe program in EXE mode. ComKoalasources ComKoalaTstsources

Com/Docu/Koala.odc

ComKoalaDll Example This version of the Koala example can be linked as an independent DLL. It can be tested with the ObjUser.exe program which is provided with the book "Inside OLE". Note that you have to set the ObjUser.exe program into DLL mode. The implementation of the DLL only slightly differs from the first ComKoala implementation. One difference is that a counter is provided which counts the number of instances. This counter is incremented whenever a new object is created (CreateInstance method), and it is decremented if the last interface reference is removed (RELEASE finalizer). Every in-process server must provide the two functions DllGetClassObject and DllCanUnloadNow. The first procedure is called whenever a factory is required, and with the second command it is tested whether the DLL can be unloaded. The DLL can be unloaded if no object generated by a factory of the DLL is referenced through an interface pointer and if no factory of the DLL was locked with the factory's LockServer method. This ComKoalaDll example can be linked to DKoala1.dll with the following command: DevLinker.LinkDll "Com/DKoala1.dll" := Kernel+ ComKoalaDll# ~ The registry must be informed about which DLL to launch if a IKoala factory is required. The necessary registry file Com/Reg/DKoala1.reg is given below. Use the REGEDIT tool to update the registry. Adjust path names if necessary! REGEDIT HKEY_CLASSES_ROOT\Koala1.0 = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala1.0\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\Koala = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala\CurVer = Koala1.0 HKEY_CLASSES_ROOT\Koala\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046} = Koala Object Chapter 5 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\ProgID = Koala1.0 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\VersionIndependentProgID = Koala HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\InprocServer32 = C:\BlackBox\Com\DKoala1.dll HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\NotInsertable ComKoalaDllsources

Com/Docu/KoalaDll.odc

ComKoalaExe Example This version of the Koala example can be linked as an independent exe. It can be tested with the ObjUser.exe program which is provided with the book "Inside OLE". Note that you have to set the ObjUser.exe program into EXE mode. The EXE file opens its application window which is closed as soon as the last interface pointer is released. It also must implement a main loop which polls and dispatches all Windows events. Additionally, the body of the module must register the factory upon start up and remove the factory from the registry as soon as the EXE is unloaded. The ComKoalaExe example can be linked to EKoala1.EXE with the following command: DevLinker.LinkExe "Com/EKoala1.exe" := Kernel+ ComKoalaExe ~ The registry must be informed about which program to start if a local server for our IKoala factory ({00021146-0000-0000-C000-000000000046}) is requested. The necessary registry fileCom/Reg/EKoala1.reg is given below. Use the REGEDIT tool to update the registry. Adjust path names if necessary! REGEDIT HKEY_CLASSES_ROOT\Koala1.0 = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala1.0\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\Koala = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala\CurVer = Koala1.0 HKEY_CLASSES_ROOT\Koala\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046} = Koala Object Chapter 5 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\ProgID = Koala1.0 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\VersionIndependentProgID = Koala HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\LocalServer32 = C:\BlackBox\Com\Ekoala1.exe HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\NotInsertable ComKoalaExesources

Com/Docu/KoalaExe.odc

ComKoala Example: ComKoalaTst Test program for ComKoala. There is no separate documentation.

Com/Docu/KoalaTst.odc

ComObject Example This example implements a simple OLE server which provides the following OLE object: This object implements the four interfaces IUnknown, IOleObject, IDataObject and IPersistStorage and uses several other interfaces. Beside of this, the module also implements a factory object which can be registered and which provides the creation of new objects of the above type. In order to implement the four interfaces, four Component Pascal records are defined as subtypes of the particular interface records. These objects refer to each other in the following way: The record which implements the IUnknown interface contains the object data. The references to the other interface records are necessary in order to implement the QueryInterface method. The other interfaces need a reference to the IUnknown object to access the object data as well as to implement their QueryInterface. Note that other definitions would be possible also. Instead of such a symmetric approach, the interface IOleObject could play the role of the main interface and administrate the object's instance variables. Object = POINTER TO RECORD (COM.IUnknown) ioo: IOleObject; ido: IDataObject; ips: IPersistStorage; (* and other fields *) END; IOleObject = POINTER TO RECORD (WinOle.IOleObject) obj: Object END; IDataObject = POINTER TO RECORD (WinOle.IDataObject) obj: Object END; IPersistStorage = POINTER TO RECORD (WinOle.IPersistStorage) obj: Object END; Object creation New objects are created through the method CreateInstance of the class factory. This method allocates the objects, defines the relation between the involved interfaces and returns a pointer to the requested interface. The implementation of the QueryInterface method of the three interfaces IOleObject, IDataObject and IPersistStorage is simplified by using hidden references to the main record. These hidden references are generated with the two-argument NEW. VAR new: Object; NEW(new); NEW(new.ioo, new); NEW(new.ido, new); NEW(new.ips, new); new.ioo.obj := new; new.ido.obj := new; new.ips.obj := new; All QueryInterface calls are thus forwarded to the QueryInterface method of Object. The explicit references to Object are only used to access the instance variables of the object. Instance variables which would be used by the implementation of one interface only could also be stored in the corresponding record directly. If one of the interfaces IOleObject, IDataObject or IPersistStorage is requested through QueryInterface, then the reference count of the particular record as well as the reference count of the main object is incremented. The latter one is incremented since the requested interface contains a (hidden) reference to the main object. As an alternative, the four records could also be allocated with the one-argument NEW, but then QueryInterface calls would have to be forwarded to the main object by hand for the implementations of the interfaces IOleObject, IDataObject and IPersistStorage. The following procedure shows how that would be done. PROCEDURE (this: IOleObject) QueryInterface (VAR iid: COM.GUID; VAR int: COM.IUnknown): COM.RESULT; BEGIN RETURN this.obj.QueryInterface(iid, int) END QueryInterface; QueryInterface The second interesting aspect is the implementation of QueryInterface of Object. For all the interfaces that the object supports, the COM.QUERY function is called one by one. If the IUnknown interface is requested, then always the same interface pointer is returned, although all involved interfaces support the IUnknown methods. This is a requirement of the COM specification. PROCEDURE (this: Object) QueryInterface (IN iid: COM.GUID; OUT int: COM.IUnknown): COM.RESULT; BEGIN IF COM.QUERY(this, iid, int) OR COM.QUERY(this.ioo, iid, int) OR COM.QUERY(this.ido, iid, int) OR COM.QUERY(this.ips, iid, int) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END Registry With the command ComObject.Register the factory can be registered. As soon as it is registered it can be requested with a call to the procedure CoGetClassObject (it has to be requested from a local server, namely the running BlackBox). VAR factory: WinOle.IClassFactory; res: COM.RESULT; res := WinOle.CoGetClassObject("{00010001-1000-11cf-adf0-444553540000}", WinOle.CLSCTX_LOCAL_SERVER, 0, COM.ID(factory), factory) If the object is also registered in the Windows registry, then the object can be inserted in any OLE container using the Insert Object menu entry, provided that the factory has been registered using the command ComObject.Register. The necessary registry file Com/Reg/Object.reg is given below. Use the REGEDIT tool to update the registry. Adjust path names if necessary! Note that you cannot insert it into a BlackBox document of the BlackBox which is the server for this object, because then the object would be inserted in-process, and thus the in-process handler would not be used. However, you can insert this object in a document of another running BlackBox. Once the smiley object has successfully been inserted into an OLE container, you can inspect with the interface inspector how many interfaces the client has requested. REGEDIT HKEY_CLASSES_ROOT\BlackBox.Object = BlackBox Object HKEY_CLASSES_ROOT\BlackBox.Object\CLSID = {00010001-1000-11cf-adf0-444553540000} HKEY_CLASSES_ROOT\BlackBox.Object\Insertable HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000} = BlackBox Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\ProgID = BlackBox.Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\LocalServer32 = C:\BlackBox\BlackBox.exe HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\InProcHandler32 = ole32.dll HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\Insertable HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\DefaultIcon = C:\BlackBox\BlackBox.exe,0 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\DataFormats\GetSet\0 = 3,1,32,1 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\MiscStatus = 16 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\AuxUserType\2 = BlackBox Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\AuxUserType\3 = BlackBox It would also be possible to generate a new executable which acts as server for this BlackBox object. You find a similar example in ComKoalaExe. In particular, the main event loop has to be implemented. If you intend to link this object implementation into a DLL, then the additional interfaces IViewObject2, IOleCache2, and IRunnableObject would have to be implemented. ComObjectsources

Com/Docu/Object.odc

ComPhoneBook Example In this example we show the implementation of a COM component which implements a simple phone directory database that manages customer names and telephone numbers. This database can be queried by name and by number. For our phone directory service we define the interface ILookup. This interface contains the methods LookupByName and LookupByNumber, which return a phone number for a given name, and vice versa. Clients of the phonebook component can access the component's services through this interface only. The interface identifier (IID) of this interface is {C4910D71-BA7D-11CD-94E8-08001701A8A3}. This IID is a globally unique identifier (GUID), i.e., unique in time and space. The definition of this interface ILookup.idl in the Microsoft interface definition language (MIDL) is shown below: [ object, uuid(c4910d71-ba7d-11cd-94e8-08001701a8a3), pointer_default(unique) ] interface ILookup : IUnknown { import "unknwn.idl"; HRESULT LookupByName([in] LPTSTR lpName, [out, string] WCHAR **lplpNumber); HRESULT LookupByNumber([in] LPTSTR lpNumber, [out, string] WCHAR **lplpName); } In the DTC Component Pascal, this interface is defined as an abstract extension of COM.IUnknown marked by its IID. The compiler does prohibit instantiation of objects of this type, and it does also prohibit implementation of the abstract methods, but variables of type ILookup can be used as interface pointers as we will see later. TYPE ILookup* = POINTER TO ABSTRACT RECORD ["{C4910D71-BA7D-11CD-94E8-08001701A8A3}"] (COM.IUnknown) END; PROCEDURE (this: ILookup) LookupByName*( name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: ILookup) LookupByNumber*( number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; The implementation of the phone book directory interface is an extension of the abstract interface record ILookup. The phone book is represented as a linear list. The root of the list is stored as private data in the interface record. The two methods LookupByName and LookupByNumber implement a simple linear search. If no entry is found, a special error code is returned. Module ComTools offers auxiliary routines to convert e.g. strings from and to Windows data structures. TYPE CLookup = POINTER TO RECORD (ILookup) phoneBook: Entry END; Entry = POINTER TO RECORD next: Entry; name, number: ARRAY 32 OF CHAR END; To allow access to instances of this COM class, a factory object needs to be provided. The CreateInstance method creates a new object, initializes it and returns the requested interface (in this example this might be the interface IUnknown or ILookup). Note, that the implementation of the interface is usually not exported, only the CLSID must be known in order to create new instances of this class. The procedures ComPhoneBook.Register and ComPhoneBook.Unregister can be used to register a reference of the factory object in the COM library, from where it can be requested using the CLSID. CONST CLSID* = "{E67D346C-2A5B-11D0-ADBA-00C01500554E}"; TYPE LookupFactory = POINTER TO RECORD (WinOle.IClassFactory) END; In module ComPhoneBookClient the implementation of a simple client of the phone directory is given. With the Windows procedure CoCreateInstance a new instance of the phone directory object is created. If the creation is successful, a pointer to the interface ILookup is assigned to the interface pointer phoneBook, through which the methods LookupByName and LookupByNumber can be called. The combo box shown in the figure below can be opened with the command "StdCmds.OpenToolDialog('Com/Rsrc/PhoneBook', 'PhoneBook')" Through this mask, the phone directory can be accessed. It is also possible to use this interface across process boundaries. For this purpose, however, marshalling code must be provided in proxy and stub objects, and the reference to the DLL which implements the proxy and stub objects must be registered in the Windows registry. The proxy and stub code can be generated with the MIDL compiler based on the interface description in the Microsoft interface definition language. The MIDL compiler generates C source code. For the ILookup interface all necessary files are provided in the directory Com/Interfaces/Lookup. The generated DLL is a self registering DLL, i.e., you have to execute the program REGSVR32 on this DLL in order to register it. Once the proxy and stub DLLs have been registered, it is possible to communicate across process boundaries. You can test this if you start BlackBox in two separate processes, register the factory object in one process using the command ComPhoneBook.Register and look for phone book entries in the other process through the dialog "StdCmds.OpenToolDialog('Com/Rsrc/PhoneBook', 'PhoneBook')". If you have DCOM installed, then the two Component Pascal programs can even run on two different machines. The parameter in the call of procedure WinOle.CoCreateInstance needs then to be adjusted. ComPhoneBooksources

Com/Docu/PhoneBook.odc

ComPhoneBookActiveX Example In this example a simple ActiveX control is implemented. The control offers the same functionality as the phone book in the ComPhoneBook example, but in this example, clients communicate through a dispatch interface. The control will be linked into a DLL and can be used as an ActiveX control from any client which properly supports the ActiveX standard. The dispatch interface also has to be described in a MIDL definition. This definition is stored in file Phone.idl and shown below: [ uuid(C4910D73-BA7D-11CD-94E8-08001701A8A3), version(1.0), helpstring("PhoneBook ActiveX Control") ] library PhoneBookLib { importlib("stdole32.tlb"); [ uuid(C4910D72-BA7D-11CD-94E8-08001701A8A3), helpstring("Dispatch interface for PhoneBook ActiveX Control") ] dispinterface DPhoneBook { properties: methods: [id(1)] BSTR LookupByName(BSTR name); [id(2)] BSTR LookupByNumber(BSTR number); }; [ uuid(E67D346B-2A5B-11D0-ADBA-00C01500554E), helpstring("PhoneBook ActiveX Control") ] coclass PhoneBook { [default] dispinterface DPhoneBook; }; } With the MIDL compiler, a type library is generated. Once this library has been registered in the Windows registry it can be inspected with the OLE ITypeLib Viewer. In DTC Component Pascal, this interface is defined as an abstract extension of WinOleAut.IDispatch, the base type of all dispatch interface. This interface contains the following four methods which must be implemented: TYPE IDispatch = POINTER TO ABSTRACT RECORD ["{00020400-0000-0000-C000-000000000046}"] (COM.IUnknown) (this: IDispatch) GetIDsOfNames (IN [nil] riid: COM.GUID; IN [nil] rgszNames: WinApi.PtrWSTR; cNames: INTEGER; lcid: WinOle.LCID; OUT [nil] rgDispId: WinOleAut.DISPID): COM.RESULT, NEW, ABSTRACT; (this: IDispatch) GetTypeInfo (iTInfo: INTEGER; lcid: WinOle.LCID; OUT [nil] ppTInfo: WinOleAut.ITypeInfo): COM.RESULT, NEW, ABSTRACT; (this: IDispatch) GetTypeInfoCount (OUT [nil] pctinfo: INTEGER): COM.RESULT, NEW, ABSTRACT; (this: IDispatch) Invoke (dispIdMember: WinOleAut.DISPID; IN riid: COM.GUID; lcid: WinOle.LCID; wFlags: SHORTINT; VAR [nil] pDispParams: WinOleAut.DISPPARAMS; OUT [nil] pVarResult: WinOleAut.VARIANT; OUT [nil] pExcepInfo: WinOleAut.EXCEPINFO; OUT [nil] puArgErr: INTEGER): COM.RESULT, NEW, ABSTRACT END; The implementation of this interface is a concrete extension of the abstract dispatch interface. The main method is the Invoke method. Through this method the functions of the interface are called. The number of the function to be invoced is passed in parameter dispIdMember, and the parameters are passed in the array pDispParams as variant records. The result is returned through parameter pVarResult, a variant record as well. The other three methods of this interface provide information about the interface itself. They can easily be implemented if a type library is available. Besides the implementation of the dispatch interface, a factory object must be provided. Furthermore, the two global functions DllGetClassObject and DllCanUnloadNow have to be implemented. These two routines are called by the COM library. If the DLL is loaded it is asked to return a reference to the factory object, and with the function DllCanUnloadNow the COM library tests whether the DLL can be unloaded. If module ComPhoneBookActiveX has been compiled, a DLL can be linked with the command DevLinker.LinkDll "Com/phone.dll" := Kernel+ ComTools ComPhoneBookActiveX# ~ This command generates a DLL with a size of 40KBytes only. In order to load this DLL it must be registered in the Windows registry. Note, that the CLSID for this implementation is different than the CLSID of example ComPhoneBook. Besides the CLSID, the information about the type library must be stored in the registry, and in particular the CLSID entry must contain a reference to the GUID under which the type library is referenced. The necessary registry file Com/Interfaces/DPhoneBook/Phone.reg is given below. Use the REGEDIT tool to update the registry. Adjust path names if necessary! REGEDIT HKEY_CLASSES_ROOT\PhoneBook = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\PhoneBook\CLSID = {E67D346B-2A5B-11D0-ADBA-00C01500554E} HKEY_CLASSES_ROOT\PhoneBook\TypeLib = {C4910D73-BA7D-11CD-94E8-08001701A8A3} HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E} = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\ProgID = PhoneBook1.0 HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\Control HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\Version = 1.0 HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\VersionIndependentProgID = PhoneBook HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\TypeLib = {C4910D73-BA7D-11CD-94E8-08001701A8A3} HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\InprocServer32 = C:\BlackBox\Com\phone.dll HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\NotInsertable HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0 = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\0\win32 = C:\BlackBox\Com\Interfaces\DPhoneBook\phone.tlb HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\FLAGS = 0 HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\HELPDIR = C:\BlackBox\Com\Interfaces\DPhoneBook Once this information has been stored, the phonebook ActiveX control is ready to be used. As an example we demonstrate how it can be used through the Internet Explorer. With the <OBJECT> tag an ActiveX control can be embedded in any HTML page. As an example the html page Com/Rsrc/phone.html is provided. Note, that the only reference to the ActiveX control is its CLSID. The phone book is accessed in the two VBScript commands PhoneBook.LookupByName(NameField.value) and PhoneBook.LookupByNumber(NameField.value). <HTML> <HEAD> <TITLE>ActiveX Demo - Phonebook</TITLE> </HEAD> <BODY> <H1>BlackBox Phone Book Example</H1> <OBJECT CLASSID="CLSID:E67D346B-2A5B-11D0-ADBA-00C01500554E" ID=PhoneBook > </OBJECT> This page uses a small (40K) non-visual control which provides access to a phone book which also might run on a remote computer. This ActiveX control has been implemented with the DTC Component Pascal compiler. <P> Enter a name or a phone number and press the corresponding button: <P> <INPUT TYPE="text" NAME = "NameField" SIZE=20> <INPUT TYPE=BUTTON VALUE="Lookup by Name" NAME="NameBtn" > <INPUT TYPE=BUTTON VALUE="Lookup by Number" NAME="NumberBtn"> <SCRIPT LANGUAGE=VBScript> Sub NameBtn_Onclick alert "Phone number of " & NameField.value & ": " & PhoneBook.LookupByName(NameField.value) End Sub Sub NumberBtn_Onclick alert "Name of line " & NameField.value & ": " & PhoneBook.LookupByNumber(NameField.value) End Sub </SCRIPT> </BODY> </HTML> The following figure shows a screen dump of Internet Explorer if this html page is inspected. ComPhoneBookActiveXsources

Com/Docu/PhoneBookActiveX.odc

ComPhoneBook Example: ComPhoneBookClient Phonebook client program. There is no separate documentation.

Com/Docu/PhoneBookClient.odc

Map to the Direct-To-COM Examples COM Interface Usage ComEnumRectdocu ComEnumRectsources simple COM object ComObjectdocu ComObjectsources minimal OLE server ComConnectdocu ComConnectsources connection points ComAggregatedocu ComAggregatesources usage of aggregation Inprocess and Local Servers ComKoaladocu ComKoalasources local server in BlackBox ComKoalaTstsources test program for ComKoala ComKoalaExedocu ComKoalaExesources independent local server ComKoalaDlldocu ComKoalaDllsources in process server Tool Libraries ComToolsdocu ComToolssources tools for unsafe structures ComEnumdocu ComEnumsources standard enumerators Sample Control ComPhoneBookdocu ComPhoneBooksources simple phonebook ComPhoneBookActiveX ComPhoneBookActiveX phonebook as ActiveX ComPhoneBookClient phonebook client

Com/Docu/Sys-Map.odc

ComTools ComTools is a library containing routines for the handling of often used and partially unsafe data structures. These data structures are unsafe because they contain C unions or C pointers (not interface pointers) or both. ComTools can be imported as a tool package or its source can be used as starting point for customized implementations. String handling Strings are pointers to arrays of unspecified length. They must be allocated and deallocated manually. PROCEDURE NewString (IN str: ARRAY [untagged] OF CHAR): WinApi.PtrWSTR; PROCEDURE NewEmptyString (length: INTEGER): WinApi.PtrWSTR; PROCEDURE FreeString (VAR p: WinApi.PtrWSTR); PROCEDURE NewSString (IN str: ARRAY [untagged] OF SHORTCHAR): WinApi.PtrSTR; PROCEDURE NewEmptySString (length: INTEGER): WinApi.PtrSTR; PROCEDURE FreeSString (VAR p: WinApi.PtrSTR); STGMEDIUM The STGMEDIUM structure contains a C union and various pointers. The following procedures can be used to properly initialize one of the seven possible STGMEDIUM variants: PROCEDURE GenBitmapMedium (bitmap: WinApi.HBITMAP; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenEMetafileMedium (emf: WinApi.HENHMETAFILE; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenFileMedium (name: ARRAY OF CHAR; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenGlobalMedium (hg: WinApi.HGLOBAL; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenMetafileMedium (mf: WinApi.HMETAFILEPICT; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenStorageMedium (stg: WinOle.IStorage; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); PROCEDURE GenStreamMedium (stm: WinOle.IStream; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); Safe access to the variable part of the structure should be done by one of these functions: PROCEDURE MediumBitmap (IN sm: WinOle.STGMEDIUM): WinApi.HBITMAP; PROCEDURE MediumEnhMetafile (IN sm: WinOle.STGMEDIUM): WinApi.HENHMETAFILE; PROCEDURE MediumFile (IN sm: WinOle.STGMEDIUM): WinApi.PtrWSTR; PROCEDURE MediumGlobal (IN sm: WinOle.STGMEDIUM): WinApi.HGLOBAL; PROCEDURE MediumMetafile (IN sm: WinOle.STGMEDIUM): WinApi.HMETAFILEPICT; PROCEDURE MediumStorage (IN sm: WinOle.STGMEDIUM): WinOle.IStorage; PROCEDURE MediumStream (IN sm: WinOle.STGMEDIUM): WinOle.IStream; STGMEDIUM structures must be released manually. Use the OLE library procedure WinOle.ReleaseStgMedium for that purpose: PROCEDURE ReleaseStgMedium (VAR [nil] sm: WinOle.STGMEDIUM); FORMATETC generation This procedure can be used to quickly initialize a FORMATETC structure. PROCEDURE GenFormatEtc (format: SHORTINT; aspect, tymed: SET; OUT f: WinOle.FORMATETC); ComToolssources

Com/Docu/Tools.odc

DevTypeLibs Module DevTypeLibs deals with information provided by COM type libraries. This module has a private interface, it is only used internally.

Com/Docu/TypeLibs.odc

MODULE ComAggregate; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "adapted from Reuse sample in "Inside OLE", 2nd ed." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, StdLog; TYPE IAnimal = POINTER TO ABSTRACT RECORD ["{00021143-0000-0000-C000-000000000046}"] (COM.IUnknown) END; CAnimal = POINTER TO RECORD (COM.IUnknown) impl: CImpIAnimal END; CImpIAnimal = POINTER TO RECORD (IAnimal) obj: CAnimal END; IKoala = POINTER TO ABSTRACT RECORD ["{00021144-0000-0000-C000-000000000046}"] (COM.IUnknown) END; CKoala = POINTER TO RECORD (COM.IUnknown) impl: CImpIKoala; animal: COM.IUnknown END; CImpIKoala = POINTER TO RECORD (IKoala) obj: CKoala END; VAR koala: COM.IUnknown; (* ---------- IAnimal ---------- *) PROCEDURE (this: IAnimal) Eat (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IAnimal) Sleep (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IAnimal) Procreate (): COM.RESULT, NEW, ABSTRACT; (* ---------- CAnimal ---------- *) PROCEDURE (this: CAnimal) QueryInterface (IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; BEGIN IF COM.QUERY(this, iid, int) OR COM.QUERY(this.impl, iid, int) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END END QueryInterface; (* ---------- CImpIAnimal ---------- *) PROCEDURE (this: CImpIAnimal) Eat (): COM.RESULT; BEGIN StdLog.String("Animal's IAnimal.Eat called"); StdLog.Ln; RETURN WinApi.S_OK END Eat; PROCEDURE (this: CImpIAnimal) Sleep (): COM.RESULT; BEGIN StdLog.String("Animal's IAnimal.Sleep called"); StdLog.Ln; RETURN WinApi.S_OK END Sleep; PROCEDURE (this: CImpIAnimal) Procreate (): COM.RESULT; BEGIN StdLog.String("Animal's IAnimal.Procreate called"); StdLog.Ln; RETURN WinApi.S_OK END Procreate; (* ---------- Animal creation ---------- *) PROCEDURE CreateAnimal (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR new: CAnimal; BEGIN IF (outer # NIL) & (iid # COM.ID(COM.IUnknown)) THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN IF outer = NIL THEN NEW(new.impl, new) ELSE NEW(new.impl, outer) END; IF new.impl # NIL THEN new.impl.obj := new; StdLog.String("Animal allocated"); StdLog.Ln; RETURN new.QueryInterface(iid, int) END END; RETURN WinApi.E_OUTOFMEMORY END CreateAnimal; (* ---------- IKoala ---------- *) PROCEDURE (this: IKoala) ClimbEucalyptusTrees (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IKoala) PouchOpensDown (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IKoala) SleepForHoursAfterEating (): COM.RESULT, NEW, ABSTRACT; (* ---------- CKoala ---------- *) PROCEDURE (this: CKoala) QueryInterface (IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; BEGIN IF COM.QUERY(this, iid, int) OR COM.QUERY(this.impl, iid, int) THEN RETURN WinApi.S_OK ELSIF iid = COM.ID(IAnimal) THEN RETURN this.animal.QueryInterface(iid, int) ELSE RETURN WinApi.E_NOINTERFACE END END QueryInterface; (* ---------- CImpIKoala ---------- *) PROCEDURE (this: CImpIKoala) ClimbEucalyptusTrees (): COM.RESULT; BEGIN StdLog.String("Koala's IKoala.ClimbEucalyptusTrees called"); StdLog.Ln; RETURN WinApi.S_OK END ClimbEucalyptusTrees; PROCEDURE (this: CImpIKoala) PouchOpensDown (): COM.RESULT; BEGIN StdLog.String("Koala's IKoala.PouchOpensDown called"); StdLog.Ln; RETURN WinApi.S_OK END PouchOpensDown; PROCEDURE (this: CImpIKoala) SleepForHoursAfterEating (): COM.RESULT; BEGIN StdLog.String("Koala's IKoala.SleepForHoursAfterEating called"); StdLog.Ln; RETURN WinApi.S_OK END SleepForHoursAfterEating; (* ---------- Koala creation ---------- *) PROCEDURE CreateKoalaAggregation (OUT unk: COM.IUnknown): BOOLEAN; VAR obj: CKoala; res: COM.RESULT; BEGIN NEW(obj); IF obj # NIL THEN NEW(obj.impl, obj); IF obj.impl # NIL THEN obj.impl.obj := obj; res := CreateAnimal(obj, COM.ID(obj.animal), obj.animal); IF res >= 0 THEN StdLog.String("Koala allocated"); StdLog.Ln; RETURN obj.QueryInterface(COM.ID(unk), unk) >= 0 END END END; RETURN FALSE END CreateKoalaAggregation; (* ---------- user interface ---------- *) PROCEDURE CreateKoala*; BEGIN IF CreateKoalaAggregation(koala) THEN StdLog.String("Koala created") ELSE StdLog.String("Koala creation failed") END; StdLog.Ln END CreateKoala; PROCEDURE ReleaseKoala*; BEGIN IF koala # NIL THEN koala := NIL; StdLog.String("Koala released") ELSE StdLog.String("no object") END; StdLog.Ln END ReleaseKoala; PROCEDURE AnimalEat*; VAR a: IAnimal; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.Eat(); StdLog.String("IAnimal.Eat called") ELSE StdLog.String("no IAnimal interface") END ELSE StdLog.String("no object") END; StdLog.Ln END AnimalEat; PROCEDURE AnimalSleep*; VAR a: IAnimal; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.Sleep(); StdLog.String("IAnimal.Sleep called") ELSE StdLog.String("no IAnimal interface") END ELSE StdLog.String("no object") END; StdLog.Ln END AnimalSleep; PROCEDURE AnimalProcreate*; VAR a: IAnimal; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.Procreate(); StdLog.String("IAnimal.Procreate called") ELSE StdLog.String("no IAnimal interface") END ELSE StdLog.String("no object") END; StdLog.Ln END AnimalProcreate; PROCEDURE KoalaClimbEucalyptusTrees*; VAR a: IKoala; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.ClimbEucalyptusTrees(); StdLog.String("IKoala.ClimbEucalyptusTrees called") ELSE StdLog.String("no IKoala interface") END ELSE StdLog.String("no object") END; StdLog.Ln END KoalaClimbEucalyptusTrees; PROCEDURE KoalaPouchOpensDown*; VAR a: IKoala; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.PouchOpensDown(); StdLog.String("IKoala.PouchOpensDown called") ELSE StdLog.String("no IKoala interface") END ELSE StdLog.String("no object") END; StdLog.Ln END KoalaPouchOpensDown; PROCEDURE KoalaSleepForHoursAfterEating*; VAR a: IKoala; res: COM.RESULT; BEGIN IF koala # NIL THEN res := koala.QueryInterface(COM.ID(a), a); IF res >= 0 THEN res := a.SleepForHoursAfterEating(); StdLog.String("IKoala.SleepForHoursAfterEating called") ELSE StdLog.String("no IKoala interface") END ELSE StdLog.String("no object") END; StdLog.Ln END KoalaSleepForHoursAfterEating; END ComAggregate. ComAggregate.CreateKoala ComAggregate.ReleaseKoala ComAggregate.AnimalEat ComAggregate.AnimalSleep ComAggregate.AnimalProcreate ComAggregate.KoalaClimbEucalyptusTrees ComAggregate.KoalaPouchOpensDown ComAggregate.KoalaSleepForHoursAfterEating

Com/Mod/Aggregate.odc

MODULE ComConnect; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "adapted from Connect sample in "Inside OLE", 2nd ed." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle, StdLog; CONST connPoints = 1; connMax = 2; eventQuack = 1; eventFlap = 2; eventPaddle = 3; SINK1 = 0; SINK2 = 1; TYPE IDuckEvents = POINTER TO ABSTRACT RECORD ["{00021145-0000-0000-C000-000000000046}"] (COM.IUnknown) END; CEnumConnectionPoints = POINTER TO RECORD (WinOle.IEnumConnectionPoints) cur: INTEGER; num: INTEGER; data: ARRAY connPoints OF WinOle.IConnectionPoint END; CEnumConnections = POINTER TO RECORD (WinOle.IEnumConnections) cur: INTEGER; num: INTEGER; data: ARRAY connMax OF WinOle.CONNECTDATA END; CConnectionPoint = POINTER TO RECORD (WinOle.IConnectionPoint) obj: CConnObject; iid: COM.GUID; unk: ARRAY connMax OF COM.IUnknown; cookies: ARRAY connMax OF INTEGER; conn: INTEGER; next: INTEGER END; CConnObject = POINTER TO RECORD (WinOle.IConnectionPointContainer) connPt: ARRAY connPoints OF CConnectionPoint END; CDuckEvents = POINTER TO RECORD (IDuckEvents) id: INTEGER; cookie: INTEGER END; VAR sink: ARRAY 2 OF CDuckEvents; obj: CConnObject; (* ---------- IDuckEvents ---------- *) PROCEDURE (this: IDuckEvents) Quack (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IDuckEvents) Flap (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IDuckEvents) Paddle (): COM.RESULT, NEW, ABSTRACT; (* ---------- CDuckEvents ---------- *) PROCEDURE CreateCDuckEvents (id: INTEGER; OUT new: CDuckEvents); BEGIN NEW(new); IF new # NIL THEN new.id := id; new.cookie := 0 END END CreateCDuckEvents; PROCEDURE (this: CDuckEvents) Quack (): COM.RESULT; BEGIN StdLog.String("Sink "); StdLog.Int(this.id + 1); StdLog.String(" received Quack"); StdLog.Ln; RETURN WinApi.S_OK END Quack; PROCEDURE (this: CDuckEvents) Flap (): COM.RESULT; BEGIN StdLog.String("Sink "); StdLog.Int(this.id + 1); StdLog.String(" received Flap"); StdLog.Ln; RETURN WinApi.S_OK END Flap; PROCEDURE (this: CDuckEvents) Paddle (): COM.RESULT; BEGIN StdLog.String("Sink "); StdLog.Int(this.id + 1); StdLog.String(" received Paddle"); StdLog.Ln; RETURN WinApi.S_OK END Paddle; (* ---------- CEnumConnections ---------- *) PROCEDURE CreateCEnumConnections (num: INTEGER; VAR data: ARRAY OF WinOle.CONNECTDATA; OUT new: CEnumConnections); VAR i: INTEGER; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; i := 0; WHILE i < num DO new.data[i] := data[i]; INC(i) END END END CreateCEnumConnections; PROCEDURE (this: CEnumConnections) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinOle.CONNECTDATA; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO elem[n] := this.data[this.cur]; INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: CEnumConnections) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: CEnumConnections) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: CEnumConnections) Clone (OUT enum: WinOle.IEnumConnections): COM.RESULT; VAR new: CEnumConnections; BEGIN CreateCEnumConnections(this.num, this.data, new); IF new # NIL THEN new.cur := this.cur; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; (* ---------- CConnectionPoint ---------- *) PROCEDURE CreateCConnectionPoint (obj: CConnObject; IN iid: COM.GUID; OUT new: CConnectionPoint); VAR i: INTEGER; BEGIN NEW(new); IF new # NIL THEN new.iid := iid; new.obj := obj; new.conn := 0; new.next := 100 END END CreateCConnectionPoint; PROCEDURE (this: CConnectionPoint) GetConnectionInterface (OUT iid: COM.GUID): COM.RESULT; BEGIN iid := this.iid; RETURN WinApi.S_OK END GetConnectionInterface; PROCEDURE (this: CConnectionPoint) GetConnectionPointContainer (OUT cpc: WinOle.IConnectionPointContainer): COM.RESULT; BEGIN RETURN this.obj.QueryInterface(COM.ID(cpc), cpc) END GetConnectionPointContainer; PROCEDURE (this: CConnectionPoint) Advise (sink: COM.IUnknown; OUT cookie: INTEGER): COM.RESULT; VAR res: COM.RESULT; unk: COM.IUnknown; i: INTEGER; BEGIN IF this.conn < connMax THEN res := sink.QueryInterface(this.iid, unk); IF res >= 0 THEN i := 0; WHILE this.unk[i] # NIL DO INC(i) END; this.unk[i] := unk; INC(this.next); this.cookies[i] := this.next; cookie := this.next; INC(this.conn); RETURN WinApi.S_OK ELSE RETURN WinApi.CONNECT_E_CANNOTCONNECT END ELSE RETURN WinApi.CONNECT_E_ADVISELIMIT END END Advise; PROCEDURE (this: CConnectionPoint) Unadvise (cookie: INTEGER): COM.RESULT; VAR i: INTEGER; BEGIN IF cookie # 0 THEN i := 0; WHILE (i < connMax) & (this.cookies[i] # cookie) DO INC(i) END; IF i < connMax THEN this.unk[i] := NIL; this.cookies[i] := 0; DEC(this.conn); RETURN WinApi.S_OK ELSE RETURN WinApi.CONNECT_E_NOCONNECTION END ELSE RETURN WinApi.E_INVALIDARG END END Unadvise; PROCEDURE (this: CConnectionPoint) EnumConnections ( OUT enum: WinOle.IEnumConnections): COM.RESULT; VAR p: ARRAY connMax OF WinOle.CONNECTDATA; i, j: INTEGER; c: CEnumConnections; BEGIN IF this.conn > 0 THEN i := 0; j := 0; WHILE i < connMax DO IF this.unk[i] # NIL THEN p[j].pUnk := this.unk[i]; p[j].dwCookie := this.cookies[i]; INC(j) END; INC(i) END; CreateCEnumConnections(this.conn, p, c); IF c # NIL THEN enum := c; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END ELSE RETURN WinApi.OLE_E_NOCONNECTION END END EnumConnections; (* ---------- CEnumConnectionPoints ---------- *) PROCEDURE CreateCEnumConnectionPoints (num: INTEGER; VAR data: ARRAY OF WinOle.IConnectionPoint; VAR new: CEnumConnectionPoints); VAR i: INTEGER; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; i := 0; WHILE i < num DO new.data[i] := data[i]; INC(i) END END END CreateCEnumConnectionPoints; PROCEDURE (this: CEnumConnectionPoints) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinOle.IConnectionPoint; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO elem[n] := this.data[this.cur]; INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: CEnumConnectionPoints) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: CEnumConnectionPoints) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: CEnumConnectionPoints) Clone ( OUT enum: WinOle.IEnumConnectionPoints): COM.RESULT; VAR new: CEnumConnectionPoints; BEGIN CreateCEnumConnectionPoints(this.num, this.data, new); IF new # NIL THEN new.cur := this.cur; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; (* ---------- CConnObject ---------- *) PROCEDURE CreateCConnObject (VAR new: CConnObject); VAR i, n: INTEGER; BEGIN NEW(new); IF new # NIL THEN i := 0; WHILE i < connPoints DO CreateCConnectionPoint(new, COM.ID(IDuckEvents), new.connPt[i]); INC(i) END END END CreateCConnObject; PROCEDURE (this: CConnObject) EnumConnectionPoints (OUT enum: WinOle.IEnumConnectionPoints): COM.RESULT; VAR i: INTEGER; cp: ARRAY connPoints OF WinOle.IConnectionPoint; ce: CEnumConnectionPoints; BEGIN i := 0; WHILE i < connPoints DO cp[i] := this.connPt[i]; INC(i) END; CreateCEnumConnectionPoints(connPoints, cp, ce); IF ce # NIL THEN enum := ce; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END EnumConnectionPoints; PROCEDURE (this: CConnObject) FindConnectionPoint (IN iid: COM.GUID; OUT conn: WinOle.IConnectionPoint): COM.RESULT; VAR BEGIN IF iid = COM.ID(IDuckEvents) THEN conn := this.connPt[0]; RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END END FindConnectionPoint; PROCEDURE (this: CConnObject) TriggerEvent (event: INTEGER): BOOLEAN, NEW; VAR enum: WinOle.IEnumConnections; cd: ARRAY 1 OF WinOle.CONNECTDATA; duck: IDuckEvents; n: INTEGER; BEGIN IF this.connPt[0].EnumConnections(enum) >= 0 THEN WHILE enum.Next(1, cd, NIL) = WinApi.S_OK DO IF cd[0].pUnk.QueryInterface(COM.ID(duck), duck) >= 0 THEN CASE event OF | eventQuack: n := duck.Quack() | eventFlap: n := duck.Flap() | eventPaddle: n := duck.Paddle() END END END; RETURN TRUE ELSE RETURN FALSE END END TriggerEvent; (* ---------- commands ---------- *) PROCEDURE GetConnectionPoint (): WinOle.IConnectionPoint; VAR res: COM.RESULT; cont: WinOle.IConnectionPointContainer; cp: WinOle.IConnectionPoint; BEGIN res := obj.QueryInterface(COM.ID(cont), cont); IF res >= 0 THEN res := cont.FindConnectionPoint(COM.ID(IDuckEvents), cp); RETURN cp ELSE RETURN NIL END END GetConnectionPoint; PROCEDURE Connect (id: INTEGER); VAR cp: WinOle.IConnectionPoint; res: COM.RESULT; BEGIN IF obj # NIL THEN IF sink[id].cookie = 0 THEN cp := GetConnectionPoint(); IF cp # NIL THEN res := cp.Advise(sink[id], sink[id].cookie); IF res < 0 THEN StdLog.String("Connection failed"); StdLog.Ln ELSE StdLog.String("Connection complete"); StdLog.Ln END ELSE StdLog.String("Failed to get IConnectionPoint"); StdLog.Ln END ELSE StdLog.String("Sink already connected"); StdLog.Ln END ELSE StdLog.String("No object"); StdLog.Ln END END Connect; PROCEDURE Disconnect (id: INTEGER); VAR cp: WinOle.IConnectionPoint; res: COM.RESULT; BEGIN IF obj # NIL THEN IF sink[id].cookie # 0 THEN cp := GetConnectionPoint(); IF cp # NIL THEN res := cp.Unadvise(sink[id].cookie); IF res < 0 THEN StdLog.String("Disconnection failed"); StdLog.Ln ELSE StdLog.String("Disconnection complete"); StdLog.Ln; sink[id].cookie := 0 END ELSE StdLog.String("Failed to get IConnectionPoint"); StdLog.Ln END ELSE StdLog.String("Sink not connected"); StdLog.Ln END ELSE StdLog.String("No object"); StdLog.Ln END END Disconnect; PROCEDURE Init*; BEGIN CreateCDuckEvents(SINK1, sink[SINK1]); CreateCDuckEvents(SINK2, sink[SINK2]); END Init; PROCEDURE Release*; BEGIN obj := NIL; Disconnect(SINK1); Disconnect(SINK2); sink[SINK1] := NIL; sink[SINK2] := NIL END Release; PROCEDURE ObjectCreate*; BEGIN CreateCConnObject(obj); IF obj # NIL THEN StdLog.String(" Object created"); StdLog.Ln END END ObjectCreate; PROCEDURE ObjectRelease*; BEGIN IF obj # NIL THEN obj := NIL; StdLog.String("Object released"); StdLog.Ln ELSE StdLog.String("No object"); StdLog.Ln END END ObjectRelease; PROCEDURE Sink1Connect*; BEGIN Connect(SINK1) END Sink1Connect; PROCEDURE Sink1Disconnect*; BEGIN Disconnect(SINK1) END Sink1Disconnect; PROCEDURE Sink2Connect*; BEGIN Connect(SINK2) END Sink2Connect; PROCEDURE Sink2Disconnect*; BEGIN Disconnect(SINK2) END Sink2Disconnect; PROCEDURE TriggerQuack*; BEGIN IF obj # NIL THEN IF ~obj.TriggerEvent(eventQuack) THEN StdLog.String("No connected sinks"); StdLog.Ln END ELSE StdLog.String("No object"); StdLog.Ln END END TriggerQuack; PROCEDURE TriggerFlap*; BEGIN IF obj # NIL THEN IF ~obj.TriggerEvent(eventFlap) THEN StdLog.String("No connected sinks"); StdLog.Ln END ELSE StdLog.String("No object"); StdLog.Ln END END TriggerFlap; PROCEDURE TriggerPaddle*; BEGIN IF obj # NIL THEN IF ~obj.TriggerEvent(eventPaddle) THEN StdLog.String("No connected sinks"); StdLog.Ln END ELSE StdLog.String("No object"); StdLog.Ln END END TriggerPaddle; END ComConnect. ComConnect.Init ComConnect.Release ComConnect.ObjectCreate ComConnect.ObjectRelease ComConnect.Sink1Connect ComConnect.Sink1Disconnect ComConnect.Sink2Connect ComConnect.Sink2Disconnect ComConnect.TriggerFlap ComConnect.TriggerPaddle ComConnect.TriggerQuack

Com/Mod/Connect.odc

MODULE ComDebug; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20070205, bh, Unicode support - 20141027, center #19, full Unicode support for Component Pascal identifiers added - 20160110, center #60, fix for underlined white space - 20160324, center #111, code cleanups " issues = " - ... " **) IMPORT SYSTEM, COM, WinApi, WinOle, Kernel, Strings, Dialog, Fonts, Ports, Stores, Models, Views, Properties, Containers, Documents, Windows, TextModels, TextRulers, TextViews, TextControllers, TextMappers, DevDebug, DevHeapSpy, StdLog, StdLinks; TYPE Block = POINTER TO RECORD [untagged] tag: Kernel.Type; size: INTEGER; (* size of free blocks *) ref: INTEGER; unk: INTEGER END; Cluster = POINTER TO RECORD [untagged] size: INTEGER; (* total size *) next: Cluster; END; VAR all: BOOLEAN; PROCEDURE NewRuler (): TextRulers.Ruler; CONST mm = Ports.mm; VAR p: TextRulers.Prop; BEGIN NEW(p); p.valid := {TextRulers.right, TextRulers.tabs, TextRulers.opts}; p.opts.val := {TextRulers.rightFixed}; p.opts.mask := p.opts.val; p.right := 130 * mm; p.tabs.len := 4; p.tabs.tab[0].stop := 15 * mm; p.tabs.tab[1].stop := 70 * mm; p.tabs.tab[2].stop := 85 * mm; p.tabs.tab[3].stop := 95 * mm; RETURN TextRulers.dir.NewFromProp(p) END NewRuler; PROCEDURE OpenViewer (t: TextModels.Model; title: Views.Title; ruler:TextRulers.Ruler); VAR v: TextViews.View; c: Containers.Controller; BEGIN Dialog.MapString(title, title); v := TextViews.dir.New(t); IF ruler # NIL THEN v.SetDefaults(ruler, TextViews.dir.defAttr) END; c := v.ThisController(); IF c # NIL THEN c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret}) END; Views.OpenAux(v, title) END OpenViewer; PROCEDURE OpenInfoViewer (t: TextModels.Model; title: Views.Title); VAR v: TextViews.View; c: Containers.Controller; p: Properties.BoundsPref; BEGIN Dialog.MapString(title, title); v := TextViews.dir.New(t); c := v.ThisController(); IF c # NIL THEN c.SetOpts(c.opts - {Containers.noFocus, Containers.noSelection} + {Containers.noCaret}) END; p.w := Views.undefined; p.h := Views.undefined; Views.HandlePropMsg(v, p); Views.OpenAux(Documents.dir.New(v, p.w, p.h), title) END OpenInfoViewer; PROCEDURE Next (b: Block): Block; (* next block in same cluster *) VAR size: INTEGER; tag: Kernel.Type; BEGIN tag := SYSTEM.VAL(Kernel.Type, SYSTEM.VAL(INTEGER, b.tag) DIV 4 * 4); size := tag.size + 4; IF ODD(SYSTEM.VAL(INTEGER, b.tag) DIV 2) THEN size := b.size - SYSTEM.ADR(b.size) + size END; size := (size + 15) DIV 16 * 16; RETURN SYSTEM.VAL(Block, SYSTEM.VAL(INTEGER, b) + size) END Next; PROCEDURE ShowInterfaces (VAR out: TextMappers.Formatter); VAR adr, end: INTEGER; modName, name, anchor: Kernel.Name; a0, a1: TextModels.Attributes; cluster: Cluster; blk: Block; BEGIN out.WriteString("Referenced Interface Records:"); out.WriteTab; out.WriteTab; a0 := out.rider.attr; out.rider.SetAttr(TextModels.NewStyle(out.rider.attr, {Fonts.underline})); out.rider.SetAttr(TextModels.NewColor(out.rider.attr, Ports.blue)); a1 := out.rider.attr; out.WriteView(StdLinks.dir.NewLink("ComDebug.ToggleAllInterfaces")); IF all THEN out.WriteString("New") ELSE out.WriteString("All") END; out.WriteView(StdLinks.dir.NewLink("")); out.rider.SetAttr(a0); out.WriteTab; out.rider.SetAttr(a1); out.WriteView(StdLinks.dir.NewLink("ComDebug.UpdateInterfaceRecords")); out.WriteString("Update"); out.WriteView(StdLinks.dir.NewLink("")); out.rider.SetAttr(a0); out.WriteLn; out.WriteLn; cluster := SYSTEM.VAL(Cluster, Kernel.Root()); WHILE cluster # NIL DO blk := SYSTEM.VAL(Block, SYSTEM.VAL(INTEGER, cluster) + 12); end := SYSTEM.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16; WHILE SYSTEM.VAL(INTEGER, blk) < end DO IF ~(1 IN SYSTEM.VAL(SET, blk.tag)) & (SYSTEM.VAL(INTEGER, blk.tag) # SYSTEM.ADR(blk.size)) & (blk.tag.base[0] = NIL) THEN Kernel.GetModName(blk.tag.mod, modName); IF (all OR (modName # "HostMechanisms") & (modName # "OleServer") & (modName # "OleClient") & (modName # "OleStorage") & (modName # "OleData")) THEN adr := SYSTEM.ADR(blk.size); out.WriteString("ref: "); out.WriteInt(blk.ref); out.WriteTab; out.WriteString(modName); out.WriteChar("."); IF (blk.tag.id DIV 256 # 0) & (blk.tag.mod.refcnt >= 0) THEN Kernel.GetTypeName(blk.tag, name); out.WriteString(name) ELSE out.WriteString("RECORD"); END; out.WriteTab; out.WriteChar("["); out.WriteIntForm(adr, TextMappers.hexadecimal, 9, "0", TextMappers.showBase); out.WriteChar("]"); out.WriteChar(" "); out.WriteView(DevDebug.HeapRefView(adr, "Interface")); DevHeapSpy.GetAnchor(adr, anchor); IF anchor # "" THEN out.WriteTab; out.WriteTab; out.WriteChar("("); out.WriteString(anchor); out.WriteChar(")") END; out.WriteLn END; END; blk := Next(blk) END; cluster := cluster.next END END ShowInterfaces; PROCEDURE ShowInterfaceRecords*; VAR out: TextMappers.Formatter; BEGIN out.ConnectTo(TextModels.CloneOf(StdLog.buf)); ShowInterfaces(out); OpenViewer(out.rider.Base(), "Interfaces", NewRuler()); out.ConnectTo(NIL) END ShowInterfaceRecords; PROCEDURE UpdateInterfaceRecords*; VAR t, t0: TextModels.Model; out: TextMappers.Formatter; BEGIN t0 := TextViews.FocusText(); Models.BeginModification(Models.notUndoable, t0); t0.Delete(0, t0.Length()); (* removes old object references from text *) Views.Update(TextViews.Focus(), Views.rebuildFrames); Windows.dir.Update(Windows.dir.First()); (* remove frame references *) Kernel.Collect; t := TextModels.CloneOf(t0); (*Stores.InitDomain(t, t0.domain);*) Stores.Join(t, t0); out.ConnectTo(t); ShowInterfaces(out); t0.Insert(0, t, 0, t.Length()); Models.EndModification(Models.notUndoable, t0); out.ConnectTo(NIL) END UpdateInterfaceRecords; PROCEDURE ToggleAllInterfaces*; BEGIN all := ~all; UpdateInterfaceRecords END ToggleAllInterfaces; PROCEDURE ShowError*; VAR res: INTEGER; c: TextControllers.Controller; r: TextModels.Reader; f: TextMappers.Formatter; beg, end, i: INTEGER; str: ARRAY 1024 OF CHAR; ch: CHAR; s: ARRAY 64 OF CHAR; BEGIN c := TextControllers.Focus(); IF (c # NIL) & c.HasSelection() THEN c.GetSelection(beg, end); r := c.text.NewReader(NIL); r.SetPos(beg); i := 0; r.ReadChar(ch); WHILE (beg + i < end) & (i < LEN(s) - 1) & (ch >= " ") DO s[i] := ch; INC(i); r.ReadChar(ch) END; s[i] := 0X; Strings.StringToInt(s, i, res); IF res = 0 THEN f.ConnectTo(TextModels.CloneOf(StdLog.buf)); f.WriteString("Error Code: "); f.WriteIntForm(i, TextMappers.hexadecimal, 9, "0", TRUE); f.WriteLn; f.WriteString("(Facility: "); CASE i DIV 10000H MOD 2000H OF | 0: f.WriteString("NULL, ") | 1: f.WriteString("RPC, ") | 2: f.WriteString("DISPATCH, ") | 3: f.WriteString("STORAGE, ") | 4: f.WriteString("ITF, ") | 7: f.WriteString("WIN32, ") | 8: f.WriteString("WINDOWS, ") | 10: f.WriteString("CONTROL, ") ELSE f.WriteString("unknown, ") END; f.WriteString("Severity: "); IF i < 0 THEN f.WriteString("Error, ") ELSE f.WriteString("Success, ") END; f.WriteString("Code: "); f.WriteInt(i MOD 10000H); f.WriteChar(")"); f.WriteLn; f.WriteString("Description:"); f.WriteLn; i := WinApi.FormatMessageW({12}, 0, i, 0, str, LEN(str), NIL); IF i > 0 THEN REPEAT DEC(i) UNTIL (i < 0) OR (str[i] >= " "); str[i + 1] := 0X; ELSE str := "" END; f.WriteString(str); f.WriteLn; OpenInfoViewer(f.rider.Base(), "Show Error"); f.ConnectTo(NIL) END END END ShowError; PROCEDURE Hex (VAR f: TextMappers.Formatter; x, n: INTEGER); BEGIN IF n > 1 THEN Hex(f, x DIV 16, n - 1) END; x := x MOD 16; IF x >= 10 THEN f.WriteChar(CHR(x + ORD("A") - 10)) ELSE f.WriteChar(CHR(x + ORD("0"))) END END Hex; PROCEDURE NewGuid*; VAR f: TextMappers.Formatter; g: COM.GUID; res: COM.RESULT; n: INTEGER; BEGIN f.ConnectTo(TextModels.CloneOf(StdLog.buf)); n := 10; WHILE n > 0 DO res := WinOle.CoCreateGuid(g); f.WriteChar("{"); Hex(f, g[2] MOD 256 + 256 * g[3] MOD 256, 4); Hex(f, g[0] MOD 256 + 256 * g[1] MOD 256, 4); f.WriteChar("-"); Hex(f, g[4] MOD 256 + 256 * g[5] MOD 256, 4); f.WriteChar("-"); Hex(f, g[6] MOD 256 + 256 * g[7] MOD 256, 4); f.WriteChar("-"); Hex(f, g[8] MOD 256, 2); Hex(f, g[9] MOD 256, 2); f.WriteChar("-"); Hex(f, g[10] MOD 256, 2); Hex(f, g[11] MOD 256, 2); Hex(f, g[12] MOD 256, 2); Hex(f, g[13] MOD 256, 2); Hex(f, g[14] MOD 256, 2); Hex(f, g[15] MOD 256, 2); f.WriteChar("}"); f.WriteLn; DEC(n) END; OpenInfoViewer(f.rider.Base(), "Guids"); f.ConnectTo(NIL) END NewGuid; END ComDebug.

Com/Mod/Debug.odc

MODULE ComEnum; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle, ComTools; TYPE IEnumUnknown = POINTER TO RECORD (WinOle.IEnumUnknown) cur: INTEGER; num: INTEGER; data: POINTER TO ARRAY OF COM.IUnknown END; IEnumString = POINTER TO RECORD (WinOle.IEnumString) cur: INTEGER; num: INTEGER; data: POINTER TO ARRAY OF ARRAY OF CHAR END; IEnumFORMATETC = POINTER TO RECORD (WinOle.IEnumFORMATETC) cur: INTEGER; num: INTEGER; format: POINTER TO ARRAY OF INTEGER; aspect, tymed: POINTER TO ARRAY OF SET END; IEnumOLEVERB = POINTER TO RECORD (WinOle.IEnumOLEVERB) cur: INTEGER; num: INTEGER; verb: POINTER TO ARRAY OF INTEGER; name: POINTER TO ARRAY OF ARRAY OF CHAR; flags, attribs: POINTER TO ARRAY OF SET END; (* IEnumUnknown *) PROCEDURE CreateIEnumUnknown* (num: INTEGER; IN data: ARRAY OF COM.IUnknown; OUT enum: WinOle.IEnumUnknown); VAR i, n: INTEGER; new: IEnumUnknown; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; NEW(new.data, num); i := 0; WHILE i < num DO new.data[i] := data[i]; INC(i) END; enum := new END END CreateIEnumUnknown; PROCEDURE (this: IEnumUnknown) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF COM.IUnknown; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO elem[n] := this.data[this.cur]; INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: IEnumUnknown) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: IEnumUnknown) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: IEnumUnknown) Clone (OUT enum: WinOle.IEnumUnknown): COM.RESULT; VAR new: IEnumUnknown; BEGIN NEW(new); IF new # NIL THEN new.num := this.num; new.cur := this.cur; new.data := this.data; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; (* IEnumString *) PROCEDURE CreateIEnumString* (num: INTEGER; IN data: ARRAY OF ARRAY OF CHAR; OUT enum: WinOle.IEnumString); VAR i, n: INTEGER; new: IEnumString; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; NEW(new.data, num, LEN(data, 1)); i := 0; WHILE i < num DO new.data[i] := data[i]$; INC(i) END; enum := new END END CreateIEnumString; PROCEDURE (this: IEnumString) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinApi.PtrWSTR; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO elem[n] := ComTools.NewString(this.data[this.cur]); INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: IEnumString) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: IEnumString) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: IEnumString) Clone (OUT enum: WinOle.IEnumString): COM.RESULT; VAR new: IEnumString; BEGIN NEW(new); IF new # NIL THEN new.num := this.num; new.cur := this.cur; new.data := this.data; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; (* IEnumFORMATETC *) PROCEDURE CreateIEnumFORMATETC* (num: INTEGER; IN format: ARRAY OF INTEGER; IN aspect, tymed: ARRAY OF SET; OUT enum: WinOle.IEnumFORMATETC); VAR i, n: INTEGER; new: IEnumFORMATETC; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; NEW(new.format, num); NEW(new.aspect, num); NEW(new.tymed, num); i := 0; WHILE i < num DO new.format[i] := format[i]; new.aspect[i] := aspect[i]; new.tymed[i] := tymed[i]; INC(i) END; enum := new END END CreateIEnumFORMATETC; PROCEDURE (this: IEnumFORMATETC) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinOle.FORMATETC; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO ComTools.GenFormatEtc(SHORT(this.format[this.cur]), this.aspect[this.cur], this.tymed[this.cur], elem[n]); INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: IEnumFORMATETC) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: IEnumFORMATETC) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: IEnumFORMATETC) Clone (OUT enum: WinOle.IEnumFORMATETC): COM.RESULT; VAR new: IEnumFORMATETC; BEGIN NEW(new); IF new # NIL THEN new.num := this.num; new.cur := this.cur; new.format := this.format; new.aspect := this.aspect; new.tymed := this.tymed; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; (* IEnumOLEVERB *) PROCEDURE CreateIEnumOLEVERB* (num: INTEGER; IN verb: ARRAY OF INTEGER; IN name: ARRAY OF ARRAY OF CHAR; IN flags, attribs: ARRAY OF SET; OUT enum: WinOle.IEnumOLEVERB); VAR i, n: INTEGER; new: IEnumOLEVERB; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; new.num := num; NEW(new.verb, num); NEW(new.name, num, LEN(name, 1)); NEW(new.flags, num); NEW(new.attribs, num); i := 0; WHILE i < num DO new.verb[i] := verb[i]; new.name[i] := name[i]$; new.flags[i] := flags[i]; new.attribs[i] := attribs[i]; INC(i) END; enum := new END END CreateIEnumOLEVERB; PROCEDURE (this: IEnumOLEVERB) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinOle.OLEVERB; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.E_POINTER END; IF this.cur < this.num THEN WHILE (this.cur < this.num) & (num > 0) DO elem[n].lVerb := this.verb[this.cur]; elem[n].lpszVerbName := ComTools.NewString(this.name[this.cur]); elem[n].fuFlags := this.flags[this.cur]; elem[n].grfAttribs := this.attribs[this.cur]; INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: IEnumOLEVERB) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < this.num THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: IEnumOLEVERB) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: IEnumOLEVERB) Clone (OUT enum: WinOle.IEnumOLEVERB): COM.RESULT; VAR new: IEnumOLEVERB; BEGIN NEW(new); IF new # NIL THEN new.num := this.num; new.cur := this.cur; new.verb := this.verb; new.name := this.name; new.flags := this.flags; new.attribs := this.attribs; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; END ComEnum.

Com/Mod/Enum.odc

MODULE ComEnumRect; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "adapted from EnumRect sample in "Inside OLE", 2nd ed." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi; CONST rects = 15; TYPE IEnumRECT* = POINTER TO ABSTRACT RECORD ["{00021140-0000-0000-C000-000000000046}"] (COM.IUnknown) END; EnumRECT = POINTER TO RECORD (IEnumRECT) cur: INTEGER; data: ARRAY rects OF WinApi.RECT; END; (* ---------- abstract interface methods ---------- *) (* QueryInterface, AddRef, Release inherited from COM.IUnknown *) PROCEDURE (this: IEnumRECT) Next* (num: INTEGER; OUT elem: ARRAY [untagged] OF WinApi.RECT; OUT [nil] fetched: INTEGER): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IEnumRECT) Skip* (num: INTEGER): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IEnumRECT) Reset* (): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: IEnumRECT) Clone* (OUT enum: IEnumRECT): COM.RESULT, NEW, ABSTRACT; (* ---------- interface implementation ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: EnumRECT) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinApi.RECT; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN WinApi.S_FALSE END; IF this.cur < rects THEN WHILE (this.cur < rects) & (num > 0) DO elem[n] := this.data[this.cur]; INC(this.cur); INC(n); DEC(num) END; IF VALID(fetched) THEN fetched := n END; RETURN WinApi.S_OK END; RETURN WinApi.S_FALSE END Next; PROCEDURE (this: EnumRECT) Skip (num: INTEGER): COM.RESULT; BEGIN IF this.cur + num < rects THEN INC(this.cur, num); RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END Skip; PROCEDURE (this: EnumRECT) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN WinApi.S_OK END Reset; PROCEDURE (this: EnumRECT) Clone (OUT enum: IEnumRECT): COM.RESULT; VAR new: EnumRECT; BEGIN NEW(new); IF new # NIL THEN new.cur := this.cur; new.data := this.data; enum := new; RETURN WinApi.S_OK ELSE RETURN WinApi.E_OUTOFMEMORY END END Clone; PROCEDURE CreateRectEnumerator* (OUT enum: IEnumRECT); VAR new: EnumRECT; i: INTEGER; BEGIN NEW(new); IF new # NIL THEN new.cur := 0; i := 0; WHILE i < rects DO new.data[i].left := i; new.data[i].top := i * 2; new.data[i].right := i * 3; new.data[i].bottom := i * 4; INC(i) END; enum := new END END CreateRectEnumerator; END ComEnumRect.

Com/Mod/EnumRect.odc

MODULE ComInterfaceGen; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20070205, bh, Unicode support - 20160110, center #92, Office automation " issues = " - ... " **) IMPORT COM, WinApi, WinOle, WinOleAut, Files, (* HostFiles, *) Strings, Dialog, StdDialog, Views, TextModels, TextViews, ComTypeLibs, StdCmds; TYPE Entry = POINTER TO RECORD (* registry typelib entry *) next: Entry; index: INTEGER; guid: COM.GUID; major, minor: SHORTINT; lcid: WinApi.LCID; title: ARRAY 256 OF CHAR; file: ARRAY 256 OF CHAR END; VAR dialog*: RECORD library*: Dialog.List; fileName*: ARRAY 256 OF CHAR; modName*: ARRAY 64 OF CHAR; list, current: Entry END; PROCEDURE GetName (tlib: WinOleAut.ITypeLib; VAR name: ARRAY OF CHAR); VAR res: INTEGER; s: WinOle.BSTR; BEGIN res := tlib.GetDocumentation(-1, s, NIL, NIL, NIL); name := s$; IF (name[0] >= "a") & (name[0] <= "z") THEN name[0] := CAP(name[0]) END; name := "Ctl" + name; WinOleAut.SysFreeString(s) END GetName; PROCEDURE GenAutomationInterface*; VAR fn: Files.Name; loc: Files.Locator; t: TextModels.Model; BEGIN t := ComTypeLibs.AutomationInterface(dialog.fileName$, dialog.modName$); StdDialog.GetSubLoc(dialog.modName, "Mod", loc, fn); loc.res := 77; Views.Open(TextViews.dir.New(t), loc, fn, NIL) END GenAutomationInterface; PROCEDURE GenCustomInterface*; VAR fn: Files.Name; loc: Files.Locator; t: TextModels.Model; BEGIN t := ComTypeLibs.CustomInterface(dialog.fileName$, dialog.modName$); StdDialog.GetSubLoc(dialog.modName, "Mod", loc, fn); loc.res := 77; Views.Open(TextViews.dir.New(t), loc, fn, NIL) END GenCustomInterface; PROCEDURE BrowseTypeLib*; VAR fn: Files.Name; loc: Files.Locator; t: TextModels.Model; BEGIN t := ComTypeLibs.Browse(dialog.fileName$, dialog.modName$); StdDialog.GetSubLoc(dialog.modName, "Mod", loc, fn); loc.res := 77; Views.Open(TextViews.dir.New(t), loc, fn, NIL) END BrowseTypeLib; PROCEDURE Browse*; VAR loc: Files.Locator; name: Files.Name; res: INTEGER; tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR; BEGIN Dialog.GetIntSpec("*", loc, name); IF loc # NIL THEN (* dialog.fileName := loc(HostFiles.Locator).path$ + "\" + name$; *) Dialog.GetLocPath(loc, dialog.fileName); res := WinOleAut.LoadTypeLib(dialog.fileName, tlib); IF res >= 0 THEN GetName(tlib, n); dialog.modName := n$ ELSE dialog.modName := "" END; dialog.library.index := 0; Dialog.Update(dialog) END END Browse; PROCEDURE TextFieldNotifier* (op, from, to: INTEGER); VAR res: INTEGER; tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR; BEGIN IF op = Dialog.changed THEN res := WinOleAut.LoadTypeLib(dialog.fileName, tlib); IF res >= 0 THEN GetName(tlib, n); dialog.modName := n$ ELSE dialog.modName := "" END; dialog.library.index := 0; Dialog.Update(dialog) END END TextFieldNotifier; PROCEDURE ListBoxNotifier* (op, from, to: INTEGER); VAR name: ARRAY 260 OF CHAR; res: INTEGER; e: Entry; tlib: WinOleAut.ITypeLib; n: ARRAY 256 OF CHAR; BEGIN IF op = Dialog.changed THEN IF dialog.library.index # dialog.current.index THEN e := dialog.list; WHILE e.index # dialog.library.index DO e := e.next END; dialog.current := e; dialog.fileName := e.file$ END; res := WinOleAut.LoadTypeLib(dialog.fileName, tlib); IF res >= 0 THEN GetName(tlib, n); dialog.modName := n$ ELSE dialog.modName := ""; dialog.library.index := 0 END; Dialog.Update(dialog) END END ListBoxNotifier; PROCEDURE InitDialog*; VAR tlKey, gKey, vKey, lidKey, fKey: WinApi.HKEY; guid: COM.GUID; e: Entry; i, j, k, res, idx, lcid, len: INTEGER; ver: REAL; wstr: ARRAY 256 OF CHAR; nstr: ARRAY 16 OF CHAR; BEGIN NEW(dialog.list); dialog.list.next := NIL; dialog.list.index := 0; dialog.list.title := " "; dialog.list.file := ""; dialog.current := dialog.list; res := WinApi.RegOpenKeyW(WinApi.HKEY_CLASSES_ROOT, "TypeLib", tlKey); idx := 1; i := 0; res := WinApi.RegEnumKeyW(tlKey, i, wstr, LEN(wstr)); WHILE res = 0 DO res := WinOle.CLSIDFromString(wstr, guid); IF res = 0 THEN res := WinApi.RegOpenKeyW(tlKey, wstr, gKey); j := 0; res := WinApi.RegEnumKeyW(gKey, j, wstr, LEN(wstr)); WHILE res = 0 DO Strings.StringToReal(wstr, ver, res); IF res = 0 THEN res := WinApi.RegOpenKeyW(gKey, wstr, vKey); k := 0; res := WinApi.RegEnumKeyW(vKey, k, wstr, LEN(wstr)); WHILE res = 0 DO Strings.StringToInt(wstr, lcid, res); IF res = 0 THEN res := WinApi.RegOpenKeyW(vKey, wstr, lidKey); res := WinApi.RegOpenKeyW(lidKey, "Win32", fKey); IF res # 0 THEN res := WinApi.RegOpenKeyW(lidKey, "Win16", fKey) END; IF res = 0 THEN NEW(e); e.next := dialog.list; dialog.list := e; e.index := idx; INC(idx); e.guid := guid; e.major := SHORT(SHORT(ENTIER(ver))); e.minor := SHORT(SHORT(ENTIER(ver * 100)) MOD 100); e.lcid := lcid; len := LEN(e.title); res := WinApi.RegQueryValueW(vKey, NIL, e.title, len); Strings.RealToString(ver, wstr); Strings.IntToString(lcid, nstr); e.title := e.title + " (" + wstr + ", " + nstr + ")"; len := LEN(e.file); res := WinApi.RegQueryValueW(fKey, NIL, e.file, len) END END; INC(k); res := WinApi.RegEnumKeyW(vKey, k, wstr, LEN(wstr)) END END; INC(j); res := WinApi.RegEnumKeyW(gKey, j, wstr, LEN(wstr)) END END; INC(i); res := WinApi.RegEnumKeyW(tlKey, i, wstr, LEN(wstr)) END; dialog.library.SetLen(idx); e := dialog.list; WHILE e # NIL DO dialog.library.SetItem(e.index, e.title); e := e.next END; IF dialog.list.next # NIL THEN dialog.library.index := 1 ELSE dialog.library.index := 0 END; ListBoxNotifier(Dialog.changed, 0, 0) END InitDialog; PROCEDURE Open*; BEGIN IF dialog.list = NIL THEN InitDialog END ; StdCmds.OpenAuxDialog('Com/Rsrc/InterfaceGen', '#Com:Type Libraries') END Open; PROCEDURE Close*; BEGIN dialog.list := NIL; dialog.current := NIL; dialog.library.SetLen(0); StdCmds.CloseDialog; END Close; END ComInterfaceGen. ComInterfaceGen.Open

Com/Mod/InterfaceGen.odc

MODULE ComKoala; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "adapted from Koala sample in "Inside OLE", 2nd ed." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle; CONST KoalaId = "{00021146-0000-0000-C000-000000000046}"; TYPE Koala = POINTER TO RECORD (COM.IUnknown) END; KoalaFactory = POINTER TO RECORD (WinOle.IClassFactory) END; VAR locks: INTEGER; token: INTEGER; (* ---------- Koala ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) (* ---------- KoalaFactory ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: KoalaFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: Koala; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN RETURN new.QueryInterface(iid, int) ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; PROCEDURE (this: KoalaFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; RETURN WinApi.S_OK END LockServer; (* ---------- registration ---------- *) PROCEDURE Register*; VAR res: COM.RESULT; factory: KoalaFactory; BEGIN NEW(factory); res := WinOle.CoRegisterClassObject(KoalaId, factory, WinOle.CLSCTX_LOCAL_SERVER, WinOle.REGCLS_MULTIPLEUSE, token) END Register; PROCEDURE Unregister*; VAR res: COM.RESULT; BEGIN IF (locks = 0) & (token # 0) THEN res := WinOle.CoRevokeClassObject(token) END END Unregister; BEGIN locks := 0 END ComKoala. ComKoala.Register ComKoala.Unregister

Com/Mod/Koala.odc

MODULE ComKoalaDll; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "adapted from Koala sample in "Inside OLE", 2nd ed." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle; CONST KoalaId = "{00021146-0000-0000-C000-000000000046}"; TYPE Koala = POINTER TO RECORD (COM.IUnknown) END; KoalaFactory = POINTER TO RECORD (WinOle.IClassFactory) END; VAR locks: INTEGER; objects: INTEGER; (* ---------- Koala ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: Koala) RELEASE; (* called when last com reference is removed *) BEGIN DEC(objects) END RELEASE; (* ---------- KoalaFactory ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: KoalaFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: Koala; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN res := new.QueryInterface(iid, int); IF res >= 0 THEN INC(objects) END; RETURN res ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; PROCEDURE (this: KoalaFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; RETURN WinApi.S_OK END LockServer; (* ---------- dll interface ---------- *) PROCEDURE DllGetClassObject* (IN clsid: COM.GUID; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR obj: KoalaFactory; BEGIN IF clsid = KoalaId THEN NEW(obj); IF obj # NIL THEN RETURN obj.QueryInterface(iid, int) ELSE RETURN WinApi.E_OUTOFMEMORY; END ELSE RETURN WinApi.E_FAIL END END DllGetClassObject; PROCEDURE DllCanUnloadNow* (): COM.RESULT; BEGIN IF (objects = 0) & (locks = 0) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END DllCanUnloadNow; BEGIN locks := 0; objects := 0 END ComKoalaDll. DevLinker.LinkDll DKoala1.dll := Kernel+ ComKoalaDll# ~ ----------------------------------------------------------------------------------------------------------------- REGEDIT HKEY_CLASSES_ROOT\Koala1.0 = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala1.0\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\Koala = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala\CurVer = Koala1.0 HKEY_CLASSES_ROOT\Koala\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046} = Koala Object Chapter 5 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\ProgID = Koala1.0 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\VersionIndependentProgID = Koala HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\InprocServer32 = C:\BlackBox\Com\DKoala1.dll HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\NotInsertable -----------------------------------------------------------------------------------------------------------------

Com/Mod/KoalaDll.odc

MODULE ComKoalaExe; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20070205, bh, Unicode support " issues = " - ... " **) IMPORT S := SYSTEM, COM, WinApi, WinOle; CONST KoalaId = "{00021146-0000-0000-C000-000000000046}"; TYPE Koala = POINTER TO RECORD (COM.IUnknown) END; KoalaFactory = POINTER TO RECORD (WinOle.IClassFactory) END; VAR instance: WinApi.HMODULE; mainWnd: WinApi.HWND; locks: INTEGER; objects: INTEGER; (* ---------- Koala ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: Koala) RELEASE; (* called when last com reference is removed *) VAR res: INTEGER; BEGIN DEC(objects); IF objects = 0 THEN res := WinApi.PostMessageW(mainWnd, WinApi.WM_CLOSE, 0, 0); END END RELEASE; (* ---------- KoalaFactory ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: KoalaFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: Koala; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN res := new.QueryInterface(iid, int); IF res >= 0 THEN INC(objects) END; RETURN res ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; PROCEDURE (this: KoalaFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; VAR res: INTEGER; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; IF locks = 0 THEN res := WinApi.PostMessageW(mainWnd, WinApi.WM_CLOSE, 0, 0); END; RETURN WinApi.S_OK END LockServer; (* ---------- window handler ---------- *) PROCEDURE WndHandler (wnd: WinApi.HWND; message, wParam, lParam: INTEGER): INTEGER; VAR res: INTEGER; ps: WinApi.PAINTSTRUCT; dc: WinApi.HDC; BEGIN IF message = WinApi.WM_CLOSE THEN IF (locks > 0) OR (objects > 0) THEN RETURN 0 END ELSIF message = WinApi.WM_DESTROY THEN WinApi.PostQuitMessage(0); RETURN 0 ELSIF message = WinApi.WM_PAINT THEN dc := WinApi.BeginPaint(wnd, ps); res := WinApi.TextOutW(dc, 50, 50, "Koala Server", 12); res := WinApi.EndPaint(wnd, ps); RETURN 0 END; RETURN WinApi.DefWindowProcW(wnd, message, wParam, lParam) END WndHandler; PROCEDURE OpenWindow; VAR class: WinApi.WNDCLASSW; res: INTEGER; BEGIN class.hCursor := WinApi.LoadCursorW(0, S.VAL(WinApi.PtrWSTR, WinApi.IDC_ARROW)); class.hIcon := WinApi.LoadIconW(0, S.VAL(WinApi.PtrWSTR, WinApi.IDI_APPLICATION)); class.lpszMenuName := NIL; class.lpszClassName := "Koala"; class.hbrBackground := WinApi.GetStockObject(WinApi.WHITE_BRUSH); class.style := WinApi.CS_HREDRAW + WinApi.CS_VREDRAW; class.hInstance := instance; class.lpfnWndProc := WndHandler; class.cbClsExtra := 0; class.cbWndExtra := 0; res := WinApi.RegisterClassW(class); mainWnd := WinApi.CreateWindowExW({}, "Koala", "Koala", WinApi.WS_OVERLAPPEDWINDOW, WinApi.CW_USEDEFAULT, WinApi.CW_USEDEFAULT, WinApi.CW_USEDEFAULT, WinApi.CW_USEDEFAULT, 0, 0, instance, 0); res := WinApi.ShowWindow(mainWnd, 10); res := WinApi.UpdateWindow(mainWnd); END OpenWindow; (* ---------- main loop ---------- *) PROCEDURE Main; VAR msg: WinApi.MSG; res: COM.RESULT; factory: KoalaFactory; token: INTEGER; BEGIN instance := WinApi.GetModuleHandleW(NIL); res := WinOle.CoInitialize(0); NEW(factory); res := WinOle.CoRegisterClassObject(KoalaId, factory, WinOle.CLSCTX_LOCAL_SERVER, WinOle.REGCLS_MULTIPLEUSE, token); OpenWindow; WHILE WinApi.GetMessageW(msg, 0, 0, 0) # 0 DO res := WinApi.TranslateMessage(msg); res := WinApi.DispatchMessageW(msg); END; res := WinOle.CoRevokeClassObject(token); WinOle.CoUninitialize; WinApi.ExitProcess(msg.wParam) END Main; BEGIN Main END ComKoalaExe. DevLinker.LinkExe EKoala1.exe := Kernel+ ComKoalaExe ~ ----------------------------------------------------------------------------------------------------------------- REGEDIT HKEY_CLASSES_ROOT\Koala1.0 = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala1.0\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\Koala = Koala Object Chapter 5 HKEY_CLASSES_ROOT\Koala\CurVer = Koala1.0 HKEY_CLASSES_ROOT\Koala\CLSID = {00021146-0000-0000-C000-000000000046} HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046} = Koala Object Chapter 5 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\ProgID = Koala1.0 HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\VersionIndependentProgID = Koala HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\LocalServer32 = C:\BlackBox\Com\Ekoala1.exe HKEY_CLASSES_ROOT\CLSID\{00021146-0000-0000-C000-000000000046}\NotInsertable -----------------------------------------------------------------------------------------------------------------

Com/Mod/KoalaExe.odc

MODULE ComKoalaTst; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle, StdLog; CONST KoalaId = "{00021146-0000-0000-C000-000000000046}"; nMax = 10; VAR factory: WinOle.IClassFactory; koala: ARRAY nMax OF COM.IUnknown; n: INTEGER; PROCEDURE CreateClass*; VAR res: INTEGER; BEGIN res := WinOle.CoGetClassObject(KoalaId, WinOle.CLSCTX_LOCAL_SERVER, 0, COM.ID(factory), factory); IF res = WinApi.S_OK THEN StdLog.String("Class creation succeeded"); StdLog.Ln ELSE StdLog.String("Class creation failed, error = "); StdLog.Int(res); StdLog.Ln END END CreateClass; PROCEDURE ReleaseClass*; BEGIN factory := NIL END ReleaseClass; PROCEDURE CreateInstance*; VAR res: INTEGER; BEGIN IF factory # NIL THEN res := factory.CreateInstance(NIL, COM.ID(COM.IUnknown), koala[0]); n := 1; IF res = WinApi.S_OK THEN StdLog.String("Instance creation succeeded"); StdLog.Ln ELSE StdLog.String("Instance creation failed, error = "); StdLog.Int(res); StdLog.Ln END ELSE StdLog.String("Creation failed, class not yet created."); StdLog.Ln END END CreateInstance; PROCEDURE AddRef*; BEGIN IF (n > 0) & (n < nMax) THEN koala[n] := koala[n-1]; INC(n) END END AddRef; PROCEDURE Release*; BEGIN IF n > 0 THEN DEC(n); koala[n] := NIL END END Release; END ComKoalaTst. ComKoala.Register ComKoala.Unregister ComKoalaTst.CreateClass ComKoalaTst.ReleaseClass ComKoalaTst.CreateInstance ComKoalaTst.AddRef ComKoalaTst.Release

Com/Mod/KoalaTst.odc

MODULE ComObject; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20070205, bh, Unicode support " issues = " - ... " **) IMPORT SYSTEM, COM, WinApi, WinOle, ComTools; CONST ObjectID = "{00010001-1000-11cf-adf0-444553540000}"; streamStr = "CONTENTS"; cbFormat = 200H; TYPE IClassFactory = POINTER TO RECORD (WinOle.IClassFactory) END; Object = POINTER TO RECORD (COM.IUnknown) ioo: IOleObject; ido: IDataObject; ips: IPersistStorage; ics: WinOle.IOleClientSite; idah: WinOle.IDataAdviseHolder; ioah: WinOle.IOleAdviseHolder; isg: WinOle.IStorage; ism: WinOle.IStream; w, h: INTEGER END; IOleObject = POINTER TO RECORD (WinOle.IOleObject) obj: Object END; IDataObject = POINTER TO RECORD (WinOle.IDataObject) obj: Object END; IPersistStorage = POINTER TO RECORD (WinOle.IPersistStorage) obj: Object END; VAR locks: INTEGER; token: INTEGER; PROCEDURE PictureOf (obj: Object): WinApi.HMETAFILEPICT; VAR dc: WinApi.HDC; mf: WinApi.HMETAFILE; mp: WinApi.PtrMETAFILEPICT; rc: WinApi.RECT; res: INTEGER; h: WinApi.HMETAFILEPICT; oldb, oldp: WinApi.HGDIOBJ; BEGIN dc := WinApi.CreateMetaFileW(NIL); IF dc # 0 THEN res := WinApi.SetMapMode(dc, WinApi.MM_ANISOTROPIC); res := WinApi.SetWindowOrgEx(dc, 0, 0, NIL); res := WinApi.SetWindowExtEx(dc, 20, 20, NIL); oldb := WinApi.SelectObject(dc, WinApi.GetStockObject(WinApi.NULL_BRUSH)); oldp := WinApi.SelectObject(dc, WinApi.CreatePen(WinApi.PS_SOLID, 1, 0)); res := WinApi.Ellipse(dc, 2, 2, 18, 18); res := WinApi.Ellipse(dc, 6, 6, 8, 8); res := WinApi.Ellipse(dc, 12, 6, 14, 8); res := WinApi.Ellipse(dc, 8, 8, 12, 12); res := WinApi.Ellipse(dc, 6, 14, 14, 16); res := WinApi.SelectObject(dc, oldb); res := WinApi.DeleteObject(WinApi.SelectObject(dc, oldp)); mf := WinApi.CloseMetaFile(dc); IF mf # 0 THEN h := WinApi.GlobalAlloc(WinApi.GMEM_DDESHARE + WinApi.GMEM_MOVEABLE, SIZE(WinApi.METAFILEPICT)); IF h # 0 THEN mp := SYSTEM.VAL(WinApi.PtrMETAFILEPICT, WinApi.GlobalLock(h)); mp.hMF := mf; mp.mm := WinApi.MM_ANISOTROPIC; mp.xExt := obj.w; mp.yExt := obj.h; res := WinApi.GlobalUnlock(h); RETURN h ELSE res := WinApi.DeleteMetaFile(mf) END END END; RETURN 0 END PictureOf; (* ---------- IClassFactory ---------- *) PROCEDURE (this: IClassFactory) CreateInstance (outer: COM.IUnknown; IN iid: COM.GUID; OUT int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: Object; BEGIN IF outer = NIL THEN NEW(new); IF new # NIL THEN NEW(new.ioo, new); NEW(new.ido, new); NEW(new.ips, new); IF (new.ioo # NIL) & (new.ido # NIL) & (new.ips # NIL) THEN new.ioo.obj := new; new.ido.obj := new; new.ips.obj := new; res := new.QueryInterface(iid, int) ELSE res := WinApi.E_OUTOFMEMORY END ELSE res := WinApi.E_OUTOFMEMORY END ELSE res := WinApi.CLASS_E_NOAGGREGATION END; RETURN res END CreateInstance; PROCEDURE (this: IClassFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; RETURN WinApi.S_OK END LockServer; (* ---------- Object ---------- *) PROCEDURE (this: Object) QueryInterface (IN iid: COM.GUID; OUT int: COM.IUnknown): COM.RESULT; BEGIN IF COM.QUERY(this, iid, int) OR COM.QUERY(this.ioo, iid, int) OR COM.QUERY(this.ido, iid, int) OR COM.QUERY(this.ips, iid, int) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.E_NOINTERFACE END END QueryInterface; (* ---------- IOleObject ---------- *) PROCEDURE (this: IOleObject) SetClientSite (site: WinOle.IOleClientSite): COM.RESULT; BEGIN this.obj.ics := site; RETURN WinApi.S_OK END SetClientSite; PROCEDURE (this: IOleObject) GetClientSite (OUT site: WinOle.IOleClientSite): COM.RESULT; BEGIN site := this.obj.ics; RETURN WinApi.S_OK END GetClientSite; PROCEDURE (this: IOleObject) SetHostNames (app, obj: WinApi.PtrWSTR): COM.RESULT; BEGIN RETURN WinApi.S_OK END SetHostNames; PROCEDURE (this: IOleObject) Close (saveOption: INTEGER): COM.RESULT; BEGIN RETURN WinApi.S_OK END Close; PROCEDURE (this: IOleObject) SetMoniker (which: INTEGER; mk: WinOle.IMoniker): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END SetMoniker; PROCEDURE (this: IOleObject) GetMoniker (assign, which: INTEGER; OUT mk: WinOle.IMoniker): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END GetMoniker; PROCEDURE (this: IOleObject) InitFromData (obj: WinOle.IDataObject; creation: WinApi.BOOL; reserved: INTEGER): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END InitFromData; PROCEDURE (this: IOleObject) GetClipboardData (reserved: INTEGER; OUT obj: WinOle.IDataObject): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END GetClipboardData; PROCEDURE (this: IOleObject) DoVerb (verb: INTEGER; IN msg: WinApi.MSG; activeSite: WinOle.IOleClientSite; index: INTEGER; parent: WinApi.HWND; IN posRect: WinApi.RECT): COM.RESULT; BEGIN IF verb < 0 THEN RETURN WinApi.S_OK ELSE RETURN WinApi.OLEOBJ_E_NOVERBS END END DoVerb; PROCEDURE (this: IOleObject) EnumVerbs (OUT enum: WinOle.IEnumOLEVERB): COM.RESULT; BEGIN RETURN WinApi.OLEOBJ_E_NOVERBS END EnumVerbs; PROCEDURE (this: IOleObject) Update (): COM.RESULT; BEGIN RETURN WinApi.S_OK END Update; PROCEDURE (this: IOleObject) IsUpToDate (): COM.RESULT; BEGIN RETURN WinApi.S_OK END IsUpToDate; PROCEDURE (this: IOleObject) GetUserClassID (OUT id: COM.GUID): COM.RESULT; BEGIN id := ObjectID; RETURN WinApi.S_OK END GetUserClassID; PROCEDURE (this: IOleObject) GetUserType (form: INTEGER; OUT type: WinApi.PtrWSTR): COM.RESULT; BEGIN RETURN WinApi.OLE_S_USEREG END GetUserType; PROCEDURE (this: IOleObject) SetExtent (aspect: SET; IN size: WinApi.SIZE): COM.RESULT; VAR res: COM.RESULT; BEGIN IF aspect * WinOle.DVASPECT_CONTENT # {} THEN this.obj.w := size.cx; this.obj.h := size.cy; RETURN WinApi.S_OK ELSE RETURN WinApi.E_FAIL END END SetExtent; PROCEDURE (this: IOleObject) GetExtent (aspect: SET; OUT size: WinApi.SIZE): COM.RESULT; BEGIN IF aspect * WinOle.DVASPECT_CONTENT # {} THEN size.cx := this.obj.w; size.cy := this.obj.h; RETURN WinApi.S_OK ELSE RETURN WinApi.E_FAIL END END GetExtent; PROCEDURE (this: IOleObject) Advise (sink: WinOle.IAdviseSink; OUT connection: INTEGER): COM.RESULT; VAR res: COM.RESULT; BEGIN IF this.obj.ioah = NIL THEN res := WinOle.CreateOleAdviseHolder(this.obj.ioah); IF res < 0 THEN RETURN res END END; RETURN this.obj.ioah.Advise(sink, connection) END Advise; PROCEDURE (this: IOleObject) Unadvise (connection: INTEGER): COM.RESULT; BEGIN IF this.obj.ioah # NIL THEN RETURN this.obj.ioah.Unadvise(connection) ELSE RETURN WinApi.E_FAIL END END Unadvise; PROCEDURE (this: IOleObject) EnumAdvise (OUT enum: WinOle.IEnumSTATDATA): COM.RESULT; BEGIN IF this.obj.ioah # NIL THEN RETURN this.obj.ioah.EnumAdvise(enum) ELSE RETURN WinApi.E_FAIL END END EnumAdvise; PROCEDURE (this: IOleObject) GetMiscStatus (aspect: SET; OUT status: SET): COM.RESULT; BEGIN RETURN WinApi.OLE_S_USEREG END GetMiscStatus; PROCEDURE (this: IOleObject) SetColorScheme (IN pal: WinApi.LOGPALETTE): COM.RESULT; BEGIN RETURN WinApi.E_NOTIMPL END SetColorScheme; (* ---------- IDataObject ---------- *) PROCEDURE (this: IDataObject) GetData (IN format: WinOle.FORMATETC; OUT medium: WinOle.STGMEDIUM): COM.RESULT; VAR res: COM.RESULT; BEGIN res := this.QueryGetData(format); IF res = WinApi.S_OK THEN ComTools.GenMetafileMedium(PictureOf(this.obj), NIL, medium); RETURN WinApi.S_OK ELSE RETURN res END END GetData; PROCEDURE (this: IDataObject) GetDataHere (IN format: WinOle.FORMATETC; VAR medium: WinOle.STGMEDIUM): COM.RESULT; BEGIN RETURN WinApi.DV_E_FORMATETC END GetDataHere; PROCEDURE (this: IDataObject) QueryGetData (IN format: WinOle.FORMATETC): COM.RESULT; BEGIN IF format.dwAspect * WinOle.DVASPECT_CONTENT = {} THEN RETURN WinApi.DV_E_DVASPECT ELSIF format.cfFormat # WinApi.CF_METAFILEPICT THEN RETURN WinApi.DV_E_FORMATETC ELSIF format.tymed * WinOle.TYMED_MFPICT = {} THEN RETURN WinApi.DV_E_TYMED ELSE RETURN WinApi.S_OK END END QueryGetData; PROCEDURE (this: IDataObject) GetCanonicalFormatEtc (IN formatIn: WinOle.FORMATETC; OUT formatOut: WinOle.FORMATETC): COM.RESULT; BEGIN RETURN WinApi.DATA_S_SAMEFORMATETC END GetCanonicalFormatEtc; PROCEDURE (this: IDataObject) SetData (IN format: WinOle.FORMATETC; IN medium: WinOle.STGMEDIUM; release: WinApi.BOOL): COM.RESULT; BEGIN RETURN WinApi.DV_E_FORMATETC END SetData; PROCEDURE (this: IDataObject) EnumFormatEtc (direction: SET; OUT enum: WinOle.IEnumFORMATETC): COM.RESULT; BEGIN RETURN WinApi.OLE_S_USEREG END EnumFormatEtc; PROCEDURE (this: IDataObject) DAdvise (IN format: WinOle.FORMATETC; flags: SET; advSink: WinOle.IAdviseSink; OUT connection: INTEGER): COM.RESULT; VAR res: COM.RESULT; BEGIN IF this.obj.idah = NIL THEN res := WinOle.CreateDataAdviseHolder(this.obj.idah); IF res < 0 THEN RETURN res END END; RETURN this.obj.idah.Advise(this, format, flags, advSink, connection) END DAdvise; PROCEDURE (this: IDataObject) DUnadvise (connection: INTEGER): COM.RESULT; BEGIN IF this.obj.idah # NIL THEN RETURN this.obj.idah.Unadvise(connection) ELSE RETURN WinApi.E_FAIL END END DUnadvise; PROCEDURE (this: IDataObject) EnumDAdvise (OUT enum: WinOle.IEnumSTATDATA): COM.RESULT; BEGIN IF this.obj.idah # NIL THEN RETURN this.obj.idah.EnumAdvise(enum) ELSE RETURN WinApi.E_FAIL END END EnumDAdvise; (* ---------- IPersistStorage ---------- *) PROCEDURE (this: IPersistStorage) GetClassID (OUT id: COM.GUID): COM.RESULT; BEGIN id := ObjectID; RETURN WinApi.S_OK END GetClassID; PROCEDURE (this: IPersistStorage) IsDirty (): COM.RESULT; BEGIN RETURN WinApi.S_FALSE END IsDirty; PROCEDURE (this: IPersistStorage) InitNew (stg: WinOle.IStorage): COM.RESULT; VAR res: COM.RESULT; ps: WinApi.PtrWSTR; BEGIN IF stg # NIL THEN res := stg.CreateStream(streamStr, WinOle.STGM_DIRECT + WinOle.STGM_CREATE + WinOle.STGM_READWRITE + WinOle.STGM_SHARE_EXCLUSIVE, 0, 0, this.obj.ism); IF res >= 0 THEN res := WinOle.OleRegGetUserType(ObjectID, WinOle.USERCLASSTYPE_SHORT, ps); res := WinOle.WriteFmtUserTypeStg(stg, cbFormat, ps); ComTools.FreeString(ps); this.obj.isg := stg; this.obj.w := 5000; this.obj.h := 5000; RETURN WinApi.S_OK ELSE RETURN res END ELSE RETURN WinApi.E_POINTER END END InitNew; PROCEDURE (this: IPersistStorage) Load (stg: WinOle.IStorage): COM.RESULT; VAR res: COM.RESULT; BEGIN IF stg # NIL THEN res := stg.OpenStream(streamStr, 0, WinOle.STGM_DIRECT + WinOle.STGM_READWRITE + WinOle.STGM_SHARE_EXCLUSIVE, 0, this.obj.ism); IF res >= 0 THEN res := this.obj.ism.Read(SYSTEM.ADR(this.obj.w), 4, NIL); res := this.obj.ism.Read(SYSTEM.ADR(this.obj.h), 4, NIL); IF res >= 0 THEN this.obj.isg := stg; RETURN WinApi.S_OK END END; RETURN WinApi.STG_E_READFAULT ELSE RETURN WinApi.E_POINTER END END Load; PROCEDURE (this: IPersistStorage) Save (stg: WinOle.IStorage; sameAsLoad: WinApi.BOOL): COM.RESULT; VAR stm: WinOle.IStream; res: COM.RESULT; ps: WinApi.PtrWSTR; BEGIN IF sameAsLoad # 0 THEN stm := this.obj.ism; res := stm.Seek(0, WinOle.STREAM_SEEK_SET, NIL) ELSIF stg # NIL THEN res := stg.CreateStream(streamStr, WinOle.STGM_DIRECT + WinOle.STGM_CREATE + WinOle.STGM_WRITE + WinOle.STGM_SHARE_EXCLUSIVE, 0, 0, stm); IF res < 0 THEN RETURN res END; res := WinOle.OleRegGetUserType(ObjectID, WinOle.USERCLASSTYPE_SHORT, ps); res := WinOle.WriteFmtUserTypeStg(stg, cbFormat, ps); ComTools.FreeString(ps); ELSE RETURN WinApi.E_POINTER END; res := stm.Write(SYSTEM.ADR(this.obj.w), 4, NIL); res := stm.Write(SYSTEM.ADR(this.obj.h), 4, NIL); IF res < 0 THEN RETURN WinApi.STG_E_WRITEFAULT ELSE RETURN WinApi.S_OK END END Save; PROCEDURE (this: IPersistStorage) SaveCompleted (new: WinOle.IStorage): COM.RESULT; VAR res: COM.RESULT; BEGIN IF new # NIL THEN res := new.OpenStream(streamStr, 0, WinOle.STGM_DIRECT + WinOle.STGM_READWRITE + WinOle.STGM_SHARE_EXCLUSIVE, 0, this.obj.ism); IF res >= 0 THEN this.obj.isg := new; ELSE RETURN res END END; IF this.obj.ioah # NIL THEN res := this.obj.ioah.SendOnSave() END; RETURN WinApi.S_OK END SaveCompleted; PROCEDURE (this: IPersistStorage) HandsOffStorage (): COM.RESULT; BEGIN this.obj.ism := NIL; this.obj.isg := NIL; RETURN WinApi.S_OK END HandsOffStorage; (* ---------- commands ---------- *) PROCEDURE Register*; VAR res: COM.RESULT; factory: IClassFactory; BEGIN NEW(factory); res := WinOle.CoRegisterClassObject(ObjectID, factory, WinOle.CLSCTX_LOCAL_SERVER, WinOle.REGCLS_MULTIPLEUSE, token); END Register; PROCEDURE Unregister*; VAR res: COM.RESULT; BEGIN IF (token # 0) & (locks = 0) THEN res := WinOle.CoRevokeClassObject(token) END END Unregister; END ComObject. ComObject.Register ComObject.Unregister ----------------------------------------------------------------------------------------------------------------- REGEDIT HKEY_CLASSES_ROOT\BlackBox.Object = BlackBox Object HKEY_CLASSES_ROOT\BlackBox.Object\CLSID = {00010001-1000-11cf-adf0-444553540000} HKEY_CLASSES_ROOT\BlackBox.Object\Insertable HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000} = BlackBox Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\ProgID = BlackBox.Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\LocalServer32 = C:\BlackBox\BlackBox.exe HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\InProcHandler32 = ole32.dll HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\Insertable HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\DefaultIcon = C:\BlackBox\BlackBox.exe,0 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\DataFormats\GetSet\0 = 3,1,32,1 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\MiscStatus = 16 HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\AuxUserType\2 = BlackBox Object HKEY_CLASSES_ROOT\CLSID\{00010001-1000-11cf-adf0-444553540000}\AuxUserType\3 = BlackBox -----------------------------------------------------------------------------------------------------------------

Com/Mod/Object.odc

MODULE ComPhoneBook; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle, ComTools; CONST CLSID* = "{E67D346C-2A5B-11D0-ADBA-00C01500554E}"; E_NotFound* = 80004005H; TYPE ILookup* = POINTER TO ABSTRACT RECORD ["{C4910D71-BA7D-11CD-94E8-08001701A8A3}"] (COM.IUnknown) END; CLookup = POINTER TO RECORD (ILookup) phoneBook: Entry END; LookupFactory = POINTER TO RECORD (WinOle.IClassFactory) END; Entry = POINTER TO RECORD next: Entry; name, number: ARRAY 32 OF CHAR END; VAR locks: INTEGER; token: INTEGER; phoneBook: Entry; (* ---------- ILookup ---------- *) PROCEDURE (this: ILookup) LookupByName*( name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: ILookup) LookupByNumber*( number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; (* ---------- CLookup ---------- *) PROCEDURE (this: CLookup) LookupByName(name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT; VAR e: Entry; BEGIN e := this.phoneBook; WHILE (e # NIL) & (e.name # name^) DO e := e.next END; IF e # NIL THEN number := ComTools.NewString(e.number); RETURN WinApi.S_OK ELSE RETURN E_NotFound END END LookupByName; PROCEDURE (this: CLookup) LookupByNumber(number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT; VAR e: Entry; BEGIN e := this.phoneBook; WHILE (e # NIL) & (e.number # number^) DO e := e.next END; IF e # NIL THEN name := ComTools.NewString(e.name); RETURN WinApi.S_OK ELSE RETURN E_NotFound END END LookupByNumber; (* ---------- LookupFactory ---------- *) PROCEDURE (this: LookupFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR new: CLookup; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN new.phoneBook := phoneBook;RETURN new.QueryInterface(iid, int) ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; PROCEDURE (this: LookupFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; RETURN WinApi.S_OK END LockServer; (* ---------- registration ---------- *) PROCEDURE Register*; VAR res: COM.RESULT; factory: LookupFactory; BEGIN NEW(factory); res := WinOle.CoRegisterClassObject(CLSID, factory, WinOle.CLSCTX_LOCAL_SERVER, WinOle.REGCLS_MULTIPLEUSE, token) END Register; PROCEDURE Unregister*; VAR res: COM.RESULT; BEGIN IF (locks = 0) & (token # 0) THEN res := WinOle.CoRevokeClassObject(token); token := 0 END END Unregister; PROCEDURE NewEntry(name, number: ARRAY 32 OF CHAR); VAR e: Entry; BEGIN NEW(e); e.next := phoneBook; phoneBook := e; e.name := name$; e.number := number$ END NewEntry; BEGIN locks := 0; NewEntry("Daffy Duck", "310-555-1212"); NewEntry("Wile E. Coyote", "408-555-1212"); NewEntry("Scrogge McDuck", "206-555-1212"); NewEntry("Huey Lewis", "415-555-1212"); NewEntry("Thomas Dewey", "617-555-1212") END ComPhoneBook.

Com/Mod/PhoneBook.odc

MODULE ComPhoneBookActiveX; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinApi, WinOle, ComTools, WinOleAut; CONST CLSID* = "{E67D346B-2A5B-11D0-ADBA-00C01500554E}"; E_NotFound = -2147467259; typelibrary = "C:\BlackBox\Com\Interfaces\DPhoneBook\phone.tlb"; TYPE ILookup* = POINTER TO ABSTRACT RECORD ["{C4910D72-BA7D-11CD-94E8-08001701A8A3}"] (WinOleAut.IDispatch) END; CLookup = POINTER TO RECORD (ILookup) END; LookupFactory = POINTER TO RECORD (WinOle.IClassFactory) END; Entry = POINTER TO EntryDesc; EntryDesc = RECORD next: Entry; name, number: ARRAY 32 OF CHAR END; VAR locks: INTEGER; objects: INTEGER; phoneBook: Entry; (* ---------- ILookup ---------- *) PROCEDURE (this: ILookup) LookupByName*( name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; PROCEDURE (this: ILookup) LookupByNumber*( number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT, NEW, ABSTRACT; (* ---------- CLookup ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: CLookup) LookupByName(name: WinApi.PtrWSTR; OUT number: WinApi.PtrWSTR): COM.RESULT; VAR e: Entry; ustr: ARRAY [untagged] 32 OF CHAR; i: INTEGER; BEGIN e := phoneBook; WHILE (e # NIL) & (e.name # name^) DO e := e.next END; IF e # NIL THEN i := 0; REPEAT ustr[i] := e.number[i]; INC(i) UNTIL e.number[i-1] = 0X; number := ComTools.NewString(ustr); RETURN WinApi.S_OK ELSE RETURN E_NotFound END END LookupByName; PROCEDURE (this: CLookup) LookupByNumber(number: WinApi.PtrWSTR; OUT name: WinApi.PtrWSTR): COM.RESULT; VAR e: Entry; ustr: ARRAY [untagged] 32 OF CHAR; i: INTEGER; BEGIN e := phoneBook; WHILE (e # NIL) & (e.number # number^) DO e := e.next END; IF e # NIL THEN i := 0; REPEAT ustr[i] := e.name[i]; INC(i) UNTIL e.name[i-1] = 0X; name := ComTools.NewString(ustr); RETURN WinApi.S_OK ELSE RETURN E_NotFound END END LookupByNumber; PROCEDURE (this: CLookup) Invoke (dispIdMember: WinOleAut.DISPID; IN riid: COM.GUID; lcid: WinOle.LCID; wFlags: SHORTINT; VAR [nil] pDispParams: WinOleAut.DISPPARAMS; OUT [nil] pVarResult: WinOleAut.VARIANT; OUT [nil] pExcepInfo: WinOleAut.EXCEPINFO; OUT [nil] puArgErr: INTEGER ): COM.RESULT; VAR wstr: WinApi.PtrWSTR; res: INTEGER; (* bstr: WinOle.BSTR; *) BEGIN IF (dispIdMember = 1) OR (dispIdMember = 2) THEN IF pDispParams.cArgs = 1 THEN IF pDispParams.rgvarg[0].vt = WinOle.VT_BSTR THEN IF dispIdMember = 1 THEN res := this.LookupByName(pDispParams.rgvarg[0].u.bstrVal, wstr) ELSE res := this.LookupByNumber(pDispParams.rgvarg[0].u.bstrVal, wstr) END; IF res = 0 THEN pVarResult.vt := WinOle.VT_BSTR; pVarResult.u.bstrVal := WinOleAut.SysAllocString(wstr^); RETURN WinApi.S_OK ELSE pExcepInfo.wCode := 0; pExcepInfo.wReserved := 0; pExcepInfo.bstrSource := WinOleAut.SysAllocString("PhoneBook.Lookup"); pExcepInfo.bstrDescription := WinOleAut.SysAllocString("Entry not found"); pExcepInfo.bstrHelpFile := NIL; pExcepInfo.pfnDeferredFillIn := NIL; pExcepInfo.scode := res; RETURN WinApi.DISP_E_EXCEPTION END ELSE RETURN WinApi.DISP_E_BADVARTYPE END ELSE RETURN WinApi.DISP_E_BADPARAMCOUNT END; ELSE RETURN WinApi.DISP_E_MEMBERNOTFOUND END END Invoke; PROCEDURE (this: CLookup) GetIDsOfNames (IN [nil] riid: COM.GUID (* NULL *); IN [nil] rgszNames: WinApi.PtrWSTR; cNames: INTEGER; lcid: WinOle.LCID; OUT [nil] rgDispId: WinOleAut.DISPID ): COM.RESULT; VAR lib: WinOleAut.ITypeLib; ptinfo: WinOleAut.ITypeInfo; names: WinApi.PtrWSTR;res: INTEGER; BEGIN res := WinOleAut.LoadTypeLib(ComTools.NewString(typelibrary), lib); res := lib.GetTypeInfoOfGuid(COM.ID(ILookup), ptinfo); names := ComTools.NewString(rgszNames^); res := WinOleAut.DispGetIDsOfNames(ptinfo, names, cNames, rgDispId); RETURN 0 END GetIDsOfNames; PROCEDURE (this: CLookup) GetTypeInfo (iTInfo: INTEGER; lcid: WinOle.LCID; OUT [nil] ppTInfo: WinOleAut.ITypeInfo): COM.RESULT; VAR lib: WinOleAut.ITypeLib; res: INTEGER; BEGIN res := WinOleAut.LoadTypeLib(ComTools.NewString(typelibrary), lib); RETURN lib.GetTypeInfo(iTInfo, ppTInfo) END GetTypeInfo; PROCEDURE (this: CLookup) GetTypeInfoCount (OUT [nil] pctinfo: INTEGER): COM.RESULT; BEGIN pctinfo := 1; (* type info available *) RETURN 0 END GetTypeInfoCount; PROCEDURE (this: CLookup) RELEASE; (* called when last com reference is removed *) BEGIN DEC(objects) END RELEASE; (* ---------- LookupFactory ---------- *) (* use default QueryInterface implementation *) (* AddRef & Release implemented implicitly by the compiler *) PROCEDURE (this: LookupFactory) CreateInstance (outer: COM.IUnknown; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR res: COM.RESULT; new: CLookup; BEGIN IF outer # NIL THEN RETURN WinApi.CLASS_E_NOAGGREGATION END; NEW(new); IF new # NIL THEN res := new.QueryInterface(iid, int); IF res >= 0 THEN INC(objects) END; RETURN res ELSE RETURN WinApi.E_OUTOFMEMORY END END CreateInstance; PROCEDURE (this: LookupFactory) LockServer (lock: WinApi.BOOL): COM.RESULT; BEGIN IF lock # 0 THEN INC(locks) ELSE DEC(locks) END; RETURN WinApi.S_OK END LockServer; (* ---------- dll interface ---------- *) PROCEDURE DllGetClassObject* (IN clsid: COM.GUID; IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown): COM.RESULT; VAR obj: LookupFactory; BEGIN IF clsid = CLSID THEN NEW(obj); IF obj # NIL THEN RETURN obj.QueryInterface(iid, int) ELSE RETURN WinApi.E_OUTOFMEMORY; END ELSE RETURN WinApi.E_FAIL END END DllGetClassObject; PROCEDURE DllCanUnloadNow* (): COM.RESULT; BEGIN IF (objects = 0) & (locks = 0) THEN RETURN WinApi.S_OK ELSE RETURN WinApi.S_FALSE END END DllCanUnloadNow; PROCEDURE NewEntry(name, number: ARRAY OF CHAR); VAR e: Entry; BEGIN NEW(e); e.next := phoneBook; phoneBook := e; e.name := name$; e.number := number$ END NewEntry; BEGIN locks := 0; objects := 0; NewEntry("Daffy Duck", "310-555-1212"); NewEntry("Wile E. Coyote", "408-555-1212"); NewEntry("Scrooge McDuck", "206-555-1212"); NewEntry("Huey Lewis", "415-555-1212"); NewEntry("Thomas Dewey", "617-555-1212"); END ComPhoneBookActiveX. DevLinker.LinkDll "Com/phone.dll" := Kernel+ ComTools ComPhoneBookActiveX# ~ REGEDIT HKEY_CLASSES_ROOT\PhoneBook = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\PhoneBook\CLSID = {E67D346B-2A5B-11D0-ADBA-00C01500554E} HKEY_CLASSES_ROOT\PhoneBook\TypeLib = {C4910D73-BA7D-11CD-94E8-08001701A8A3} HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E} = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\ProgID = PhoneBook1.0 HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\Control HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\Version = 1.0 HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\VersionIndependentProgID = PhoneBook HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\TypeLib = {C4910D73-BA7D-11CD-94E8-08001701A8A3} HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\InprocServer32 = C:\BlackBox\Com\phone.dll HKEY_CLASSES_ROOT\CLSID\{E67D346B-2A5B-11D0-ADBA-00C01500554E}\NotInsertable HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0 = PhoneBook ActiveX Control HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\0\win32 = C:\BlackBox\Com\Interfaces\DPhoneBook\phone.tlb HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\FLAGS = 0 HKEY_CLASSES_ROOT\TypeLib\{C4910D73-BA7D-11CD-94E8-08001701A8A3}\1.0\HELPDIR = C:\BlackBox\Com\Interfaces\DPhoneBook

Com/Mod/PhoneBookActiveX.odc

MODULE ComPhoneBookClient; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT COM, WinOle, WinApi, ComTools, StdLog, ComPhoneBook, Dialog; VAR para*: RECORD name*: Dialog.Combo; number*: ARRAY 32 OF CHAR END; PROCEDURE GetNumber*; VAR phoneBook: ComPhoneBook.ILookup; res: INTEGER; str: WinApi.PtrWSTR; BEGIN res := WinOle.CoCreateInstance(ComPhoneBook.CLSID, NIL, WinOle.CLSCTX_SERVER, COM.ID(phoneBook), phoneBook); IF res = WinApi.S_OK THEN res := phoneBook.LookupByName(para.name.item, str); IF res = WinApi.S_OK THEN para.number := str$; ComTools.FreeString(str) ELSE StdLog.String("GetNumber failed, error = "); StdLog.Int(res); StdLog.Ln; para.number := "" END; Dialog.Update(para) ELSE StdLog.String("Instance creation failed, error = "); StdLog.Int(res); StdLog.Ln END; END GetNumber; BEGIN para.name.SetLen(5); para.name.SetItem(0, "Daffy Duck"); para.name.SetItem(1, "Wile E. Coyote"); para.name.SetItem(2, "Scrogge McDuck"); para.name.SetItem(3, "Huey Lewis"); para.name.SetItem(4, "Thomas Dewey"); END ComPhoneBookClient. ComPhoneBook.Register ComPhoneBook.Unregister "StdCmds.OpenToolDialog('Com/Rsrc/PhoneBook', 'PhoneBook')"

Com/Mod/PhoneBookClient.odc

MODULE ComTools; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT SYSTEM, COM, WinApi, WinOle; (* ole string handling *) PROCEDURE NewString* (IN str: ARRAY [untagged] OF CHAR): WinApi.PtrWSTR; VAR p: WinApi.PtrWSTR; n: INTEGER; BEGIN n := 0; WHILE str[n] # 0X DO INC(n) END; p := SYSTEM.VAL(WinApi.PtrWSTR, WinOle.CoTaskMemAlloc(SIZE(CHAR) * (n + 1))); p^ := str$; RETURN p END NewString; PROCEDURE NewEmptyString* (length: INTEGER): WinApi.PtrWSTR; BEGIN RETURN SYSTEM.VAL(WinApi.PtrWSTR, WinOle.CoTaskMemAlloc(SIZE(CHAR) * length)) END NewEmptyString; PROCEDURE FreeString* (VAR p: WinApi.PtrWSTR); BEGIN WinOle.CoTaskMemFree(SYSTEM.VAL(WinApi.PtrVoid, p)); p := NIL END FreeString; PROCEDURE NewSString* (IN str: ARRAY [untagged] OF SHORTCHAR): WinApi.PtrSTR; VAR p: WinApi.PtrSTR; n: INTEGER; BEGIN n := 0; WHILE str[n] # 0X DO INC(n) END; p := SYSTEM.VAL(WinApi.PtrSTR, WinOle.CoTaskMemAlloc(SIZE(SHORTCHAR) * (n + 1))); p^ := str$; RETURN p END NewSString; PROCEDURE NewEmptySString* (length: INTEGER): WinApi.PtrSTR; BEGIN RETURN SYSTEM.VAL(WinApi.PtrSTR, WinOle.CoTaskMemAlloc(SIZE(CHAR) * length)) END NewEmptySString; PROCEDURE FreeSString* (VAR p: WinApi.PtrSTR); BEGIN WinOle.CoTaskMemFree(SYSTEM.VAL(WinApi.PtrVoid, p)); p := NIL END FreeSString; (* FORMATETC generation *) PROCEDURE GenFormatEtc* (format: SHORTINT; aspect: SET; tymed: SET; OUT f: WinOle.FORMATETC); BEGIN f.cfFormat := format; f.ptd := NIL; f.dwAspect := aspect; f.lindex := -1; f.tymed := tymed END GenFormatEtc; (* STGMEDIUM generation *) PROCEDURE GenBitmapMedium* ( bitmap: WinApi.HBITMAP; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_GDI; sm.u.hBitmap := bitmap; sm.pUnkForRelease := unk END GenBitmapMedium; PROCEDURE GenMetafileMedium* ( mf: WinApi.HMETAFILEPICT; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_MFPICT; sm.u.hMetaFilePict := mf; sm.pUnkForRelease := unk END GenMetafileMedium; PROCEDURE GenEMetafileMedium* ( emf: WinApi.HENHMETAFILE; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_ENHMF; sm.u.hEnhMetaFile := emf; sm.pUnkForRelease := unk END GenEMetafileMedium; PROCEDURE GenGlobalMedium* (hg: WinApi.HGLOBAL; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_HGLOBAL; sm.u.hGlobal := hg; sm.pUnkForRelease := unk END GenGlobalMedium; PROCEDURE GenFileMedium* (name: ARRAY OF CHAR; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_FILE; sm.u.lpszFileName := NewString(name); sm.pUnkForRelease := unk END GenFileMedium; PROCEDURE GenStreamMedium* (stm: WinOle.IStream; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_ISTREAM; sm.u.pstm := stm; sm.pUnkForRelease := unk END GenStreamMedium; PROCEDURE GenStorageMedium* (stg: WinOle.IStorage; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM); BEGIN IF sm.tymed # WinOle.TYMED_NULL THEN WinOle.ReleaseStgMedium(sm) END; sm.tymed := WinOle.TYMED_ISTORAGE; sm.u.pstg := stg; sm.pUnkForRelease := unk END GenStorageMedium; (* STGMEDIUM access *) PROCEDURE MediumBitmap* (IN sm: WinOle.STGMEDIUM): WinApi.HBITMAP; BEGIN ASSERT(sm.tymed = WinOle.TYMED_GDI, 20); RETURN sm.u.hBitmap END MediumBitmap; PROCEDURE MediumMetafile* (IN sm: WinOle.STGMEDIUM): WinApi.HMETAFILEPICT; BEGIN ASSERT(sm.tymed = WinOle.TYMED_MFPICT, 20); RETURN sm.u.hMetaFilePict END MediumMetafile; PROCEDURE MediumEnhMetafile* (IN sm: WinOle.STGMEDIUM): WinApi.HENHMETAFILE; BEGIN ASSERT(sm.tymed = WinOle.TYMED_ENHMF, 20); RETURN sm.u.hEnhMetaFile END MediumEnhMetafile; PROCEDURE MediumGlobal* (IN sm: WinOle.STGMEDIUM): WinApi.HGLOBAL; BEGIN ASSERT(sm.tymed = WinOle.TYMED_HGLOBAL, 20); RETURN sm.u.hGlobal END MediumGlobal; PROCEDURE MediumFile* (IN sm: WinOle.STGMEDIUM): WinApi.PtrWSTR; BEGIN ASSERT(sm.tymed = WinOle.TYMED_FILE, 20); RETURN sm.u.lpszFileName END MediumFile; PROCEDURE MediumStream* (IN sm: WinOle.STGMEDIUM): WinOle.IStream; BEGIN ASSERT(sm.tymed = WinOle.TYMED_ISTREAM, 20); RETURN sm.u.pstm END MediumStream; PROCEDURE MediumStorage* (IN sm: WinOle.STGMEDIUM): WinOle.IStorage; BEGIN ASSERT(sm.tymed = WinOle.TYMED_ISTORAGE, 20); RETURN sm.u.pstg END MediumStorage; END ComTools.

Com/Mod/Tools.odc

MODULE ComTypeLibs; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Code that is only reached with wrapper in options. Code that is not reached with wrapper in options. *) IMPORT COM, WinOle, WinOleAut, TextModels, TextMappers, Strings; CONST (* options *) browse = 1; interface = 2; wrapper = 3; inAuto = 12; inAll = 13; outAuto = 14; outAll = 15; source = 31; (* kind *) value = 1; var = 2; varin = 3; varout = 4; (* conv type *) ret = 1; get = 2; par = 3; refpar = 4; (* pseudo types *) enumerator = -1; record = -2; union = -3; module = -4; class = -5; ptrVoid = -6; VAR modules: ARRAY 16, 64 OF CHAR; noMod: INTEGER; retName: ARRAY 156 OF CHAR; emptyenum: BOOLEAN; (* constant 'emptyenum' has been defined *) PROCEDURE WriteBSTR (s: WinOle.BSTR; VAR out: TextMappers.Formatter); BEGIN IF s # NIL THEN out.WriteString(s$) END END WriteBSTR; PROCEDURE WriteGuid (VAR guid: COM.GUID; VAR out: TextMappers.Formatter); BEGIN out.WriteChar("{"); out.WriteIntForm((guid[2] MOD 256 + 256 * guid[3]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE); out.WriteIntForm((guid[0] MOD 256 + 256 * guid[1]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE); out.WriteChar("-"); out.WriteIntForm((guid[4] MOD 256 + 256 * guid[5]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE); out.WriteChar("-"); out.WriteIntForm((guid[6] MOD 256 + 256 * guid[7]) MOD 65536, TextMappers.hexadecimal, 4, "0", FALSE); out.WriteChar("-"); out.WriteIntForm((guid[8]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[9]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteChar("-"); out.WriteIntForm((guid[10]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[11]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[12]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[13]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[14]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteIntForm((guid[15]) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE); out.WriteChar("}") END WriteGuid; PROCEDURE^ GetInfoType (tinfo: WinOleAut.ITypeInfo; OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo); PROCEDURE GetDescType (IN desc: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo); VAR res: COM.RESULT; t: INTEGER; i: WinOleAut.ITypeInfo; BEGIN type := desc.vt; IF type = WinOle.VT_USERDEFINED THEN res := tinfo.GetRefTypeInfo(desc.u.hreftype, i); GetInfoType(i, type, info) ELSIF type = WinOle.VT_PTR THEN GetDescType(desc.u.lptdesc, tinfo, t, i); IF (i # NIL) & ((t = WinOle.VT_DISPATCH) OR (t = WinOle.VT_UNKNOWN)) OR (t = WinOle.VT_VARIANT) OR (t = WinOle.VT_SAFEARRAY) THEN type := t; info := i ELSIF t = WinOle.VT_VOID THEN type := ptrVoid END END END GetDescType; PROCEDURE GetInfoType (tinfo: WinOleAut.ITypeInfo; OUT type: INTEGER; OUT info: WinOleAut.ITypeInfo); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; i: INTEGER; flags: SET; ti: WinOleAut.ITypeInfo; t: WinOleAut.HREFTYPE; BEGIN info := tinfo; res := tinfo.GetTypeAttr(attr); CASE attr.typekind OF | WinOleAut.TKIND_ENUM: type := WinOle.VT_I4 | WinOleAut.TKIND_RECORD: type := record | WinOleAut.TKIND_UNION: type := union | WinOleAut.TKIND_MODULE: type := module | WinOleAut.TKIND_INTERFACE: type := WinOle.VT_UNKNOWN | WinOleAut.TKIND_DISPATCH: type := WinOle.VT_DISPATCH | WinOleAut.TKIND_ALIAS: GetDescType(attr.tdescAlias, tinfo, type, info) | WinOleAut.TKIND_COCLASS: type := class; i := 0; WHILE (i < attr.cImplTypes) & (type = class) DO res := tinfo.GetImplTypeFlags(i, flags); IF (WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags # {} ) & (WinOleAut.IMPLTYPEFLAG_FSOURCE * flags = {} ) THEN res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 101); res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 102); GetInfoType(ti, type, info) END; INC(i) END END; tinfo.ReleaseTypeAttr(attr) END GetInfoType; PROCEDURE WriteVariant (VAR v: WinOleAut.VARIANT; VAR out: TextMappers.Formatter); BEGIN IF ODD(v.vt DIV WinOle.VT_ARRAY) THEN out.WriteSString("array "); (* to be completed *) ELSIF ODD(v.vt DIV WinOle.VT_BYREF) THEN out.WriteSString("ref "); CASE v.vt MOD 4096 OF | WinOle.VT_UI1: out.WriteInt(ORD(v.u.pbVal[0])) | WinOle.VT_I2: out.WriteInt(v.u.piVal[0]) | WinOle.VT_I4: IF v.u.plVal[0] = 80000000H THEN out.WriteString("80000000H") ELSE out.WriteInt(v.u.plVal[0]) END | WinOle.VT_R4: out.WriteReal(v.u.pfltVal[0]) | WinOle.VT_R8: out.WriteReal(v.u.pdblVal[0]) | WinOle.VT_BOOL: IF v.u.pboolVal[0] = 0 THEN out.WriteSString("FALSE") ELSE out.WriteSString("TRUE") END | WinOle.VT_CY: out.WriteReal(v.u.pcyVal[0] / 10000) | WinOle.VT_DATE: out.WriteReal(v.u.pdate[0]) | WinOle.VT_BSTR: out.WriteChar('"'); WriteBSTR(v.u.pbstrVal[0], out); out.WriteChar('"') | WinOle.VT_ERROR: out.WriteIntForm(v.u.pscode[0], TextMappers.hexadecimal, 9, "0", TRUE) | WinOle.VT_DISPATCH: out.WriteSString("IDispatch") | WinOle.VT_UNKNOWN: out.WriteSString("IUnknown") ELSE out.WriteSString("undefined ("); out.WriteInt(v.vt MOD 4096); out.WriteChar(")") END ELSE CASE v.vt MOD 4096 OF | WinOle.VT_NULL: out.WriteSString("NIL") | WinOle.VT_UI1: out.WriteInt(ORD(v.u.bVal)) | WinOle.VT_I2: out.WriteInt(v.u.iVal) | WinOle.VT_I4: IF v.u.lVal = 80000000H THEN out.WriteString("80000000H") ELSE out.WriteInt(v.u.lVal) END | WinOle.VT_R4: out.WriteReal(v.u.fltVal) | WinOle.VT_R8: out.WriteReal(v.u.dblVal) | WinOle.VT_BOOL: IF v.u.boolVal = 0 THEN out.WriteSString("FALSE") ELSE out.WriteSString("TRUE") END | WinOle.VT_CY: out.WriteReal(v.u.cyVal / 10000) | WinOle.VT_DATE: out.WriteReal(v.u.date) | WinOle.VT_BSTR: out.WriteChar('"'); WriteBSTR(v.u.bstrVal, out); out.WriteChar('"') | WinOle.VT_ERROR: out.WriteIntForm(v.u.scode, TextMappers.hexadecimal, 9, "0", TRUE) | WinOle.VT_DISPATCH: out.WriteSString("IDispatch") | WinOle.VT_UNKNOWN: out.WriteSString("IUnknown") ELSE out.WriteSString("undefined ("); out.WriteInt(v.vt MOD 4096); out.WriteChar(")") END END END WriteVariant; PROCEDURE WriteTypeName ( tinfo: WinOleAut.ITypeInfo; convert, isThis: BOOLEAN; VAR out: TextMappers.Formatter ); VAR ti: WinOleAut.ITypeInfo; lib: WinOleAut.ITypeLib; i, n, vt: INTEGER; res: COM.RESULT; s: WinOle.BSTR; mod, name: ARRAY 64 OF CHAR; flags: SET; BEGIN res := tinfo.GetContainingTypeLib(lib, i); ASSERT(res >= 0, 102); res := lib.GetDocumentation(-1, s, NIL, NIL, NIL); ASSERT(res >= 0, 105); mod := s$; WinOleAut.SysFreeString(s); res := tinfo.GetDocumentation(-1, s, NIL, NIL, NIL); ASSERT(res >= 0, 106); (* !!! *) name := s$; WinOleAut.SysFreeString(s); IF convert THEN IF mod = "stdole" THEN IF name = "IDispatch" THEN mod := "CtlT"; name := "Object" ELSE mod := "CtlStdType" END ELSE GetInfoType(tinfo, vt, ti); IF vt = WinOle.VT_UNKNOWN THEN mod := "CtlT"; name := "IUnknown" ELSE mod := "Ctl" + mod END END; END; i := 0; WHILE (i < noMod) & (modules[i] # mod) DO INC(i) END; IF i = noMod THEN modules[i] := mod$; INC(noMod) END; IF i # 0 THEN out.WriteString(mod); out.WriteChar(".") END; IF isThis THEN out.WriteString("This") END; out.WriteString(name) END WriteTypeName; PROCEDURE WriteHandleName ( t: WinOleAut.HREFTYPE; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter ); VAR res: COM.RESULT; type: WinOleAut.ITypeInfo; BEGIN res := tinfo.GetRefTypeInfo(t, type); (* ASSERT(res >= 0, 100); *) IF res >= 0 THEN WriteTypeName(type, wrapper IN opts, FALSE, out) ELSE out.WriteSString("???("); out.WriteInt(res); out.WriteChar(")") END END WriteHandleName; PROCEDURE WriteType ( VAR t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter ); VAR i, vt: INTEGER; ti: WinOleAut.ITypeInfo; BEGIN CASE t.vt OF | WinOle.VT_I2: out.WriteSString("SHORTINT") | WinOle.VT_I4: out.WriteSString("INTEGER") | WinOle.VT_R4: out.WriteSString("SHORTREAL") | WinOle.VT_R8: out.WriteSString("REAL") | WinOle.VT_CY: IF wrapper IN opts THEN out.WriteSString("CtlT.OleCy") ELSE out.WriteSString("CURRENCY") END | WinOle.VT_DATE: IF wrapper IN opts THEN out.WriteSString("CtlT.OleDate") ELSE out.WriteSString("DATE") END | WinOle.VT_BSTR: IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("WinOle.BSTR") END | WinOle.VT_DISPATCH: IF wrapper IN opts THEN out.WriteSString("CtlT.Object") ELSE out.WriteSString("WinOleAut.IDispatch") END | WinOle.VT_ERROR: out.WriteSString("CtlT.RESULT") | WinOle.VT_BOOL: IF wrapper IN opts THEN out.WriteSString("BOOLEAN") ELSE out.WriteSString("WinOle.VARIANT_BOOL") END | WinOle.VT_VARIANT: IF wrapper IN opts THEN out.WriteSString("CtlT.Any") ELSE out.WriteSString("WinOleAut.VARIANT") END | WinOle.VT_UNKNOWN: out.WriteSString("CtlT.IUnknown") | WinOle.VT_DECIMAL: out.WriteSString("DECIMAL") | WinOle.VT_I1: out.WriteSString("BYTE") | WinOle.VT_UI1: out.WriteSString("BYTE") | WinOle.VT_UI2: out.WriteSString("SHORTINT") | WinOle.VT_UI4: out.WriteSString("INTEGER") | WinOle.VT_I8: out.WriteSString("LONGINT") | WinOle.VT_UI8: out.WriteSString("LONGINT") | WinOle.VT_INT: out.WriteSString("INTEGER") | WinOle.VT_UINT: out.WriteSString("INTEGER") | WinOle.VT_VOID: IF browse IN opts THEN out.WriteSString("VOID") ELSE out.WriteSString("RECORD END") END | WinOle.VT_HRESULT: out.WriteSString("CtlT.RESULT") | WinOle.VT_PTR: GetDescType(t, tinfo, vt, ti); IF vt = ptrVoid THEN out.WriteSString("CtlT.PtrVoid") ELSIF vt # WinOle.VT_PTR THEN WriteType(t.u.lptdesc, tinfo, opts, out) ELSE out.WriteSString("POINTER TO "); WriteType(t.u.lptdesc^, tinfo, opts, out) END | WinOle.VT_SAFEARRAY: IF wrapper IN opts THEN out.WriteSString("CtlT.Any") ELSE out.WriteSString("ARRAY [safe] OF "); WriteType(t.u.lptdesc^, tinfo, opts, out) END | WinOle.VT_CARRAY: out.WriteSString("ARRAY "); i := 0; WHILE i < t.u.lpadesc.cDims DO out.WriteInt(t.u.lpadesc.rgbounds[i].cElements); out.WriteChar(" "); INC(i) END; out.WriteSString("OF "); WriteType(t.u.lpadesc.tdescElem, tinfo, opts, out) | WinOle.VT_USERDEFINED: WriteHandleName(t.u.hreftype, tinfo, opts, out) | WinOle.VT_LPSTR: IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("PtrSTR") END | WinOle.VT_LPWSTR: IF wrapper IN opts THEN out.WriteSString("CtlT.Strg") ELSE out.WriteSString("PtrWSTR") END | enumerator: out.WriteSString("CtlT.Enumerator") END END WriteType; PROCEDURE WriteShortType (VAR t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter); VAR vt: INTEGER; ti: WinOleAut.ITypeInfo; res: COM.RESULT; BEGIN GetDescType(t, tinfo, vt, ti); CASE vt OF | WinOle.VT_I2: out.WriteSString("SInt") | WinOle.VT_I4: out.WriteSString("Int") | WinOle.VT_R4: out.WriteSString("SReal") | WinOle.VT_R8: out.WriteSString("Real") | WinOle.VT_CY: out.WriteSString("Cy") | WinOle.VT_DATE: out.WriteSString("Date") | WinOle.VT_BSTR: out.WriteSString("Str") | WinOle.VT_DISPATCH: out.WriteSString("Obj") | WinOle.VT_ERROR: out.WriteSString("Res") | WinOle.VT_BOOL: out.WriteSString("Bool") | WinOle.VT_VARIANT: out.WriteSString("Any") | WinOle.VT_UNKNOWN: out.WriteSString("Intfce") | WinOle.VT_DECIMAL: out.WriteSString("Decimal") | WinOle.VT_I1: out.WriteSString("Byte") | WinOle.VT_UI1: out.WriteSString("Byte") | WinOle.VT_UI2: out.WriteSString("SInt") | WinOle.VT_UI4: out.WriteSString("Int") | WinOle.VT_I8: out.WriteSString("LInt") | WinOle.VT_UI8: out.WriteSString("LInt") | WinOle.VT_INT: out.WriteSString("Int") | WinOle.VT_UINT: out.WriteSString("Int") | WinOle.VT_VOID: out.WriteSString("Void") | WinOle.VT_HRESULT: out.WriteSString("Res") | WinOle.VT_PTR: out.WriteSString("Pointer") | WinOle.VT_SAFEARRAY: out.WriteSString("Any"); (* t.u.lptdesc *) | WinOle.VT_CARRAY: out.WriteSString("Array"); | WinOle.VT_USERDEFINED: HALT(100) | WinOle.VT_LPSTR: out.WriteSString("Str") | WinOle.VT_LPWSTR: out.WriteSString("Str") | enumerator: out.WriteSString("Enum") | ptrVoid: out.WriteSString("Int") | record: out.WriteSString("Record") | union: out.WriteSString("Union") | module: out.WriteSString("Module") | class: out.WriteSString("Class") END END WriteShortType; PROCEDURE WriteTypeFlags (flags: SHORTINT; VAR out: TextMappers.Formatter); BEGIN IF ODD(flags DIV WinOleAut.TYPEFLAG_FAPPOBJECT) THEN out.WriteSString(", appObject") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FCANCREATE) THEN out.WriteSString(", createable") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FLICENSED) THEN out.WriteSString(", licensed") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FPREDECLID) THEN out.WriteSString(", predeclared") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FCONTROL) THEN out.WriteSString(", control") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FDUAL) THEN out.WriteSString(", dual") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FNONEXTENSIBLE) THEN out.WriteSString(", nonextensible") END; IF ODD(flags DIV WinOleAut.TYPEFLAG_FOLEAUTOMATION) THEN out.WriteSString(", oleauto") END END WriteTypeFlags; PROCEDURE WriteTypeConv (t: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo; type, n: INTEGER; VAR out: TextMappers.Formatter); VAR ti: WinOleAut.ITypeInfo; vt: INTEGER; BEGIN GetDescType(t, tinfo, vt, ti); IF (vt = WinOle.VT_DISPATCH) & (ti # NIL) THEN WriteTypeName(ti, TRUE, TRUE, out); IF type = ret THEN out.WriteSString("(CtlC.VarAny("); out.WriteString(retName); out.WriteString("))") ELSIF type = get THEN out.WriteSString("(CtlC.GetAny(this, "); out.WriteInt(n); out.WriteSString("))") ELSIF type = par THEN out.WriteSString("(CtlC.VarAny(par["); out.WriteInt(n); out.WriteSString("]))") ELSE (* type = refpar *) out.WriteSString("(CtlC.VarRefAny(par["); out.WriteInt(n); out.WriteSString("])[0])") END ELSE IF type = ret THEN out.WriteSString("CtlC.Var"); WriteShortType(t, tinfo, out); out.WriteChar("("); out.WriteString(retName); out.WriteChar(")") ELSIF type = get THEN out.WriteSString("CtlC.Get"); WriteShortType(t, tinfo, out); out.WriteSString("(this, "); out.WriteInt(n); out.WriteChar(")") ELSIF type = par THEN out.WriteSString("CtlC.Var"); WriteShortType(t, tinfo, out); out.WriteSString("(par["); out.WriteInt(n); out.WriteSString("])") ELSE (* type = refpar *) out.WriteSString("CtlC.VarRef"); WriteShortType(t, tinfo, out); out.WriteSString("(par["); out.WriteInt(n); out.WriteSString("])[0]") END END END WriteTypeConv; PROCEDURE IsSpecial (IN type: WinOleAut.TYPEDESC; tinfo: WinOleAut.ITypeInfo): BOOLEAN; (* special handling needed for bool, string, dispatch & variant passed by reference *) VAR ti: WinOleAut.ITypeInfo; vt: INTEGER; BEGIN GetDescType(type, tinfo, vt, ti); RETURN (vt = WinOle.VT_BOOL) OR (vt = WinOle.VT_BSTR) OR (vt = WinOle.VT_DISPATCH) OR (vt = WinOle.VT_VARIANT) END IsSpecial; PROCEDURE GetParamType (IN param: WinOleAut.ELEMDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; OUT type: WinOleAut.TYPEDESC; OUT kind: SHORTINT); VAR flags: SHORTINT; vt: INTEGER; ti: WinOleAut.ITypeInfo; BEGIN type := param.tdesc; kind := value; GetDescType(param.tdesc, tinfo, vt, ti); IF (type.vt = WinOle.VT_PTR) & (vt = WinOle.VT_PTR) THEN flags := param.u.paramdesc.wParamFlags; type := type.u.lptdesc^; IF ODD(flags DIV WinOleAut.PARAMFLAG_FIN) THEN IF ~ODD(flags DIV WinOleAut.PARAMFLAG_FOUT) THEN kind := varin; (* correction for wrong IN attributes *) GetDescType(type, tinfo, vt, ti); IF (vt # record) & (vt # union) & (vt # WinOle.VT_CARRAY) THEN kind := var END ELSE kind := var END ELSIF ODD(flags DIV WinOleAut.PARAMFLAG_FOUT) THEN kind := varout ELSE kind := var END END END GetParamType; PROCEDURE ShowVar (VAR var: WinOleAut.PtrVARDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR n: INTEGER; name, s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT; BEGIN res := tinfo.GetNames(var.memid, name, 1, n); out.WriteTab; out.WriteTab; out.WriteTab; IF name^ = "emptyenum" THEN (* required e.g. for Microsoft Word 15; define 'emptyenum' only once *) IF emptyenum THEN (* already defined *) out.WriteSString("(* emptyenum *)"); out.WriteLn; WinOleAut.SysFreeString(name); RETURN END; emptyenum := TRUE END; WriteBSTR(name, out); WinOleAut.SysFreeString(name); IF var.varkind = WinOleAut.VAR_CONST THEN out.WriteSString("* = "); WriteVariant(var.u.lpvarValue^, out) ELSE IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteChar("-") ELSE out.WriteChar("*") END; IF var.varkind = WinOleAut.VAR_STATIC THEN res := tinfo.GetDllEntry(var.memid, 0, s, t, e); IF res >= 0 THEN out.WriteSString(" ["); IF s # NIL THEN out.WriteChar('"'); WriteBSTR(s, out); out.WriteSString('", '); WinOleAut.SysFreeString(s) END; IF t # NIL THEN out.WriteChar('"'); WriteBSTR(s, out); out.WriteChar('"'); WinOleAut.SysFreeString(t) ELSE out.WriteChar('"'); out.WriteInt(e); out.WriteChar('"') END; out.WriteChar("]") END END; out.WriteSString(": "); WriteType(var.elemdescVar.tdesc, tinfo, opts + {browse}, out) END; out.WriteChar(";"); res := tinfo.GetDocumentation(var.memid, NIL, s, NIL, NIL); IF (s # NIL) OR (browse IN opts) THEN out.WriteSString(" (* "); IF s # NIL THEN WriteBSTR(s, out); IF browse IN opts THEN out.WriteSString(", ") END; WinOleAut.SysFreeString(s) END; IF browse IN opts THEN out.WriteSString("id: "); out.WriteIntForm(var.memid, TextMappers.hexadecimal, 8, "0", FALSE); IF var.varkind = WinOleAut.VAR_DISPATCH THEN out.WriteSString(", property") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteSString(", readonly") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FSOURCE) THEN out.WriteSString(", source") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FBINDABLE) THEN out.WriteSString(", bindable") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FDISPLAYBIND) THEN out.WriteSString(", display") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FDEFAULTBIND) THEN out.WriteSString(", default") END; IF ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END; IF var.varkind = WinOleAut.VAR_PERINSTANCE THEN out.WriteSString(", offset: "); out.WriteInt(var.u.oInst) END END; out.WriteSString(" *)") END; out.WriteLn END ShowVar; PROCEDURE ShowParam (VAR param: WinOleAut.ELEMDESC; name: WinOle.BSTR; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR type: WinOleAut.TYPEDESC; flags, kind: SHORTINT; ti: WinOleAut.ITypeInfo; s: WinOle.BSTR; res: COM.RESULT; BEGIN GetParamType(param, tinfo, opts, type, kind); IF kind = var THEN out.WriteSString("VAR ") ELSIF kind = varin THEN out.WriteSString("IN ") ELSIF kind = varout THEN out.WriteSString("OUT ") END; flags := param.u.paramdesc.wParamFlags; IF ODD(flags DIV WinOleAut.PARAMFLAG_FLCID) THEN out.WriteSString("(* lcid *) ") END; IF ODD(flags DIV WinOleAut.PARAMFLAG_FRETVAL) THEN out.WriteSString("(* retval *) ") END; (* (* correct parameter name *) IF (type.vt = WinOle.VT_PTR) & (type.u.lptdesc.vt = WinOle.VT_USERDEFINED) THEN res := tinfo.GetRefTypeInfo(type.u.lptdesc.u.hreftype, ti); IF res >= 0 THEN res := ti.GetDocumentation(-1, s, NIL, NIL, NIL); IF s # NIL THEN IF name^ = s^ THEN IF name[0] < "a" THEN name[0] := CHR(ORD(name[0]) + 32) ELSE name[0] := CHR(ORD(name[0]) - 32) END END; WinOleAut.SysFreeString(s) END END END; *) WriteBSTR(name, out); out.WriteSString(": "); IF (wrapper IN opts) & (type.vt = WinOle.VT_BSTR) & (kind = value) THEN out.WriteSString("ARRAY OF CHAR") ELSE WriteType(type, tinfo, opts, out) END; (* IF ODD(param.u.paramdesc.wParamFlags DIV WinOleAut.PARAMFLAG_FHASDEFAULT) THEN out.WriteSString(" (* := "); WriteVariant(param.u.paramdesc.pparamdescex.varDefaultValue, out); out.WriteSString(" *)") END; *) END ShowParam; PROCEDURE ShowWrapper (VAR [nil] param: ARRAY [untagged] OF WinOleAut.ELEMDESC; VAR retTyp: WinOleAut.TYPEDESC; VAR names: ARRAY OF WinOle.BSTR; par, id, invoke: INTEGER; hasRet: BOOLEAN; opts: SET; tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter); VAR i: INTEGER; type: WinOleAut.TYPEDESC; kind: SHORTINT; hasVar: BOOLEAN; BEGIN IF (invoke = WinOleAut.INVOKE_PROPERTYPUT) & ~hasRet & (par = 1) THEN out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("CtlC.Put"); WriteShortType(param[0].tdesc, tinfo, out); out.WriteSString("(this, "); out.WriteInt(id); out.WriteSString(", "); WriteBSTR(names[1], out); out.WriteChar(")"); out.WriteLn ELSIF (invoke = WinOleAut.INVOKE_PROPERTYGET) & hasRet & (par = 0) THEN out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("RETURN "); WriteTypeConv(retTyp, tinfo, get, id, out); out.WriteLn ELSE hasVar := FALSE; IF par > 0 THEN IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END; out.WriteString(" argv: ARRAY "); out.WriteInt(par); out.WriteString(" OF CtlT.Variant;") END; IF hasRet THEN IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END; out.WriteString(" ret: CtlT.Variant;") END; i := 0; WHILE i < par DO GetParamType(param[i], tinfo, opts, type, kind); IF (kind # value) & IsSpecial(type, tinfo) THEN IF ~hasVar THEN out.WriteTab; out.WriteTab; out.WriteSString("VAR"); hasVar := TRUE END; out.WriteChar(" "); WriteBSTR(names[i + 1], out); out.WriteString("_TEMP: CtlT.Variant;") END; INC(i) END; IF hasVar THEN out.WriteLn END; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; i := 0; WHILE i < par DO GetParamType(param[i], tinfo, opts, type, kind); IF (kind IN {var, varin}) & IsSpecial(type, tinfo) THEN out.WriteTab; out.WriteTab; out.WriteSString("CtlC."); WriteShortType(type, tinfo, out); out.WriteString("Var("); WriteBSTR(names[i + 1], out); out.WriteString(", "); WriteBSTR(names[i + 1], out); out.WriteString("_TEMP);"); out.WriteLn END; out.WriteTab; out.WriteTab; out.WriteSString("CtlC."); IF kind # value THEN out.WriteSString("Ref") END; WriteShortType(type, tinfo, out); out.WriteSString("Var("); WriteBSTR(names[i + 1], out); IF (kind # value) & IsSpecial(type, tinfo) THEN out.WriteString("_TEMP") END; out.WriteSString(", argv["); out.WriteInt(par - i - 1); out.WriteSString("]);"); out.WriteLn; INC(i) END; out.WriteTab; out.WriteTab; IF par = 0 THEN out.WriteSString("CtlC.CallMethod(this, ") ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYGET) THEN out.WriteSString("CtlC.CallGetMethod(this, ") ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYPUT) THEN out.WriteSString("CtlC.CallPutMethod(this, ") ELSIF ODD(invoke DIV WinOleAut.INVOKE_PROPERTYPUTREF) THEN out.WriteSString("CtlC.CallPutRefMethod(this, ") ELSE out.WriteSString("CtlC.CallParMethod(this, ") END; out.WriteInt(id); IF par > 0 THEN out.WriteSString(", argv") END; IF hasRet THEN out.WriteSString(", ret") ELSE out.WriteSString(", NIL") END; out.WriteSString(");"); out.WriteLn; i := 0; WHILE i < par DO GetParamType(param[i], tinfo, opts, type, kind); IF (kind IN {var, varout}) & IsSpecial(type, tinfo) THEN out.WriteTab; out.WriteTab; WriteBSTR(names[i + 1], out); out.WriteSString(" := "); retName := names[i + 1]$ + "_TEMP"; WriteTypeConv(type, tinfo, ret, 0, out); out.WriteChar(";"); out.WriteLn END; INC(i) END; IF hasRet THEN out.WriteTab; out.WriteTab; out.WriteSString("RETURN "); retName := "ret"; WriteTypeConv(retTyp, tinfo, ret, 0, out); out.WriteLn END END END ShowWrapper; PROCEDURE ShowGenerator (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; name: WinOle.BSTR; BEGIN res := tinfo.GetTypeAttr(attr); res := tinfo.GetDocumentation(-1, name, NIL, NIL, NIL); (* !!! *) out.WriteTab; out.WriteSString("PROCEDURE This"); WriteBSTR(name, out); out.WriteSString("* (v: CtlT.Any): "); WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("VAR new: "); WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("IF v # NIL THEN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString('NEW(new); CtlC.InitObj(new, v, "'); WriteGuid(attr.guid, out); out.WriteSString('"); RETURN new'); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("ELSE RETURN NIL"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn; out.WriteTab; out.WriteSString("END This"); WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteLn; out.WriteTab; out.WriteSString("PROCEDURE Is"); WriteBSTR(name, out); out.WriteSString("* (v: CtlT.Any): BOOLEAN;"); out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString('RETURN CtlC.IsObj(v, "'); WriteGuid(attr.guid, out); out.WriteSString('")'); out.WriteLn; out.WriteTab; out.WriteSString("END Is"); WriteBSTR(name, out); out.WriteChar(";"); out.WriteLn; out.WriteLn; WinOleAut.SysFreeString(name) END ShowGenerator; PROCEDURE ShowClassGenerator (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr, iattr: WinOleAut.PtrTYPEATTR; sc, si: WinOle.BSTR; i: INTEGER; t: WinOleAut.HREFTYPE; iinfo: WinOleAut.ITypeInfo; flags: SET; BEGIN IF (inAll IN opts) OR (inAuto IN opts) THEN res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); i := 0; WHILE i < attr.cImplTypes DO res := tinfo.GetImplTypeFlags(i, flags); IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags = {} THEN res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 101); res := tinfo.GetRefTypeInfo(t, iinfo); ASSERT(res >= 0, 102); res := iinfo.GetTypeAttr(iattr); ASSERT(res >= 0, 103); IF iattr.typekind = WinOleAut.TKIND_DISPATCH THEN res := tinfo.GetDocumentation(-1, sc, NIL, NIL, NIL); ASSERT(res >= 0, 104); res := iinfo.GetDocumentation(-1, si, NIL, NIL, NIL); ASSERT(res >= 0, 105); (* !!! *) IF si # NIL THEN out.WriteTab; out.WriteSString("PROCEDURE New"); WriteBSTR(sc, out); IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags = {} THEN out.WriteChar("_"); WriteBSTR(si, out) END; out.WriteSString("* (): "); WriteBSTR(si, out); out.WriteChar(";"); out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("RETURN This"); WriteBSTR(si, out); out.WriteSString('(CtlC.NewObj("'); WriteGuid(attr.guid, out); out.WriteSString('"))'); out.WriteLn; out.WriteTab; out.WriteSString("END New"); WriteBSTR(sc, out); IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags = {} THEN out.WriteChar("_"); WriteBSTR(si, out) END; out.WriteChar(";"); out.WriteLn; out.WriteLn; WinOleAut.SysFreeString(sc); WinOleAut.SysFreeString(si) END END; iinfo.ReleaseTypeAttr(iattr) END; INC(i) END; tinfo.ReleaseTypeAttr(attr) END END ShowClassGenerator; PROCEDURE ShowProperty (VAR var: WinOleAut.PtrVARDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR attr: WinOleAut.PtrTYPEATTR; tn: WinOle.BSTR; VAR out: TextMappers.Formatter); VAR n, i: INTEGER; s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT; names: ARRAY 2 OF WinOle.BSTR; elem: ARRAY 1 OF WinOleAut.ELEMDESC; BEGIN res := tinfo.GetNames(var.memid, names[0], 1, n); out.WriteTab; out.WriteSString("PROCEDURE "); out.WriteSString("(this: "); WriteBSTR(tn, out); out.WriteSString(") "); WriteBSTR(names[0], out); out.WriteSString("* (): "); WriteType(var.elemdescVar.tdesc, tinfo, opts, out); out.WriteString(", NEW"); IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN (* Something's wrong here, should choose ABSTRACT. *) IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END; out.WriteChar(";"); out.WriteLn; ShowWrapper(elem, var.elemdescVar.tdesc, names, 0, var.memid, WinOleAut.INVOKE_PROPERTYGET, TRUE, opts, tinfo, out); out.WriteTab; out.WriteSString("END "); WriteBSTR(names[0], out); ELSE out.WriteString(", ABSTRACT") END; out.WriteChar(";"); out.WriteLn; out.WriteLn; IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteTab; out.WriteSString("PROCEDURE "); out.WriteSString("(this: "); WriteBSTR(tn, out); out.WriteSString(") PUT"); WriteBSTR(names[0], out); out.WriteSString("* (val: "); IF var.elemdescVar.tdesc.vt = WinOle.VT_BSTR THEN out.WriteSString("ARRAY OF CHAR") ELSE WriteType(var.elemdescVar.tdesc, tinfo, opts, out) END; out.WriteString("), NEW"); IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END; out.WriteChar(";"); out.WriteLn; elem[0] := var.elemdescVar; names[1] := WinOleAut.SysAllocString("val"); ShowWrapper(elem, var.elemdescVar.tdesc, names, 1, var.memid, WinOleAut.INVOKE_PROPERTYPUT, FALSE, opts, tinfo, out); WinOleAut.SysFreeString(names[1]); out.WriteTab; out.WriteSString("END PUT"); WriteBSTR(names[0], out); ELSE out.WriteString(", ABSTRACT") END; out.WriteChar(";"); out.WriteLn; out.WriteLn; END; WinOleAut.SysFreeString(names[0]); END ShowProperty; PROCEDURE ShowFunc (VAR func: WinOleAut.PtrFUNCDESC; tinfo: WinOleAut.ITypeInfo; VAR attr: WinOleAut.PtrTYPEATTR; tn: WinOle.BSTR; opts: SET; VAR out: TextMappers.Formatter); VAR n, i: INTEGER; names: ARRAY 64 OF WinOle.BSTR; s, t: WinOle.BSTR; res: COM.RESULT; e: SHORTINT; retTyp: WinOleAut.TYPEDESC; ti: WinOleAut.ITypeInfo; BEGIN res := tinfo.GetNames(func.memid, names[0], LEN(names), n); IF (wrapper IN opts) & ((func.memid = WinOleAut.DISPID_NEWENUM) OR (names[0]^ = "_NewEnum") & (func.cParams = 0) & ((func.elemdescFunc.tdesc.vt = WinOle.VT_UNKNOWN) OR (func.elemdescFunc.tdesc.vt = WinOle.VT_VARIANT))) THEN (* IF names[0]^ = "_NewEnum" THEN names[0]^ := "NewEnum" END; *) retTyp.vt := enumerator ELSE retTyp := func.elemdescFunc.tdesc END; IF ~(wrapper IN opts) OR ~ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED) OR (retTyp.vt = enumerator) THEN (* IF ~(wrapper IN opts) OR (names[0]^ # "QueryInterface") & (names[0]^ # "AddRef") & (names[0]^ # "Release") & (names[0]^ # "GetTypeInfoCount") & (names[0]^ # "GetTypeInfo") & (names[0]^ # "GetIDsOfNames") & (names[0]^ # "Invoke") THEN *) out.WriteTab; out.WriteSString("PROCEDURE "); IF ~(wrapper IN opts) & (func.callconv # WinOleAut.CC_STDCALL) THEN out.WriteChar("["); IF func.callconv = WinOleAut.CC_CDECL THEN out.WriteSString("ccall") ELSIF func.callconv = WinOleAut.CC_PASCAL THEN out.WriteSString("pascal") ELSIF func.callconv = WinOleAut.CC_MACPASCAL THEN out.WriteSString("macpascal") ELSIF func.callconv = WinOleAut.CC_SYSCALL THEN out.WriteSString("syscall") ELSIF func.callconv = WinOleAut.CC_MPWCDECL THEN out.WriteSString("mpwccall") ELSIF func.callconv = WinOleAut.CC_MPWPASCAL THEN out.WriteSString("mpwpascal") ELSE HALT(100) END; out.WriteSString("] ") END; IF (func.funckind = WinOleAut.FUNC_VIRTUAL) OR (func.funckind = WinOleAut.FUNC_PUREVIRTUAL) OR (func.funckind = WinOleAut.FUNC_DISPATCH) THEN out.WriteSString("(this: "); WriteBSTR(tn, out); out.WriteSString(") ") END; IF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString("PUT") ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString("PUTREF") END; WriteBSTR(names[0], out); out.WriteChar("*"); IF func.funckind = WinOleAut.FUNC_STATIC THEN res := tinfo.GetDllEntry(func.memid, func.invkind, s, t, e); IF res >= 0 THEN out.WriteSString(" ["); IF s # NIL THEN out.WriteChar('"'); WriteBSTR(s, out); out.WriteSString('", '); WinOleAut.SysFreeString(s) END; IF t # NIL THEN out.WriteChar('"'); WriteBSTR(t, out); out.WriteChar('"'); WinOleAut.SysFreeString(t) ELSE out.WriteChar('"'); out.WriteInt(e); out.WriteChar('"') END; out.WriteChar("]") END END; out.WriteSString(" ("); WHILE n <= func.cParams DO IF n <= 9 THEN names[n] := WinOleAut.SysAllocString("p0"); names[n][1] := SHORT(CHR(n + ORD("0"))) ELSE names[n] := WinOleAut.SysAllocString("p00"); names[n][1] := SHORT(CHR(n DIV 10 + ORD("0"))); names[n][2] := SHORT(CHR(n MOD 10 + ORD("0"))) END; INC(n) END; (* (* correct parameter name - return type conflict *) IF (n > 1) & (retTyp.vt = WinOle.VT_PTR) & (retTyp.u.lptdesc.vt = WinOle.VT_USERDEFINED) THEN res := tinfo.GetRefTypeInfo(retTyp.u.lptdesc.u.hreftype, ti); IF res >= 0 THEN res := ti.GetDocumentation(-1, s, NIL, NIL, NIL); IF s # NIL THEN IF names[1]^ = s^ THEN IF names[1, 0] < "a" THEN names[1, 0] := CHR(ORD(names[1, 0]) + 32) ELSE names[1, 0] := CHR(ORD(names[1, 0]) - 32) END END; WinOleAut.SysFreeString(s) END END END; *) i := 0; WHILE i < func.cParams DO IF i > 0 THEN out.WriteSString("; ") END; names[i+1, 0] := Strings.Lower(names[i+1, 0]); (* lowercase first char avoids many name conflicts with type names, which typically start with uppercase *) IF i = func.cParams - ABS(func.cParamsOpt) THEN out.WriteSString("(* optional *) ") END; ShowParam(func.lprgelemdescParam[i], names[i + 1], tinfo, opts, out); INC(i) END; out.WriteChar(")"); IF retTyp.vt # WinOle.VT_VOID THEN out.WriteSString(": "); WriteType(retTyp, tinfo, opts, out) END; IF (names[0]^ # "Date") & (names[0]^ # "Cy") & (names[0]^ # "Int") THEN out.WriteString(", NEW") END; IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString(", EXTENSIBLE") END ELSE out.WriteString(", ABSTRACT") END; out.WriteChar(";"); out.WriteLn; res := tinfo.GetDocumentation(func.memid, NIL, s, NIL, NIL); IF (s # NIL) OR (browse IN opts) THEN out.WriteTab; out.WriteTab; out.WriteSString("(* "); IF s # NIL THEN WriteBSTR(s, out); IF browse IN opts THEN out.WriteSString(", ") END; WinOleAut.SysFreeString(s) END; IF browse IN opts THEN out.WriteSString("id: "); out.WriteIntForm(func.memid, TextMappers.hexadecimal, 8, "0", FALSE); IF func.memid = attr.memidConstructor THEN out.WriteSString(", contructor") END; IF func.memid = attr.memidDestructor THEN out.WriteSString(", destructor") END; IF func.funckind = WinOleAut.FUNC_DISPATCH THEN out.WriteSString(", dispatch") END; IF func.invkind = WinOleAut.INVOKE_PROPERTYGET THEN out.WriteSString(", get") ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString(", put") ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString(", putref") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED) THEN out.WriteSString(", restricted") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FSOURCE) THEN out.WriteSString(", source") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FBINDABLE) THEN out.WriteSString(", bindable") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FREQUESTEDIT) THEN out.WriteSString(", request") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FDISPLAYBIND) THEN out.WriteSString(", display") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FDEFAULTBIND) THEN out.WriteSString(", default") END; IF ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END; IF (func.funckind = WinOleAut.FUNC_PUREVIRTUAL) OR (func.funckind = WinOleAut.FUNC_VIRTUAL) THEN out.WriteSString(", offset: "); out.WriteInt(func.oVft) END END; out.WriteSString(" *)"); out.WriteLn END; res := tinfo.GetMops(func.memid, s); IF s # NIL THEN out.WriteTab; out.WriteTab; out.WriteSString("(* mops: "); WriteBSTR(s, out); out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s) END; IF func.cScodes > 0 THEN out.WriteTab; out.WriteTab; out.WriteSString("(* scodes:"); i := 0; WHILE i < func.cScodes DO out.WriteChar(" "); out.WriteIntForm(func.lprgscode[i], TextMappers.hexadecimal, 9, "0", TRUE); INC(i) END; out.WriteSString(" *)"); out.WriteLn END; IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN IF wrapper IN opts THEN ShowWrapper(func.lprgelemdescParam^, retTyp, names, func.cParams, func.memid, func.invkind, retTyp.vt # WinOle.VT_VOID, opts, tinfo, out) END; out.WriteTab; out.WriteSString("END "); IF func.invkind = WinOleAut.INVOKE_PROPERTYPUT THEN out.WriteSString("PUT") ELSIF func.invkind = WinOleAut.INVOKE_PROPERTYPUTREF THEN out.WriteSString("PUTREF") END; WriteBSTR(names[0], out); out.WriteChar(";"); out.WriteLn END; out.WriteLn END; i := 0; WHILE i < n DO WinOleAut.SysFreeString(names[i]); INC(i) END END ShowFunc; PROCEDURE ShowConst (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC; i: INTEGER; s, t: WinOle.BSTR; used: BOOLEAN; BEGIN res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); i := 0; used := FALSE; WHILE i < attr.cVars DO res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101); IF var.varkind = WinOleAut.VAR_CONST THEN IF ~used THEN out.WriteTab; out.WriteTab; out.WriteSString("(* "); res := tinfo.GetDocumentation(-1, s, t, NIL, NIL); IF s # NIL THEN WriteBSTR(s, out); WinOleAut.SysFreeString(s) END; IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out); WinOleAut.SysFreeString(t) END; WriteTypeFlags(attr.wTypeFlags, out); out.WriteSString(" *)"); out.WriteLn; used := TRUE END; ShowVar(var, tinfo, opts, out) END; tinfo.ReleaseVarDesc(var); INC(i) END; tinfo.ReleaseTypeAttr(attr) END ShowConst; PROCEDURE ShowStatic (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC; i: INTEGER; s, t: WinOle.BSTR; used: BOOLEAN; BEGIN res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); i := 0; used := FALSE; WHILE i < attr.cVars DO res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101); IF var.varkind # WinOleAut.VAR_CONST THEN IF ~used THEN out.WriteTab; out.WriteTab; out.WriteSString("(* "); res := tinfo.GetDocumentation(-1, s, t, NIL, NIL); IF s # NIL THEN WriteBSTR(s, out); WinOleAut.SysFreeString(s) END; IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out); WinOleAut.SysFreeString(t) END; WriteTypeFlags(attr.wTypeFlags, out); out.WriteSString(" *)"); out.WriteLn; used := TRUE END; ShowVar(var, tinfo, opts, out) END; tinfo.ReleaseVarDesc(var); INC(i) END; tinfo.ReleaseTypeAttr(attr) END ShowStatic; PROCEDURE ShowType (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; var: WinOleAut.PtrVARDESC; flags: SET; i, vt: INTEGER; func: WinOleAut.PtrFUNCDESC; s, s1: WinOle.BSTR; iinfo: WinOleAut.ITypeInfo; t: WinOleAut.HREFTYPE; BEGIN res := tinfo.GetDocumentation(-1, s, s1, NIL, NIL); (* !!! *) IF s1 # NIL THEN out.WriteTab; out.WriteTab; out.WriteSString("(* "); WriteBSTR(s1, out); out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s1) END; res := tinfo.GetMops(-1, s1); IF s1 # NIL THEN out.WriteTab; out.WriteTab; out.WriteSString("(* Mops: "); WriteBSTR(s1, out); out.WriteSString(" *)"); out.WriteLn; WinOleAut.SysFreeString(s1) END; res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); IF attr.typekind = WinOleAut.TKIND_COCLASS THEN (* !!! *) IF wrapper IN opts THEN GetInfoType(tinfo, vt, iinfo); IF vt = WinOle.VT_DISPATCH THEN res := iinfo.GetDocumentation(-1, s1, NIL, NIL, NIL); ASSERT(res >= 0, 104); IF s1 # NIL THEN out.WriteTab; out.WriteTab; WriteBSTR(s, out); out.WriteSString("* = "); WriteBSTR(s1, out); out.WriteChar(";"); out.WriteLn; WinOleAut.SysFreeString(s1) END END END ELSE out.WriteTab; out.WriteTab; WriteBSTR(s, out); out.WriteSString("* = "); IF attr.typekind = WinOleAut.TKIND_ALIAS THEN WriteType(attr.tdescAlias, tinfo, opts, out) ELSIF attr.typekind = WinOleAut.TKIND_ENUM THEN out.WriteString("INTEGER"); ELSE out.WriteSString("POINTER TO "); IF wrapper IN opts THEN IF (inAll IN opts) OR (inAuto IN opts) & ~(source IN opts) THEN IF (outAll IN opts) OR (outAuto IN opts) & (source IN opts) THEN out.WriteString("EXTENSIBLE ") END ELSE out.WriteString("ABSTRACT ") END; out.WriteSString("RECORD ") ELSE out.WriteSString("RECORD "); IF (attr.typekind = WinOleAut.TKIND_INTERFACE) OR (attr.typekind = WinOleAut.TKIND_DISPATCH) THEN out.WriteSString('["'); WriteGuid(attr.guid, out); out.WriteSString('"] ') ELSIF attr.typekind = WinOleAut.TKIND_UNION THEN out.WriteSString("[union] ") ELSIF attr.cbAlignment = 1 THEN out.WriteSString("[noalign] ") ELSIF attr.cbAlignment = 2 THEN out.WriteSString("[align2] ") ELSIF attr.cbAlignment = 8 THEN out.WriteSString("[align8] ") ELSE out.WriteSString("[untagged] ") END END; IF attr.cImplTypes > 0 THEN ASSERT(attr.cImplTypes = 1, 101); res := tinfo.GetRefTypeOfImplType(0, t); ASSERT(res >= 0, 102); out.WriteChar("("); IF (wrapper IN opts) & ((outAll IN opts) OR (outAuto IN opts) & (source IN opts)) THEN out.WriteString("CtlT.OutObject") ELSE WriteHandleName(t, tinfo, opts, out) END; out.WriteSString(") ") END; IF ~(wrapper IN opts) THEN IF attr.typekind = WinOleAut.TKIND_DISPATCH THEN out.WriteSString("(* dispatch") ELSE out.WriteSString("(* size: "); out.WriteInt(attr.cbSizeInstance); out.WriteSString(", vtbl size: "); out.WriteInt(attr.cbSizeVft) END; WriteTypeFlags(attr.wTypeFlags, out); out.WriteSString(" *)"); out.WriteLn; i := 0; WHILE i < attr.cVars DO res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 103); IF var.varkind # WinOleAut.VAR_CONST THEN ShowVar(var, tinfo, opts, out) END; tinfo.ReleaseVarDesc(var); INC(i) END; out.WriteTab; out.WriteTab END; out.WriteSString("END") END; out.WriteChar(";"); out.WriteLn END; WinOleAut.SysFreeString(s); tinfo.ReleaseTypeAttr(attr) END ShowType; PROCEDURE ShowInvokeCall (func: WinOleAut.PtrFUNCDESC; tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR p, n: INTEGER; res: COM.RESULT; name: WinOle.BSTR; type: WinOleAut.TYPEDESC; kind: SHORTINT; BEGIN res := tinfo.GetNames(func.memid, name, 1, n); IF func.elemdescFunc.tdesc.vt # WinOle.VT_VOID THEN (* function *) out.WriteSString("CtlC."); IF (wrapper IN opts) & ((func.memid = WinOleAut.DISPID_NEWENUM) OR (name^ = "_NewEnum") & (func.cParams = 0) & ((func.elemdescFunc.tdesc.vt = WinOle.VT_UNKNOWN) OR (func.elemdescFunc.tdesc.vt = WinOle.VT_VARIANT))) THEN out.WriteString("Enum") ELSE WriteShortType(func.elemdescFunc.tdesc, tinfo, out) END; out.WriteSString("Var(") END; out.WriteSString("this."); IF ODD(func.invkind DIV WinOleAut.INVOKE_PROPERTYPUT) THEN out.WriteSString("PUT") ELSIF ODD(func.invkind DIV WinOleAut.INVOKE_PROPERTYPUTREF) THEN out.WriteSString("PUTREF") END; WriteBSTR(name, out); out.WriteChar("("); WinOleAut.SysFreeString(name); p := 0; WHILE p < func.cParams DO IF p > 0 THEN out.WriteSString(", ") END; GetParamType(func.lprgelemdescParam[p], tinfo, opts, type, kind); IF kind = value THEN WriteTypeConv(type, tinfo, par, func.cParams - 1 - p, out) ELSE WriteTypeConv(type, tinfo, refpar, func.cParams - 1 - p, out) END; INC(p) END; out.WriteChar(")"); IF func.elemdescFunc.tdesc.vt # WinOle.VT_VOID THEN out.WriteSString(", ret)") END; p := 0; WHILE p < func.cParams DO GetParamType(func.lprgelemdescParam[p], tinfo, opts, type, kind); IF (kind # value) & IsSpecial(type, tinfo) THEN out.WriteSString("; CtlC.Ret"); WriteShortType(type, tinfo, out); out.WriteString("(par["); out.WriteInt(func.cParams - 1 - p); out.WriteString("])") END; INC(p) END; END ShowInvokeCall; PROCEDURE ShowInvoke (tinfo: WinOleAut.ITypeInfo; attr: WinOleAut.PtrTYPEATTR; tn: WinOle.BSTR; opts: SET; VAR out: TextMappers.Formatter); VAR func, pfunc: WinOleAut.PtrFUNCDESC; res: COM.RESULT; i, j, n: INTEGER; name: WinOle.BSTR; var: WinOleAut.PtrVARDESC; ifUsed: BOOLEAN; BEGIN out.WriteTab; out.WriteSString("PROCEDURE (this: "); WriteBSTR(tn, out); out.WriteSString(") Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant);"); out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString("CASE id OF"); out.WriteLn; i := 0; WHILE i < attr.cVars DO (* property access *) res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101); IF var.varkind # WinOleAut.VAR_CONST THEN res := tinfo.GetNames(var.memid, name, 1, n); out.WriteTab; out.WriteTab; out.WriteSString("| "); out.WriteInt(var.memid); out.WriteSString(": "); IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteSString("IF n = -1 THEN this.PUT"); WriteBSTR(name, out); out.WriteChar("("); WriteTypeConv(var.elemdescVar.tdesc, tinfo, par, 0, out); out.WriteChar(")"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELSE ") END; out.WriteSString("ASSERT(n = 0, 11); "); out.WriteSString("CtlC."); WriteShortType(var.elemdescVar.tdesc, tinfo, out); out.WriteSString("Var(this."); WriteBSTR(name, out); out.WriteSString("(), ret)"); out.WriteLn; IF ~ODD(var.wVarFlags DIV WinOleAut.VARFLAG_FREADONLY) THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn END; WinOleAut.SysFreeString(name) END; tinfo.ReleaseVarDesc(var); INC(i) END; i := 0; WHILE i < attr.cFuncs DO (* method access *) res := tinfo.GetFuncDesc(i, func); ASSERT(res >= 0, 102); IF ~ODD(func.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED) & (func.invkind < WinOleAut.INVOKE_PROPERTYPUT) THEN out.WriteTab; out.WriteTab; out.WriteSString("| "); out.WriteInt(func.memid); out.WriteSString(": "); ifUsed := FALSE; IF func.invkind = WinOleAut.INVOKE_PROPERTYGET THEN j := 0; WHILE j < attr.cFuncs DO res := tinfo.GetFuncDesc(j, pfunc); ASSERT(res >= 0, 103); IF (pfunc.memid = func.memid) & ~ODD(pfunc.wFuncFlags DIV WinOleAut.FUNCFLAG_FRESTRICTED) & (pfunc.invkind >= WinOleAut.INVOKE_PROPERTYPUT) THEN IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELS") END; out.WriteSString("IF n = -"); IF ODD(pfunc.invkind DIV WinOleAut.INVOKE_PROPERTYPUT) THEN out.WriteInt(pfunc.cParams) ELSE out.WriteInt(pfunc.cParams + 100) END; out.WriteSString(" THEN "); ShowInvokeCall(pfunc, tinfo, opts, out); out.WriteLn; ifUsed := TRUE END; tinfo.ReleaseFuncDesc(pfunc); INC(j) END END; IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("ELSE ") END; out.WriteSString("ASSERT(n = "); out.WriteInt(func.cParams); out.WriteSString(", 11); "); ShowInvokeCall(func, tinfo, opts, out); out.WriteLn; IF ifUsed THEN out.WriteTab; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn END END; tinfo.ReleaseFuncDesc(func); INC(i) END; out.WriteTab; out.WriteTab; out.WriteSString("END"); out.WriteLn; out.WriteTab; out.WriteSString("END Invoke;"); out.WriteLn; out.WriteLn; (* GetIID *) out.WriteTab; out.WriteSString("PROCEDURE (this: "); WriteBSTR(tn, out); out.WriteSString(") GetIID* (OUT iid: CtlT.GUID);"); out.WriteLn; out.WriteTab; out.WriteSString("BEGIN"); out.WriteLn; out.WriteTab; out.WriteTab; out.WriteSString('iid := "'); WriteGuid(attr.guid, out); out.WriteChar('"'); out.WriteLn; out.WriteTab; out.WriteSString("END GetIID;"); out.WriteLn; out.WriteLn END ShowInvoke; PROCEDURE ShowProcs (tinfo: WinOleAut.ITypeInfo; opts: SET; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; s, t: WinOle.BSTR; i: INTEGER; func: WinOleAut.PtrFUNCDESC; var: WinOleAut.PtrVARDESC; BEGIN res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); IF (wrapper IN opts) OR (attr.cFuncs > 0) THEN res := tinfo.GetDocumentation(-1, s, t, NIL, NIL); (* !!! *) out.WriteLn; out.WriteTab; out.WriteSString("(* ---------- "); IF s # NIL THEN WriteBSTR(s, out) END; IF t # NIL THEN out.WriteSString(": "); WriteBSTR(t, out) END; WriteTypeFlags(attr.wTypeFlags, out); out.WriteSString(" ---------- *)"); out.WriteLn; out.WriteLn; IF wrapper IN opts THEN i := 0; WHILE i < attr.cVars DO res := tinfo.GetVarDesc(i, var); ASSERT(res >= 0, 101); IF var.varkind # WinOleAut.VAR_CONST THEN ShowProperty(var, tinfo, opts, attr, s, out) END; tinfo.ReleaseVarDesc(var); INC(i) END END; i := 0; WHILE i < attr.cFuncs DO res := tinfo.GetFuncDesc(i, func); ASSERT(res >= 0, 102); ShowFunc(func, tinfo, attr, s, opts, out); tinfo.ReleaseFuncDesc(func); INC(i) END; IF (wrapper IN opts) & ((outAll IN opts) OR (outAuto IN opts) & (source IN opts)) THEN ShowInvoke(tinfo, attr, s, opts, out) END; WinOleAut.SysFreeString(s); WinOleAut.SysFreeString(t) END; tinfo.ReleaseTypeAttr(attr) END ShowProcs; PROCEDURE ShowClass (tinfo: WinOleAut.ITypeInfo; VAR out: TextMappers.Formatter); VAR res: COM.RESULT; attr: WinOleAut.PtrTYPEATTR; flags: SET; i: INTEGER; s, s1: WinOle.BSTR; t: WinOleAut.HREFTYPE; BEGIN out.WriteTab; out.WriteSString("(* CLASS "); res := tinfo.GetDocumentation(-1, s, s1, NIL, NIL); IF s # NIL THEN WriteBSTR(s, out) END; IF s1 # NIL THEN out.WriteSString(": "); WriteBSTR(s1, out); WinOleAut.SysFreeString(s1) END; res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); out.WriteLn; out.WriteTab; out.WriteTab; WriteGuid(attr.guid, out); WriteTypeFlags(attr.wTypeFlags, out); out.WriteLn; i := 0; WHILE i < attr.cImplTypes DO res := tinfo.GetImplTypeFlags(i, flags); res := tinfo.GetRefTypeOfImplType(i, t); ASSERT(res >= 0, 103); out.WriteTab; out.WriteTab; out.WriteSString("INTERFACE "); WriteHandleName(t, tinfo, {}, out); out.WriteTab; out.WriteSString("(* "); IF WinOleAut.IMPLTYPEFLAG_FDEFAULT * flags # {} THEN out.WriteSString("default ") END; IF WinOleAut.IMPLTYPEFLAG_FDEFAULTVTABLE * flags # {} THEN out.WriteSString("defaultVtable ") END; IF WinOleAut.IMPLTYPEFLAG_FRESTRICTED * flags # {} THEN out.WriteSString("restricted ") END; IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags # {} THEN out.WriteSString("source ") END; out.WriteSString("*)"); out.WriteLn; INC(i) END; out.WriteTab; out.WriteSString("END *)"); out.WriteLn; out.WriteLn; WinOleAut.SysFreeString(s); tinfo.ReleaseTypeAttr(attr) END ShowClass; PROCEDURE IsSource (tlib: WinOleAut.ITypeLib; tinfo: WinOleAut.ITypeInfo): BOOLEAN; VAR attr, ca, ta: WinOleAut.PtrTYPEATTR; ci, ti: WinOleAut.ITypeInfo; i, j, n: INTEGER; res: COM.RESULT; kind: WinOleAut.TYPEKIND; t: WinOleAut.HREFTYPE; flags: SET; BEGIN res := tinfo.GetTypeAttr(attr); ASSERT(res >= 0, 100); i := 0; n := tlib.GetTypeInfoCount(); WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 101); IF kind = WinOleAut.TKIND_COCLASS THEN res := tlib.GetTypeInfo(i, ci); ASSERT(res >= 0, 102); res := ci.GetTypeAttr(ca); ASSERT(res >= 0, 103); j := 0; WHILE j < ca.cImplTypes DO res := ci.GetImplTypeFlags(j, flags); ASSERT(res >= 0, 104); IF WinOleAut.IMPLTYPEFLAG_FSOURCE * flags # {} THEN res := ci.GetRefTypeOfImplType(j, t); ASSERT(res >= 0, 105); res := ci.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 106); res := ti.GetTypeAttr(ta); ASSERT(res >= 0, 107); IF ta.guid = attr.guid THEN i := n; j := ca.cImplTypes END; ti.ReleaseTypeAttr(ta) END; INC(j) END; ci.ReleaseTypeAttr(ca) END; INC(i) END; tinfo.ReleaseTypeAttr(attr); RETURN i > n END IsSource; PROCEDURE ShowLibrary ( tlib: WinOleAut.ITypeLib; name: ARRAY OF CHAR; opts: SET; VAR out: TextMappers.Formatter ); VAR s1, s2, s3: WinOle.BSTR; str: ARRAY 256 OF SHORTCHAR; i, n, impPos: INTEGER; res: COM.RESULT; attr: WinOleAut.PtrTLIBATTR; tinfo, ti: WinOleAut.ITypeInfo; kind: WinOleAut.TYPEKIND; t: WinOleAut.HREFTYPE; BEGIN emptyenum := FALSE; res := tlib.GetDocumentation(-1, s1, s2, n, s3); ASSERT(res >= 0, 100); modules[0] := s1$; WinOleAut.SysFreeString(s1); modules[1] := "CtlT"; modules[2] := "CtlC"; noMod := 3; IF wrapper IN opts THEN modules[0] := "Ctl" + modules[0] END; out.WriteSString("MODULE "); out.WriteString(name); IF interface IN opts THEN out.WriteSString(' [""]') END; out.WriteChar(";"); out.WriteLn; out.WriteTab; out.WriteSString("(* "); IF s2 # NIL THEN WriteBSTR(s2, out); WinOleAut.SysFreeString(s2) END; out.WriteSString(", help: "); IF s3 # NIL THEN WriteBSTR(s3, out); WinOleAut.SysFreeString(s3) END; out.WriteSString(", id: "); out.WriteInt(n); out.WriteSString(" *)"); out.WriteLn; res := tlib.GetLibAttr(attr); ASSERT(res >= 0, 102); out.WriteTab; out.WriteSString("(* guid: "); WriteGuid(attr.guid, out); out.WriteSString(", lcid: "); out.WriteInt(attr.lcid); out.WriteSString(", syskind: "); IF attr.syskind = WinOleAut.SYS_WIN16 THEN out.WriteSString("win16") ELSIF attr.syskind = WinOleAut.SYS_WIN32 THEN out.WriteSString("win32") ELSIF attr.syskind = WinOleAut.SYS_MAC THEN out.WriteSString("mac") ELSE out.WriteInt(attr.syskind) END; out.WriteSString(", version: "); out.WriteInt(attr.wMajorVerNum); out.WriteChar("."); out.WriteInt(attr.wMinorVerNum); IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FRESTRICTED) THEN out.WriteSString(", restricted") END; IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FCONTROL) THEN out.WriteSString(", control") END; IF ODD(attr.wLibFlags DIV WinOleAut.LIBFLAG_FHIDDEN) THEN out.WriteSString(", hidden") END; out.WriteSString(" *)"); out.WriteLn; out.WriteLn; impPos := out.Pos(); tlib.ReleaseTLibAttr(attr); n := tlib.GetTypeInfoCount(); out.WriteTab; out.WriteSString("CONST"); out.WriteLn; i := 0; WHILE i < n DO res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 103); ShowConst(tinfo, opts, out); INC(i) END; out.WriteLn; out.WriteLn; out.WriteTab; out.WriteSString("TYPE"); out.WriteLn; i := 0; WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 104); IF (kind = WinOleAut.TKIND_ALIAS) OR (kind = WinOleAut.TKIND_ENUM) OR ~(wrapper IN opts) & (kind IN {WinOleAut.TKIND_RECORD, WinOleAut.TKIND_INTERFACE, WinOleAut.TKIND_ALIAS, WinOleAut.TKIND_UNION}) OR ~(interface IN opts) & (kind IN {WinOleAut.TKIND_DISPATCH, WinOleAut.TKIND_COCLASS}) THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 105); IF (wrapper IN opts) & IsSource(tlib, tinfo) THEN ShowType(tinfo, opts + {source}, out) ELSE ShowType(tinfo, opts, out) END END; IF (~(wrapper IN opts)) & (kind = WinOleAut.TKIND_DISPATCH) THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 105); res := tinfo.GetRefTypeOfImplType(-1, t); IF res >= 0 THEN (* dual interfaced *) res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 106); ShowType(ti, opts, out) END END; INC(i) END; out.WriteLn; out.WriteLn; IF ~(wrapper IN opts) THEN out.WriteTab; out.WriteSString("VAR"); out.WriteLn; i := 0; WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 107); IF kind = WinOleAut.TKIND_MODULE THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 108); ShowStatic(tinfo, opts, out) END; INC(i) END; out.WriteLn; out.WriteLn ELSE i := 0; WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 109); IF (wrapper IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110); IF (inAll IN opts) OR (inAuto IN opts) & ~IsSource(tlib, tinfo) THEN ShowGenerator(tinfo, opts, out) END END; INC(i) END; out.WriteLn END; i := 0; WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 109); IF ~(wrapper IN opts) & (kind IN {WinOleAut.TKIND_MODULE, WinOleAut.TKIND_INTERFACE}) OR ~(interface IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110); IF (wrapper IN opts) & IsSource(tlib, tinfo) THEN ShowProcs(tinfo, opts + {source}, out) ELSE ShowProcs(tinfo, opts, out) END END; IF ~(wrapper IN opts) & (kind = WinOleAut.TKIND_DISPATCH) THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 110); res := tinfo.GetRefTypeOfImplType(-1, t); IF res >= 0 THEN (* dual interfaced *) res := tinfo.GetRefTypeInfo(t, ti); ASSERT(res >= 0, 111); ShowProcs(ti, opts, out) END END; INC(i) END; out.WriteLn; i := 0; WHILE i < n DO res := tlib.GetTypeInfoType(i, kind); ASSERT(res >= 0, 112); IF kind = WinOleAut.TKIND_COCLASS THEN res := tlib.GetTypeInfo(i, tinfo); ASSERT(res >= 0, 113); IF wrapper IN opts THEN ShowClassGenerator(tinfo, opts, out) ELSE ShowClass(tinfo, out) END END; INC(i) END; out.WriteSString("END "); out.WriteString(name); out.WriteChar("."); out.WriteLn; IF (wrapper IN opts) & (noMod > 1) THEN out.SetPos(impPos); out.WriteTab; out.WriteSString("IMPORT "); i := 1; WHILE i < noMod DO IF i > 1 THEN out.WriteSString(", ") END; out.WriteString(modules[i]); INC(i) END; out.WriteChar(";"); out.WriteLn; out.WriteLn END; END ShowLibrary; PROCEDURE AutomationInterface* ( fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR ): TextModels.Model; VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib; BEGIN t := TextModels.dir.New(); out.ConnectTo(t); res := WinOleAut.LoadTypeLib(fileName, tlib); IF res >= 0 THEN ShowLibrary(tlib, modName, {wrapper, inAuto, outAuto}, out) END; out.ConnectTo(NIL); RETURN t END AutomationInterface; PROCEDURE CustomInterface* ( fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR ): TextModels.Model; (* not yet tested *) VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib; BEGIN t := TextModels.dir.New(); out.ConnectTo(t); res := WinOleAut.LoadTypeLib(fileName, tlib); IF res >= 0 THEN ShowLibrary(tlib, modName, {interface}, out) END; out.ConnectTo(NIL); RETURN t END CustomInterface; PROCEDURE Browse* (fileName: ARRAY 256 OF CHAR; modName: ARRAY 64 OF CHAR): TextModels.Model; (* not yet tested *) VAR t: TextModels.Model; out: TextMappers.Formatter; res: COM.RESULT; tlib: WinOleAut.ITypeLib; BEGIN t := TextModels.dir.New(); out.ConnectTo(t); res := WinOleAut.LoadTypeLib(fileName, tlib); IF res >= 0 THEN ShowLibrary(tlib, modName, {browse}, out) END; out.ConnectTo(NIL); RETURN t END Browse; END ComTypeLibs. DevComInterfaceGen DevTypeLibs

Com/Mod/TypeLibs.odc

Com/Rsrc/InterfaceGen.odc

MENU "#Com:&COM" "#Com:&Show Error" "" "ComDebug.ShowError" "TextCmds.SelectionGuard" "#Com:&Show Interfaces" "" "ComDebug.ShowInterfaceRecords" "" SEPARATOR "#Com:&Interface Info" "" "DevBrowser.ShowInterface('+!')" "TextCmds.SelectionGuard" "#Com:&Type Libraries" "" "ComInterfaceGen.Open" "" SEPARATOR "#Com:&New GUID" "" "ComDebug.NewGuid" "" "#Com:&Insert OLE Object..." "" "OleClient.InsertObject" "StdCmds.PasteViewGuard" SEPARATOR "#Com:&Collect" "" "MdiMenus.Collect" "" SEPARATOR "#Com:&DTC Help" "" "StdCmds.OpenBrowser('Com/Docu/DTC-Help', '#Com:DTC Help')" "" "#Com:&DTC Examples" "" "StdCmds.OpenBrowser('Com/Docu/Sys-Map', '#Com:DTC Examples')" "" END

Com/Rsrc/Menus.odc

Com/Rsrc/PhoneBook.odc

STRINGS &COM COM &Show Error Show Error &Show Interfaces Show Interfaces &Interface Info Interface Info &Type Libraries Type Libraries &New GUID New GUID &Insert OLE Object... Insert OLE &Object... &Collect Collect &DTC Help DTC Help &DTC Examples DTC Examples DTC Help DTC Help DTC Examples DTC Examples Type Libraries Type Libraries

Com/Rsrc/Strings.odc

CommObxStreamsClient DEFINITION CommObxStreamsClient; PROCEDURE SendTextSelection; END CommObxStreamsClient. This module acts as a client for CommObxStreamsServer. The command sends the current text selection to the server, which opens it in a new TextView. The server is expected to run on the same machine and to be started first. It may, however, run in a BlackBox process separate from the one in which the client runs. Try (after starting the server and selecting some text): CommObxStreamsClient.SendTextSelection PROCEDURE SendTextSelection Sends a text selection to the server. opensource

Comm/Docu/ObxStreamsClient.odc

CommObxStreamsServer DEFINITION CommObxStreamsServer; PROCEDURE Start; PROCEDURE Stop; END CommObxStreamsServer. This module provides an example of how to program a server using CommStreams. A sample client is provided by the module CommObxStreamsClient. The server waits for a connect. Whenever a client requests a new connection a separate TextView is opened by the server and everything received through this connection is displayed in the TextView. Per machine only one server is permitted to run at a time. Try - to start / stop the server: CommObxStreamsServer.Start CommObxStreamsServer.Stop PROCEDURE Start Starts the server. PROCEDURE Stop Stops the server. opensource

Comm/Docu/ObxStreamsServer.odc

CommStreams DEFINITION CommStreams; CONST done = 0; noSuchProtocol = 1; invalidLocalAdr = 2; invalidRemoteAdr = 3; networkDown = 4; localAdrInUse = 5; remoteAdrInUse = 6; TYPE Adr = POINTER TO ARRAY OF CHAR; Listener = POINTER TO ABSTRACT RECORD (l: Listener) Accept (OUT s: Stream), NEW, ABSTRACT; (l: Listener) Close, NEW, ABSTRACT; (l: Listener) LocalAdr (): Adr, NEW, ABSTRACT END; Stream = POINTER TO ABSTRACT RECORD (s: Stream) Close, NEW, ABSTRACT; (s: Stream) IsConnected (): BOOLEAN, NEW, ABSTRACT; (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER), NEW, ABSTRACT; (s: Stream) RemoteAdr (): Adr, NEW, ABSTRACT; (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER), NEW, ABSTRACT END; PROCEDURE NewListener (protocol, localAdr: ARRAY OF CHAR; OUT l: Listener; OUT res: INTEGER); PROCEDURE NewStream (protocol, localAdr, remoteAdr: ARRAY OF CHAR; OUT s: Stream; OUT res: INTEGER); END CommStreams. Module CommStreams defines the interfaces of two types: Stream and Listener. The interface is designed with reliable connection-oriented protocols in mind. Implementations of the stream and listener interfaces provide the actual communication channels. A TCP/IP implementation which internally uses a "sockets" interface is a typical example. Only implementors, not clients, need to extend the Stream and Listener types. In the following text it is distinguished between clients and implementors of these interface types. The stream interface is non-blocking. The reason for this approach is the non-modal nature of the BlackBox Component Framework. Letting one component block the whole system (and thus the user) would be contrary to the framework's basic design goals. Implementing non-blocking communicating objects is easy, although unconvential. Fortunately, object-oriented programming lends itself to a straight-forward implementation of such objects. Specification for clients Streams are full-duplex synchronous communication channels. They are used through read and write procedures. These procedures never block. The read procedure reads as much data as possible and then returns immediately. The write procedure writes as much data (into an internal buffer) as possible and then returns immediately. The number of bytes read or written is returned as a result of the procedures. Note that depending on the used protocol, individual read or write operations can have considerable overhead. This means that transferring entire groups of data in one step whenever possible can lead to a considerable performance increase, compared to sending the same data in several steps. There exist two ways to obtain a new object of type Stream, which represents a newly created connection. If a connection is to be made to a partner awaiting requests ("server"), the procedure NewStream is used. As parameters the name of the protocol to be used (or more exactly, it's driver module's name), and address identifiers for the remote port and for a local port are passed. The format of these identifiers, which are passed as character strings, depend on the protocol that is used. If the possibility to listen for calls from another site ("client") is to be offered, a listener object is created first. Such a listener is used to test whether a connection request has been made by another site. Whenever this is the case, a new Stream object can be obtained from the listener. The listener itself can be used further until it is explicitly closed. Requirements for implementors Implementors of the interface have to implement all the procedures of the types Stream and Listener according to the specification described in the previous section. Furthermore, two procedures for object allocation must be exported, with the following signatures: PROCEDURE NewStream (localAdr, remoteAdr: ARRAY OF CHAR; OUT s: Stream; OUT res: INTEGER) PROCEDURE NewListener (localAdr: ARRAY OF CHAR; OUT l: Listener; OUT res: INTEGER) These procedures will be activated by CommStreams using the metaprogramming facility of BlackBox. For example, if the protocol is TCP/IP, its driver's module name is used as protocol name, e.g., "CommTCP". For creating a stream, "CommTCP.NewStream" is called with the above described arguments. For creating a listener, "CommTCP.NewListener" is called with its set of arguments. CONST done Predefined value for parameter res of NewStream and NewListener. Signals that the operation could be carried out. CONST noSuchProtocol Predefined value for parameter res of NewStream and NewListener. Signals that the module specified as protocol could not be found, could not be loaded, or does not implement the required interface. CONST networkDown Predefined value for parameter res of NewStream and NewListener. Signals that the network resource used by the specified protocol is not available and hence no connections can be made. CONST invalidLocalAdr Predefined value for parameter res of NewStream and NewListener. Signals that the value specified as localAdr could not be used; either because the string was syntactically invalid, or because the specified address does not exist. CONST localAdrInUse Predefined value for parameter res of NewStream and NewListener. Signals that the value specified as localAdr could not be used because the address is in use already. CONST invalidRemoteAdr Predefined value for parameter res of NewStream. Signals that the value specified as remoteAdr could not be used; either because the string was syntactically invalid, or because the specified address does not exist. CONST remoteAdrInUse Predefined value for parameter res of NewStream. Signals that the value specified as remoteAdr could not be used because the address is in use already. TYPE Adr Dynamic string type for names of local or remote addresses. TYPE Listener ABSTRACT Objects of type Listener offer services to the network. PROCEDURE (l: Listener) Accept (OUT s: Stream) NEW, ABSTRACT Creates a new Stream when a remote site requests a connection. Accept never blocks: either it returns a new stream, or NIL if no service was requested from the network. If the listener is closed, Accept always returns NIL. Post s = NIL no service was requested s # NIL service was requested over the network PROCEDURE (l: Listener) Close NEW, ABSTRACT Closes the listener, so that no services can't be requested over the network anymore. Close has no effect if the listener was closed already. PROCEDURE (l: Listener) LocalAdr (): Adr NEW, ABSTRACT Returns the name of the local port on which the listener listens. TYPE Stream ABSTRACT Objects of type Stream represent full-duplex connections. PROCEDURE (s: Stream) Close NEW, ABSTRACT Closes the connection. If the connection was already closed, Close has no effect. Post ~s.IsConnected() PROCEDURE (s: Stream) IsConnected (): BOOLEAN NEW, ABSTRACT Tests whether connection is still open, or whether it has been closed by either partner of the connection. No data can be read anymore. IsConnected is not precise in time. It only represents the current knowledge of the stream implementation about the state of the connection. In reality, this state may already have changed. This means that IsConnected may still return TRUE even if the connection has already been closed down. Post result = FALSE connection has been closed by one of the partners result = TRUE connection is probably still open PROCEDURE (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER) NEW, ABSTRACT Receives up to len bytes from the communication link and reads them. The procedure never blocks. No bytes are read if ~s.IsConnected(). Pre beg >= 0 20 len > 0 21 LEN(x) >= beg + len 22 Post read >= 0 x[beg ... beg + read[ = bytes read PROCEDURE (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER) NEW, ABSTRACT Sends up to len bytes over the communication link. The procedure never blocks. How many bytes are written might depend on internal resources, like buffer size. However, no guarantee of reception of the data by the partner site is given. No bytes are written if ~s.IsConnected(). Pre beg >= 0 20 len > 0 21 LEN(x) >= beg + len 22 Post written >= 0 x[beg ... beg + written[ = bytes written PROCEDURE NewListener (protocol, localAdr: ARRAY OF CHAR; OUT l: Listener; OUT res: INTEGER) Offers connections on the port specified by localAdr using the transport service protocol. The format of localAdr depends on the protocol used. For TCP/IP, protocol = "CommTCP" and localAdr is the local port number (may be the empty string). Result codes (parameter res) may be one of the following (see const definitions above) or a protocol-specific value: done, noSuchProtocol, networkDown, invalidLocalAdr, localAdrInUse Pre protocol # "" 20 Post res = 0 l # NIL listener is open res # 0 l = NIL PROCEDURE NewStream (protocol, localAdr, remoteAdr: ARRAY OF CHAR; OUT s: Stream; OUT res: INTEGER) Connects to the site and port specified by remoteAdr using the local port given by localAdr. The format of the addresses depend on the protocol used. For example, for protocol = "CommTCP", localAdr must be a port number, e.g., 4. If the empty string is passed, port number 0 ("don't care") is used. The remoteAdr must either be an IP address such as "100.0.0.7", or the host's name. Either of them may optionally be followed by a ":" and a port number, e.g., "100.0.0.7:2". Without this option, port number 0 is assumed. For TCP/IP, protocol = "CommTCP" and localAdr is the local port number (may be the empty string). Result codes (parameter res) may be one of the following (see const definitions above) or a protocol-specific value: done, noSuchProtocol, networkDown, invalidLocalAdr, localAdrInUse, invalidRemoteAdr, remoteAdrInUse Pre protocol # "" 20 Post res = 0 s # NIL stream is open res # 0 s = NIL

Comm/Docu/Streams.odc

Map to the Comm Subsystem CommStreams reliable streams abstraction CommTCP TCP/IP streams (sockets) CommV24 V24 unreliable streams CommObxStreamsClient CommStreams example CommObxStreamsServer CommStreams example

Comm/Docu/Sys-Map.odc

CommTCP Driver for CommStreams. It implements TCP/IP streams, using the operating system's sockets interface. It provides the NewListener and NewStream factory functions as needed for CommStreams. Do not import CommTCP directly; instead, use CommStreams and specify "CommTCP" as the protocol name. Parameters localAdr and remoteAdr The CommStreams procedures NewStream and NewListener feature string parameters remoteAdr and localAdr. The interpretation of the strings passed depends on the implementation of the actual driver module. For CommTCP the following holds. The remoteAdr (only used with NewStream) must be either an IP address or a host's name, followed by a colon (":") and a port number. (Examples: "127.0.0.1:2", "loopback:2".) The parameter localAdr identifies the port on which a listener is established (NewListener) or from which a remote connection is attempted (NewStream). Valid values are - an empty string - an IP address or a host's name (Examples: "127.0.0.1", "loopback") - an IP address or a host's name followed by a colon (":") and a port number (Examples: "127.0.0.1:2", "loopback:2") - a port number (Example: "2") For unspecified port numbers, a wildcard is used, directing the operating system to choose freely. For unspecified local addresses the local host's address "127.0.0.1" is used. The special IP address "0.0.0.0" means all available IP addresses on the local machine (including "127.0.0.1"). This can be used for listening on all available network interfaces or for connecting to a server using any available network interface. In this case network traffic may leave the local machine.

Comm/Docu/TCP.odc

CommV24 MODULE CommV24; CONST bits4 = 0; bits5 = 1; bits6 = 2; bits7 = 3; stop15 = 4; stop2 = 5; even = 6; odd = 7; inXonXoff = 8; outXonXoff = 9; inRTS = 10; inDTR = 11; outCTS = 12; outDSR = 13; TYPE Connection = POINTER TO LIMITED RECORD END; PROCEDURE Open (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: Connection); PROCEDURE Close (c: Connection); PROCEDURE SendByte (c: Connection; x: BYTE); PROCEDURE SendBytes (c: Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER); PROCEDURE Available (c: Connection): INTEGER; PROCEDURE ReceiveByte (c: Connection; OUT x: BYTE); PROCEDURE ReceiveBytes (c: Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER); PROCEDURE SetBuffers (c: Connection; inpBufSize, outBufSize: INTEGER); PROCEDURE SetDTR (c: Connection; on: BOOLEAN); PROCEDURE SetRTS (c: Connection; on: BOOLEAN); PROCEDURE SetBreak (c: Connection; on: BOOLEAN); PROCEDURE CTSState (c: Connection): BOOLEAN; PROCEDURE DSRState (c: Connection): BOOLEAN; PROCEDURE CDState (c: Connection): BOOLEAN; END CommV24. Simple procedural interface to V24 and similar serial devices. CONST bits4, bits5, bits6, bits7 Number of data bits. These flags may be included in the opts set of procedure Open. At most one of them may be included. If none is included, 8 bits are chosen. CONST stop15, stop2 Number of stop bits (1.5 or 2). These flags may be included in the opts set of procedure Open. At most one of them may be included. If none is included, one stop bit is chosen. CONST even, odd Parity checking. These flags may be included in the opts set of procedure Open. At most one of them may be included. If none is included, no parity checking is chosen. CONST inXonXoff, outXonXoff XOn/XOff flow control for input and for output direction. These flags may be included in the opts set of procedure Open. CONST inRTS, inDTR, outCTS, outDSR These flags may be included in the opts set of procedure Open. TYPE Connection LIMITED Connection handle. It represents a V24 connection through a particular device. PROCEDURE Open (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: Connection) Opens a given device (e.g., "COM3:") with the given baudrate and options. Note that a device to which a connection is already open cannot be open a second time before it is closed explicitly. Post opening succeeded conn # NIL opening failed conn = NIL PROCEDURE Close (c: Connection) Closes an open connection. Pre c # NIL 20 c is open 21 PROCEDURE SendByte (c: Connection; x: BYTE) Pre c # NIL 20 c is open 21 PROCEDURE SendBytes (c: Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER) Pre c # NIL 20 c is open 21 LEN(x) >= beg + len 22 len > 0 23 PROCEDURE Available (c: Connection): INTEGER Pre c # NIL 20 c is open 21 PROCEDURE ReceiveByte (c: Connection; OUT x: BYTE) Pre c # NIL 20 c is open 21 PROCEDURE ReceiveBytes (c: Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER) Pre c # NIL 20 c is open 21 LEN(x) >= beg + len 22 len > 0 23 PROCEDURE SetBuffers (c: Connection; inpBufSize, outBufSize: INTEGER) Pre c # NIL 20 c is open 21 PROCEDURE SetDTR (c: Connection; on: BOOLEAN) Pre c # NIL 20 c is open 21 ~(inDTR IN c.opts) 22 PROCEDURE SetRTS (c: Connection; on: BOOLEAN) Pre c # NIL 20 c is open 21 ~(inRTS IN c.opts) 22 PROCEDURE SetBreak (c: Connection; on: BOOLEAN) Pre c # NIL 20 c is open 21 PROCEDURE CTSState (c: Connection): BOOLEAN Pre c # NIL 20 c is open 21 PROCEDURE DSRState (c: Connection): BOOLEAN Pre c # NIL 20 c is open 21 PROCEDURE CDState (c: Connection): BOOLEAN Pre c # NIL 20 c is open 21

Comm/Docu/V24.odc

MODULE CommObxStreamsClient; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT Services, CommStreams, TextModels, TextControllers, StdLog; CONST protocol = "CommTCP"; (* driver for TCP/IP communication, over Winsock *) remoteAdr = "127.0.0.1:900"; (* loopback address, so you can test on your local machine; choose a port number that is not used yet (here: 900). You could also specify an IP address in the form "mymachine.mydomain.com:900" *) localAdr = ""; (* don't specify an address or port on the client side *) TYPE Sender = POINTER TO RECORD (Services.Action) prev, succ: Sender; (* linked to allow stopping upon module unloading *) stream: CommStreams.Stream; (* during sending, the communicates through this object *) idx, len: INTEGER; (* index for start of data into the buf array, and length remaining to be sent *) buf: ARRAY 256 OF BYTE (* data to be sent *) END; VAR senders: Sender; PROCEDURE (s: Sender) Do; VAR written: INTEGER; BEGIN IF s.stream.IsConnected() THEN s.stream.WriteBytes(s.buf, s.idx, s.len, written); (* poll for outgoing data *) INC(s.idx, written); DEC(s.len, written); IF s.len > 0 THEN (* keep action alive if there remains further data to send *) Services.DoLater(s, Services.now) ELSE s.stream.Close; IF s.prev # NIL THEN s.prev.succ := s.succ ELSE senders := s.succ END; IF s.succ # NIL THEN s.succ.prev := s.prev END END ELSE (* connection was closed by server *) IF s.prev # NIL THEN s.prev.succ := s.succ ELSE senders := s.succ END; IF s.succ # NIL THEN s.succ.prev := s.prev END; IF s.idx = 0 THEN StdLog.String("client: connection was not accepted by server") ELSE StdLog.String("client: connection was closed by server") END; StdLog.Ln END END Do; PROCEDURE Start (s: Sender); VAR stream: CommStreams.Stream; res: INTEGER; BEGIN CommStreams.NewStream(protocol, localAdr, remoteAdr, stream, res); IF stream # NIL THEN s.prev := NIL; s.succ := senders; senders := s; IF s.succ # NIL THEN s.succ.prev := s END; s.stream := stream; Services.DoLater(s, Services.now); StdLog.String("client: connection opened"); StdLog.Ln ELSE StdLog.String("client: error opening the connection ("); StdLog.Int(res); StdLog.Char(")"); StdLog.Ln END END Start; PROCEDURE Stop; BEGIN WHILE senders # NIL DO senders.stream.Close; Services.RemoveAction(senders); senders := senders.succ END END Stop; PROCEDURE SendTextSelection*; VAR c: TextControllers.Controller; beg, end, i, len: INTEGER; rd: TextModels.Reader; ch: CHAR; s: Sender; BEGIN c := TextControllers.Focus(); IF (c # NIL) & c.HasSelection() THEN NEW(s); c.GetSelection(beg, end); rd := c.text.NewReader(NIL); rd.SetPos(beg); i := 0; len := end - beg; IF len >= LEN(s.buf) - 1 THEN len := LEN(s.buf) - 1 END; (* clip string if necessary *) WHILE len # 0 DO rd.ReadChar(ch); IF ch < 100X THEN (* skip Unicode characters *) s.buf[i] := SHORT(SHORT(ORD(ch))); INC(i) END; DEC(len) END; s.idx := 0; s.len := i; Start(s) ELSE StdLog.String("client: no text selection found"); StdLog.Ln END END SendTextSelection; CLOSE Stop (* prevent the client from trapping after module unloading *) END CommObxStreamsClient. CommObxStreamsClient.SendTextSelection

Comm/Mod/ObxStreamsClient.odc

MODULE CommObxStreamsServer; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT Services, CommStreams, Views, TextModels, TextViews, StdLog; CONST protocol = "CommTCP"; (* driver for TCP/IP communication, over Winsock *) localAdr = "900"; (* this is the port on which the server listens *) TYPE Server = POINTER TO RECORD (Services.Action) listener: CommStreams.Listener (* the server listens using this object and accepts incoming connections*) END; Processor = POINTER TO RECORD (Services.Action) prev, succ: Processor; (* linked to allow stopping of all active processors with Stop command *) stream: CommStreams.Stream; (* for each connection, a receiver communicates through this object *) writer: TextModels.Writer END; VAR server: Server; processors: Processor; PROCEDURE (server: Server) Do; VAR s: CommStreams.Stream; p: Processor; t: TextModels.Model; BEGIN server.listener.Accept(s); (* poll for a connection *) IF s # NIL THEN (* upon accept create and start processor for new connection *) NEW(p); p.prev := NIL; p.succ := processors; processors := p; IF p.succ # NIL THEN p.succ.prev := p END; p.stream := s; t := TextModels.dir.New(); p.writer := t.NewWriter(NIL); Views.OpenAux(TextViews.dir.New(t), "Message"); Services.DoLater(p, Services.now) END; Services.DoLater(server, Services.now) END Do; PROCEDURE (p: Processor) Do; VAR buf: ARRAY 256 OF BYTE; read, i: INTEGER; BEGIN p.stream.ReadBytes(buf, 0, LEN(buf), read); (* poll for incoming data *) IF read > 0 THEN (* write received data into log *) i := 0; WHILE i # read DO p.writer.WriteChar(CHR(buf[i])); INC(i) END; Services.DoLater(p, Services.now) ELSIF p.stream.IsConnected() THEN Services.DoLater(p, Services.now) ELSE IF p.prev # NIL THEN p.prev.succ := p.succ ELSE processors := p.succ END; IF p.succ # NIL THEN p.succ.prev := p.prev END END END Do; PROCEDURE Start*; VAR l: CommStreams.Listener; res: INTEGER; BEGIN IF server = NIL THEN CommStreams.NewListener(protocol, localAdr, l, res); IF l # NIL THEN NEW(server); server.listener := l; Services.DoLater(server, Services.now); StdLog.String("server: server started"); StdLog.Ln ELSE StdLog.String("server: error starting the server ("); StdLog.Int(res); StdLog.Char(")"); StdLog.Ln END END END Start; PROCEDURE Stop*; BEGIN WHILE processors # NIL DO processors.stream.Close; Services.RemoveAction(processors); processors := processors.succ END; IF server # NIL THEN Services.RemoveAction(server); server.listener.Close; server := NIL; StdLog.String("server: server stopped"); StdLog.Ln END END Stop; CLOSE Stop (* prevent the server from trapping after module unloading *) END CommObxStreamsServer. CommObxStreamsServer.Start CommObxStreamsServer.Stop

Comm/Mod/ObxStreamsServer.odc

MODULE CommStreams; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT Meta; CONST (* portable error codes: *) done* = 0; noSuchProtocol* = 1; invalidLocalAdr* = 2; invalidRemoteAdr* = 3; networkDown* = 4; localAdrInUse* = 5; remoteAdrInUse* = 6; TYPE Adr* = POINTER TO ARRAY OF CHAR; Stream* = POINTER TO ABSTRACT RECORD END; StreamAllocator* = PROCEDURE (localAdr, remoteAdr: ARRAY OF CHAR; OUT s: Stream; OUT res: INTEGER); Listener* = POINTER TO ABSTRACT RECORD END; ListenerAllocator* = PROCEDURE (localAdr: ARRAY OF CHAR; OUT l: Listener; OUT res: INTEGER); PROCEDURE (s: Stream) RemoteAdr* (): Adr, NEW, ABSTRACT; PROCEDURE (s: Stream) IsConnected* (): BOOLEAN, NEW, ABSTRACT; PROCEDURE (s: Stream) WriteBytes* ( IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER), NEW, ABSTRACT; PROCEDURE (s: Stream) ReadBytes* ( VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER), NEW, ABSTRACT; PROCEDURE (s: Stream) Close*, NEW, ABSTRACT; PROCEDURE NewStream* (protocol, localAdr, remoteAdr: ARRAY OF CHAR; OUT s: Stream; OUT res: INTEGER); VAR ok: BOOLEAN; m, p: Meta.Item; mod: Meta.Name; v: RECORD (Meta.Value) p: StreamAllocator END; BEGIN ASSERT(protocol # "", 20); res := noSuchProtocol; mod := protocol$; Meta.Lookup(mod, m); IF m.obj = Meta.modObj THEN m.Lookup("NewStream", p); IF p.obj = Meta.procObj THEN p.GetVal(v, ok); IF ok THEN v.p(localAdr, remoteAdr, s, res) END END END END NewStream; PROCEDURE (l: Listener) LocalAdr* (): Adr, NEW, ABSTRACT; PROCEDURE (l: Listener) Accept* (OUT s: Stream), NEW, ABSTRACT; PROCEDURE (l: Listener) Close*, NEW, ABSTRACT; PROCEDURE NewListener* (protocol, localAdr: ARRAY OF CHAR; OUT l: Listener; OUT res: INTEGER); VAR ok: BOOLEAN; m, p: Meta.Item; mod: Meta.Name; v: RECORD(Meta.Value) p: ListenerAllocator END; BEGIN ASSERT(protocol # "", 20); res := noSuchProtocol; mod := protocol$; Meta.Lookup(mod, m); IF m.obj = Meta.modObj THEN m.Lookup("NewListener", p); IF p.obj = Meta.procObj THEN p.GetVal(v, ok); IF ok THEN v.p(localAdr, l, res) END END END END NewListener; END CommStreams.

Comm/Mod/Streams.odc

MODULE CommTCP; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems, Ivan Denisov" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " " issues = " " **) IMPORT Kernel, Dialog, CommStreams; TYPE Hook* = POINTER TO ABSTRACT RECORD END; VAR hook: Hook; PROCEDURE SetHook* (h: Hook); BEGIN hook := h END SetHook; PROCEDURE (h: Hook) NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER), NEW, ABSTRACT; PROCEDURE (h: Hook) NewStream* (localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER), NEW, ABSTRACT; PROCEDURE NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER); BEGIN hook.NewListener(localAdr, l, res) END NewListener; PROCEDURE NewStream* (localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER); BEGIN hook.NewStream(localAdr, remoteAdr, s, res) END NewStream; BEGIN IF Dialog.platform = Dialog.windows THEN Kernel.LoadMod("CommTCP__Win") ELSIF Dialog.platform = Dialog.linux THEN Kernel.LoadMod("CommTCP__Lin") ELSIF Dialog.platform = Dialog.openbsd THEN Kernel.LoadMod("CommTCP__Obsd") ELSIF Dialog.platform = Dialog.freebsd THEN Kernel.LoadMod("CommTCP__Fbsd") END END CommTCP.

Comm/Mod/TCP.odc

MODULE CommTCP__Fbsd; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "see the CommStreams documentation for details on the semantics of this driver module" changes = " - 20070130, bh, Winsock replaced by WinNet " issues = " - ... " **) (* A. V. Shiryaev, 2012.11, 2016.11: FreeBSD CommTCP Based on 1.6 Windows CommTCP *) IMPORT SYSTEM, Libc := FbsdLibc, Net := FbsdNet, Ioctl := FbsdIoctl, Strings, Dialog, CommStreams, CommTCP; CONST hostSpecificError = -1; (* host-specific error codes *) INVALID_SOCKET = Net.INVALID_SOCKET; SOCKET_ERROR = Net.SOCKET_ERROR; TYPE Stream = POINTER TO RECORD (CommStreams.Stream) sock: Net.SOCKET; (* socket must be in non-blocking mode, otherwise recv() or send() could block *) remoteAdr: CommStreams.Adr (* remoteAdr # NIL *) END; Listener = POINTER TO RECORD (CommStreams.Listener) sock: Net.SOCKET; localAdr: CommStreams.Adr (* localAdr # NIL *) END; Hook* = POINTER TO RECORD (CommTCP.Hook) END; VAR debug*: BOOLEAN; hook: Hook; PROCEDURE Errno (): INTEGER; VAR errno: INTEGER; BEGIN SYSTEM.GET(Libc.__errno_location(), errno); RETURN errno END Errno; (* auxiliary procedures *) PROCEDURE CopyOfAdrString (a: CommStreams.Adr): CommStreams.Adr; VAR b: CommStreams.Adr; BEGIN NEW(b, LEN(a)); b := a; RETURN b END CopyOfAdrString; PROCEDURE Error (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 8 OF CHAR; BEGIN IF debug THEN CASE errno OF Libc.EINTR: s := "EINTR, interrupted system call" | Libc.EBADF: s := "EBADF, bad file descriptor" | Libc.EACCES: s := "EACCES, permission denied" | Libc.EFAULT: s := "EFAULT, bad address" | Libc.EINVAL: s := "EINVAL, invalid argument" | Libc.ENFILE: s := "ENFILE, too many open files in system" | Libc.EMFILE: s := "EMFILE, too many open files" | Libc.EPIPE: s := "EPIPE, broken pipe" | Libc.EAGAIN: s := "EAGAIN, resource temporarily unavailable" | Libc.EINPROGRESS: s := "EINPROGRESS, operation now in progress" | Libc.EALREADY: s := "EALREADY, operation already in progress" | Libc.ENOTSOCK: s := "ENOTSOCK, socket operation on non-socket" | Libc.EDESTADDRREQ: s := "EDESTADDRREQ, destination address required" | Libc.EMSGSIZE: s := "EMSGSIZE, message too long" | Libc.ENOPROTOOPT: s := "ENOPROTOOPT, protocol not available" | Libc.EPROTONOSUPPORT: s := "EPROTONOSUPPORT, protocol not supported" | Libc.EAFNOSUPPORT: s := "EAFNOSUPPORT, address family not supported by protocol family" | Libc.EADDRINUSE: s := "EADDRINUSE, address already in use" | Libc.EADDRNOTAVAIL: s := "EADDRNOTAVAIL, can't assign requested address" | Libc.ENETDOWN: s := "ENETDOWN, network is down" | Libc.ENETUNREACH: s := "ENETUNREACH, network is unreachable" | Libc.ENOBUFS: s := "ENOBUFS, no buffer space available" | Libc.EISCONN: s := "EISCONN, socket is already connected" | Libc.ENOTCONN: s := "ENOTCONN, socket is not connected" | Libc.ETIMEDOUT: s := "ETIMEDOUT, operation timed out" | Libc.ECONNREFUSED: s := "ECONNREFUSED, connection refused" | Libc.EHOSTDOWN: s := "EHOSTDOWN, host is down" | Libc.EHOSTUNREACH: s := "EHOSTUNREACH, no route to host" ELSE s := "(please look up the error number in the LinLibc symbol file and in the FreeBSD documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END Error; PROCEDURE GAIError (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 12 OF CHAR; BEGIN IF debug THEN CASE errno OF Net.EAI_AGAIN: s := "EAI_AGAIN, temporary failure in name resolution" | Net.EAI_BADFLAGS: s := "EAI_BADFLAGS, invalid value for ai_flags" | Net.EAI_BADHINTS: s := "EAI_BADHINTS, invalid value for hints" | Net.EAI_FAIL: s := "EAI_FAIL, non-recoverable failure in name resolution" | Net.EAI_FAMILY: s := "EAI_FAMILY, ai_family not supported" | Net.EAI_MEMORY: s := "EAI_MEMORY, memory allocation failure" | Net.EAI_NONAME: s := "EAI_NONAME, hostname or servname not provided, or not known" | Net.EAI_OVERFLOW: s := "EAI_OVERFLOW, argument buffer overflow" | Net.EAI_PROTOCOL: s := "EAI_PROTOCOL, resolved protocol is unknown" | Net.EAI_SERVICE: s := "EAI_SERVICE, servname not supported for ai_socktype" | Net.EAI_SOCKTYPE: s := "EAI_SOCKTYPE, ai_socktype not supported" | Net.EAI_SYSTEM: s := "EAI_SYSTEM, system error returned in errno" ELSE s := "(please look up the error number in the LinNet symbol file and in the FreeBSD documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END GAIError; PROCEDURE IsIPAddress (name: ARRAY OF CHAR): BOOLEAN; (* returns TRUE iff name only contains decimal digits and "." characters *) VAR i: INTEGER; BEGIN i := 0; WHILE ("0" <= name[i]) & (name[i] <= "9") OR (name[i] = ".") DO INC(i) END; RETURN name[i] = 0X END IsIPAddress; PROCEDURE ParseAdr (adr: ARRAY OF CHAR; OUT addr: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN); (* parse address specification with syntax addr [ ":" portnumber ] *) VAR i, j, res: INTEGER; portstr: ARRAY 16 OF CHAR; BEGIN i := 0; j := 0; port := 0; ok := TRUE; WHILE (adr[i] # 0X) & (adr[i] # ":") DO IF j < LEN(addr) - 1 THEN addr[j] := adr[i]; INC(j) END; INC(i) END; ok := i = j; addr[j] := 0X; IF ok & (adr[i] = ":") THEN INC(i); j := 0; WHILE adr[i] # 0X DO portstr[j] := adr[i]; INC(i); IF j < LEN(portstr) - 1 THEN INC(j) END END; portstr[j] := 0X; Strings.StringToInt(portstr, port, res); ok := res = 0 END END ParseAdr; PROCEDURE ParseLocalAdr (IN adr: ARRAY OF CHAR; OUT peername: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN ); VAR i, res: INTEGER; BEGIN IF adr = "" THEN port := 0; peername := ""; ok := TRUE (* default port number 0 means 'don't care which port is used' *) ELSE i := 0; WHILE (adr[i] # 0X) & ((adr[i] >= "0") & (adr[i] <= "9")) OR (adr[i] = " ") DO INC(i) END; IF adr[i] # 0X THEN ParseAdr(adr, peername, port, ok) ELSE Strings.StringToInt(adr, port, res); peername := ""; ok := res = 0 END END END ParseLocalAdr; PROCEDURE NameToAdr (IN peername: ARRAY OF CHAR; VAR inaddr: Net.in_addr; OUT ok: BOOLEAN); VAR shortPName: ARRAY 64 OF SHORTCHAR; res: Net.int; result: Net.Ptraddrinfo; hints: Net.addrinfo; addr: Net.Ptrsockaddr_in; BEGIN shortPName := SHORT(peername$); IF IsIPAddress(peername) THEN IF shortPName = "" THEN inaddr.S_un.S_addr := Net.INADDR_ANY ELSE inaddr.S_un.S_addr := Net.inet_addr(shortPName) END; ok := inaddr.S_un.S_addr # Net.INADDR_NONE ELSE hints.ai_flags := {}; hints.ai_family := Net.AF_INET; hints.ai_socktype := Net.SOCK_STREAM; hints.ai_protocol := Net.IPPROTO_TCP; hints.ai_addrlen := 0; hints.ai_addr := NIL; hints.ai_canonname := NIL; hints.ai_next := NIL; res := Net.getaddrinfo(shortPName, NIL, hints, result); ok := res = 0; IF ok THEN ASSERT(result # NIL); IF (result.ai_family = Net.AF_INET) & (result.ai_socktype = Net.SOCK_STREAM) & (result.ai_protocol = Net.IPPROTO_TCP) & (result.ai_addr # NIL) THEN addr := SYSTEM.VAL(Net.Ptrsockaddr_in, result.ai_addr); inaddr := addr.sin_addr ELSE ok := FALSE END; Net.freeaddrinfo(result); ASSERT(ok) ELSE GAIError("getaddrinfo()", res) END END END NameToAdr; PROCEDURE MakeAdr (adr: Net.sockaddr_in; OUT s: CommStreams.Adr); VAR ipadr, n: INTEGER; temp, buf: ARRAY 64 OF CHAR; BEGIN ipadr := adr.sin_addr.S_un.S_addr; temp := ""; IF ipadr # 0 THEN n := ipadr MOD 256; Strings.IntToString(n, temp); n := SYSTEM.LSH(ipadr, -8); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -16); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -24); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "." + buf + ":" END; n := (adr.sin_port MOD 256) * 256 + (adr.sin_port DIV 256) MOD 256; Strings.IntToString(n, buf); temp := temp + buf; NEW(s, LEN(temp$) + 1); s^ := temp$ END MakeAdr; (* Linux, FreeBSD, OpenBSD, 32-bit *) PROCEDURE FD_ZERO (VAR set: Net.fd_set); VAR i: INTEGER; BEGIN i := LEN(set); REPEAT DEC(i); set[i] := {} UNTIL i = 0 END FD_ZERO; PROCEDURE FD_SET (fd: Net.SOCKET; VAR set: Net.fd_set); BEGIN INCL(set[fd DIV 32], fd MOD 32) END FD_SET; PROCEDURE MakeFdSet (socket: Net.SOCKET; OUT set: Net.fd_set); BEGIN FD_ZERO(set); FD_SET(socket, set) END MakeFdSet; (* Listener *) PROCEDURE (l: Listener) LocalAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(l.localAdr) END LocalAdr; PROCEDURE (l: Listener) Accept (OUT s: CommStreams.Stream); VAR timeout: Net.timeval; set: Net.fd_set; res, namelen: INTEGER; sock: Net.SOCKET; tcpstream: Stream; adr: Net.sockaddr_storage; BEGIN timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(l.sock, set); res := Net.select(l.sock + 1, set, NIL, NIL, timeout); ASSERT(res # SOCKET_ERROR, 100); IF res > 0 THEN namelen := SIZE(Net.sockaddr_storage); sock := Net.accept(l.sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(sock # INVALID_SOCKET, 101); namelen := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, namelen); (* set to non-blocking mode *) ASSERT(res = 0, 102); NEW(tcpstream); tcpstream.sock := sock; MakeAdr(SYSTEM.VAL(Net.sockaddr_in, adr), tcpstream.remoteAdr); s := tcpstream END END Accept; PROCEDURE (l: Listener) Close; VAR res: INTEGER; BEGIN IF l.sock # INVALID_SOCKET THEN res := Libc.close(l.sock); l.sock := INVALID_SOCKET END END Close; PROCEDURE (l: Listener) FINALIZE-; BEGIN WITH l: Listener DO IF l.sock # INVALID_SOCKET THEN l.Close END END END FINALIZE; PROCEDURE NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER); (* localAdr must contain a port number *) CONST SOMAXCONN = 5; (* use default length of listener backlog queue *) VAR portnr, namelen, optval: INTEGER; ok: BOOLEAN; tcplistener: Listener; adr: Net.sockaddr_in; sock: Net.SOCKET; peername: ARRAY 64 OF CHAR; BEGIN l := NIL; ParseLocalAdr(localAdr, peername, portnr, ok); IF ok & (portnr >= 0) THEN (* only non-negative port numbers are legal *) sock := Net.socket(Net.AF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); ASSERT(sock # INVALID_SOCKET, 100); optval := 1; res := Net.setsockopt(sock, Net.SOL_SOCKET, Net.SO_REUSEADDR, SYSTEM.ADR(optval), SIZE(INTEGER)); ASSERT(res = 0, 101); adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(portnr)); NameToAdr(peername, adr.sin_addr, ok); IF ok THEN res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN res := Net.listen(sock, SOMAXCONN); ASSERT(res = 0, 102); NEW(tcplistener); tcplistener.sock := sock; namelen := SIZE(Net.sockaddr_in); res := Net.getsockname(sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(res = 0, 103); MakeAdr(adr, tcplistener.localAdr); l := tcplistener; res := CommStreams.done ELSE res := CommStreams.localAdrInUse END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END END NewListener; (* Stream *) PROCEDURE (s: Stream) RemoteAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(s.remoteAdr) END RemoteAdr; PROCEDURE (s: Stream) IsConnected (): BOOLEAN; (* Give an educated guess on whether the peer has closed the connection. *) (* This is not a guarantee that data sent on s will arrive at the peer. *) VAR timeout: Net.timeval; set: Net.fd_set; n, res, avail: INTEGER; BEGIN IF s.sock = INVALID_SOCKET THEN RETURN FALSE ELSE timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, set, NIL, NIL, timeout); ASSERT(n # SOCKET_ERROR, 100); IF n = 1 THEN (* a recv on s.sock would not block; find out whether there is data queued *) res := Ioctl.ioctl1(s.sock, Ioctl.FIONREAD, avail); ASSERT(res = 0, 101); (* if there is data queued, we assume the socket is still open. if no data is queued, then we know that a recv can only return with zero bytes read, telling us that the socket has been closed. *) RETURN avail > 0 ELSE (* a recv on s.sock would block, so the peer has not closed the socket yet or the connect failed entirely *) timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, NIL, NIL, set, timeout); ASSERT(n # SOCKET_ERROR, 102); IF n = 1 THEN s.Close END; RETURN n = 0 END END END IsConnected; PROCEDURE (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); written := Net.send(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, Net.MSG_NOSIGNAL); IF written = SOCKET_ERROR THEN res := Errno(); IF (res # Libc.EAGAIN) & (res # Libc.ENOTCONN) THEN Error("send()", res) END; written := 0 END END WriteBytes; PROCEDURE (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); read := Net.recv(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, {}); IF read = SOCKET_ERROR THEN res := Errno(); IF (res = Libc.EAGAIN) OR (res = Libc.ENOTCONN) THEN read := 0 (* there is nothing to be read *) ELSIF res = Libc.ECONNRESET THEN read := 0; s.Close (* prevent trap *) ELSE Error("recv()", res); read := 0; s.Close END END END ReadBytes; PROCEDURE (s: Stream) Close; VAR res: INTEGER; BEGIN res := Libc.close(s.sock); s.sock := INVALID_SOCKET END Close; PROCEDURE (s: Stream) FINALIZE-; BEGIN IF s.sock # INVALID_SOCKET THEN s.Close END END FINALIZE; PROCEDURE CreateStream ( OUT s: CommStreams.Stream; sock: Net.SOCKET; IN remoteAdr: ARRAY OF CHAR ); VAR stream: Stream; BEGIN NEW(stream); stream.sock := sock; NEW(stream.remoteAdr, LEN(remoteAdr$)+1); stream.remoteAdr^ := remoteAdr$; s := stream END CreateStream; PROCEDURE NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); (* localAdr may contain a port number *) (* remoteAdr must contain an address in the format ( ip-address | hostname ) [ ":" portnumber ] *) VAR adr: Net.sockaddr_in; rpeername, lpeername: ARRAY 64 OF CHAR; inaddr: Net.in_addr; lport, rport: INTEGER; ok: BOOLEAN; sock: Net.SOCKET; BEGIN s := NIL; ParseAdr(remoteAdr, rpeername, rport, ok); IF ok THEN sock := Net.socket(Net.AF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); IF sock # INVALID_SOCKET THEN ParseLocalAdr(localAdr, lpeername, lport, ok); IF ok & (lport >= 0) THEN (* only non-negative port numbers are legal *) adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(lport)); NameToAdr(lpeername, adr.sin_addr, ok); res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN NameToAdr(rpeername, inaddr, ok); IF ok THEN adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(rport)); adr.sin_addr := inaddr; res := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, res); (* set to non-blocking mode *) ASSERT(res = 0, 101); res := Net.connect(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE res := Errno(); IF res = Libc.EINPROGRESS THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE Error("connect()", res); res := Libc.close(sock); res := hostSpecificError END END ELSE res := Libc.close(sock); res := CommStreams.invalidRemoteAdr END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END ELSE Error("socket()", Errno()); res := hostSpecificError END ELSE res := CommStreams.invalidRemoteAdr END END NewStream; PROCEDURE (hook: Hook) NewListener* ( localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER ); BEGIN NewListener(localAdr, l, res) END NewListener; PROCEDURE (hook: Hook) NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); BEGIN NewStream(localAdr, remoteAdr, s, res) END NewStream; BEGIN NEW(hook); CommTCP.SetHook(hook); debug := FALSE END CommTCP__Fbsd.

Comm/Mod/TCP__Fbsd.odc

MODULE CommTCP__Lin; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "see the CommStreams documentation for details on the semantics of this driver module" changes = " - 20070130, bh, Winsock replaced by WinNet " issues = " - ... " **) (* A. V. Shiryaev, 2012.11, 2016.11: Linux CommTCP Based on 1.6 Windows CommTCP *) IMPORT SYSTEM, Libc := LinLibc, Net := LinNet, Ioctl := LinIoctl, Strings, Dialog, CommStreams, CommTCP; CONST hostSpecificError = -1; (* host-specific error codes *) INVALID_SOCKET = Net.INVALID_SOCKET; SOCKET_ERROR = Net.SOCKET_ERROR; TYPE Stream = POINTER TO RECORD (CommStreams.Stream) sock: Net.SOCKET; (* socket must be in non-blocking mode, otherwise recv() or send() could block *) remoteAdr: CommStreams.Adr (* remoteAdr # NIL *) END; Listener = POINTER TO RECORD (CommStreams.Listener) sock: Net.SOCKET; localAdr: CommStreams.Adr (* localAdr # NIL *) END; Hook* = POINTER TO RECORD (CommTCP.Hook) END; VAR debug*: BOOLEAN; hook: Hook; PROCEDURE Errno (): INTEGER; VAR errno: INTEGER; BEGIN SYSTEM.GET(Libc.__errno_location(), errno); RETURN errno END Errno; (* auxiliary procedures *) PROCEDURE CopyOfAdrString (a: CommStreams.Adr): CommStreams.Adr; VAR b: CommStreams.Adr; BEGIN NEW(b, LEN(a)); b := a; RETURN b END CopyOfAdrString; PROCEDURE Error (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 8 OF CHAR; BEGIN IF debug THEN CASE errno OF Libc.EINTR: s := "EINTR, interrupted system call" | Libc.EBADF: s := "EBADF, bad file descriptor" | Libc.EACCES: s := "EACCES, permission denied" | Libc.EFAULT: s := "EFAULT, bad address" | Libc.EINVAL: s := "EINVAL, invalid argument" | Libc.ENFILE: s := "ENFILE, too many open files in system" | Libc.EMFILE: s := "EMFILE, too many open files" | Libc.EPIPE: s := "EPIPE, broken pipe" | Libc.EAGAIN: s := "EAGAIN, resource temporarily unavailable" | Libc.EINPROGRESS: s := "EINPROGRESS, operation now in progress" | Libc.EALREADY: s := "EALREADY, operation already in progress" | Libc.ENOTSOCK: s := "ENOTSOCK, socket operation on non-socket" | Libc.EDESTADDRREQ: s := "EDESTADDRREQ, destination address required" | Libc.EMSGSIZE: s := "EMSGSIZE, message too long" | Libc.ENOPROTOOPT: s := "ENOPROTOOPT, protocol not available" | Libc.EPROTONOSUPPORT: s := "EPROTONOSUPPORT, protocol not supported" | Libc.EAFNOSUPPORT: s := "EAFNOSUPPORT, address family not supported by protocol family" | Libc.EADDRINUSE: s := "EADDRINUSE, address already in use" | Libc.EADDRNOTAVAIL: s := "EADDRNOTAVAIL, can't assign requested address" | Libc.ENETDOWN: s := "ENETDOWN, network is down" | Libc.ENETUNREACH: s := "ENETUNREACH, network is unreachable" | Libc.ENOBUFS: s := "ENOBUFS, no buffer space available" | Libc.EISCONN: s := "EISCONN, socket is already connected" | Libc.ENOTCONN: s := "ENOTCONN, socket is not connected" | Libc.ETIMEDOUT: s := "ETIMEDOUT, operation timed out" | Libc.ECONNREFUSED: s := "ECONNREFUSED, connection refused" | Libc.EHOSTDOWN: s := "EHOSTDOWN, host is down" | Libc.EHOSTUNREACH: s := "EHOSTUNREACH, no route to host" ELSE s := "(please look up the error number in the LinLibc symbol file and in the Linux documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END Error; PROCEDURE GAIError (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 12 OF CHAR; BEGIN IF debug THEN CASE errno OF Net.EAI_ADDRFAMILY: s := "EAI_ADDRFAMILY, address family for hostname not supported" | Net.EAI_AGAIN: s := "EAI_AGAIN, temporary failure in name resolution" | Net.EAI_BADFLAGS: s := "EAI_BADFLAGS, invalid value for ai_flags" | Net.EAI_FAIL: s := "EAI_FAIL, non-recoverable failure in name resolution" | Net.EAI_FAMILY: s := "EAI_FAMILY, ai_family not supported" | Net.EAI_MEMORY: s := "EAI_MEMORY, memory allocation failure" | Net.EAI_NODATA: s := "EAI_NODATA, no address associated with hostname" | Net.EAI_NONAME: s := "EAI_NONAME, hostname or servname not provided, or not known" | Net.EAI_OVERFLOW: s := "EAI_OVERFLOW, argument buffer overflow" | Net.EAI_SERVICE: s := "EAI_SERVICE, servname not supported for ai_socktype" | Net.EAI_SOCKTYPE: s := "EAI_SOCKTYPE, ai_socktype not supported" | Net.EAI_SYSTEM: s := "EAI_SYSTEM, system error returned in errno" ELSE s := "(please look up the error number in the LinNet symbol file and in the Linux documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END GAIError; PROCEDURE IsIPAddress (name: ARRAY OF CHAR): BOOLEAN; (* returns TRUE iff name only contains decimal digits and "." characters *) VAR i: INTEGER; BEGIN i := 0; WHILE ("0" <= name[i]) & (name[i] <= "9") OR (name[i] = ".") DO INC(i) END; RETURN name[i] = 0X END IsIPAddress; PROCEDURE ParseAdr (adr: ARRAY OF CHAR; OUT addr: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN); (* parse address specification with syntax addr [ ":" portnumber ] *) VAR i, j, res: INTEGER; portstr: ARRAY 16 OF CHAR; BEGIN i := 0; j := 0; port := 0; ok := TRUE; WHILE (adr[i] # 0X) & (adr[i] # ":") DO IF j < LEN(addr) - 1 THEN addr[j] := adr[i]; INC(j) END; INC(i) END; ok := i = j; addr[j] := 0X; IF ok & (adr[i] = ":") THEN INC(i); j := 0; WHILE adr[i] # 0X DO portstr[j] := adr[i]; INC(i); IF j < LEN(portstr) - 1 THEN INC(j) END END; portstr[j] := 0X; Strings.StringToInt(portstr, port, res); ok := res = 0 END END ParseAdr; PROCEDURE ParseLocalAdr (IN adr: ARRAY OF CHAR; OUT peername: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN ); VAR i, res: INTEGER; BEGIN IF adr = "" THEN port := 0; peername := ""; ok := TRUE (* default port number 0 means 'don't care which port is used' *) ELSE i := 0; WHILE (adr[i] # 0X) & ((adr[i] >= "0") & (adr[i] <= "9")) OR (adr[i] = " ") DO INC(i) END; IF adr[i] # 0X THEN ParseAdr(adr, peername, port, ok) ELSE Strings.StringToInt(adr, port, res); peername := ""; ok := res = 0 END END END ParseLocalAdr; PROCEDURE NameToAdr (IN peername: ARRAY OF CHAR; VAR inaddr: Net.in_addr; OUT ok: BOOLEAN); VAR shortPName: ARRAY 64 OF SHORTCHAR; res: Net.int; result: Net.Ptraddrinfo; hints: Net.addrinfo; addr: Net.Ptrsockaddr_in; BEGIN shortPName := SHORT(peername$); IF IsIPAddress(peername) THEN IF shortPName = "" THEN inaddr.S_un.S_addr := Net.INADDR_ANY ELSE inaddr.S_un.S_addr := Net.inet_addr(shortPName) END; ok := inaddr.S_un.S_addr # Net.INADDR_NONE ELSE hints.ai_flags := {}; hints.ai_family := Net.PF_INET; hints.ai_socktype := Net.SOCK_STREAM; hints.ai_protocol := Net.IPPROTO_TCP; hints.ai_addrlen := 0; hints.ai_addr := NIL; hints.ai_canonname := NIL; hints.ai_next := NIL; res := Net.getaddrinfo(shortPName, NIL, hints, result); ok := res = 0; IF ok THEN ASSERT(result # NIL); IF (result.ai_family = Net.PF_INET) & (result.ai_socktype = Net.SOCK_STREAM) & (result.ai_protocol = Net.IPPROTO_TCP) & (result.ai_addr # NIL) THEN addr := SYSTEM.VAL(Net.Ptrsockaddr_in, result.ai_addr); inaddr := addr.sin_addr ELSE ok := FALSE END; Net.freeaddrinfo(result); ASSERT(ok) ELSE GAIError("getaddrinfo()", res) END END END NameToAdr; PROCEDURE MakeAdr (adr: Net.sockaddr_in; OUT s: CommStreams.Adr); VAR ipadr, n: INTEGER; temp, buf: ARRAY 64 OF CHAR; BEGIN ipadr := adr.sin_addr.S_un.S_addr; temp := ""; IF ipadr # 0 THEN n := ipadr MOD 256; Strings.IntToString(n, temp); n := SYSTEM.LSH(ipadr, -8); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -16); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -24); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "." + buf + ":" END; n := (adr.sin_port MOD 256) * 256 + (adr.sin_port DIV 256) MOD 256; Strings.IntToString(n, buf); temp := temp + buf; NEW(s, LEN(temp$) + 1); s^ := temp$ END MakeAdr; (* Linux, FreeBSD, OpenBSD, 32-bit *) PROCEDURE FD_ZERO (VAR set: Net.fd_set); VAR i: INTEGER; BEGIN i := LEN(set); REPEAT DEC(i); set[i] := {} UNTIL i = 0 END FD_ZERO; PROCEDURE FD_SET (fd: Net.SOCKET; VAR set: Net.fd_set); BEGIN INCL(set[fd DIV 32], fd MOD 32) END FD_SET; PROCEDURE MakeFdSet (socket: Net.SOCKET; OUT set: Net.fd_set); BEGIN FD_ZERO(set); FD_SET(socket, set) END MakeFdSet; (* Listener *) PROCEDURE (l: Listener) LocalAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(l.localAdr) END LocalAdr; PROCEDURE (l: Listener) Accept (OUT s: CommStreams.Stream); VAR timeout: Net.timeval; set: Net.fd_set; res, namelen: INTEGER; sock: Net.SOCKET; tcpstream: Stream; adr: Net.sockaddr_storage; BEGIN timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(l.sock, set); res := Net.select(l.sock + 1, set, NIL, NIL, timeout); ASSERT(res # SOCKET_ERROR, 100); IF res > 0 THEN namelen := SIZE(Net.sockaddr_storage); sock := Net.accept(l.sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(sock # INVALID_SOCKET, 101); namelen := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, namelen); (* set to non-blocking mode *) ASSERT(res = 0, 102); NEW(tcpstream); tcpstream.sock := sock; MakeAdr(SYSTEM.VAL(Net.sockaddr_in, adr), tcpstream.remoteAdr); s := tcpstream END END Accept; PROCEDURE (l: Listener) Close; VAR res: INTEGER; BEGIN IF l.sock # INVALID_SOCKET THEN res := Libc.close(l.sock); l.sock := INVALID_SOCKET END END Close; PROCEDURE (l: Listener) FINALIZE-; BEGIN WITH l: Listener DO IF l.sock # INVALID_SOCKET THEN l.Close END END END FINALIZE; PROCEDURE NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER); (* localAdr must contain a port number *) CONST SOMAXCONN = 5; (* use default length of listener backlog queue *) VAR portnr, namelen, optval: INTEGER; ok: BOOLEAN; tcplistener: Listener; adr: Net.sockaddr_in; sock: Net.SOCKET; peername: ARRAY 64 OF CHAR; BEGIN l := NIL; ParseLocalAdr(localAdr, peername, portnr, ok); IF ok & (portnr >= 0) THEN (* only non-negative port numbers are legal *) sock := Net.socket(Net.PF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); ASSERT(sock # INVALID_SOCKET, 100); optval := 1; res := Net.setsockopt(sock, Net.SOL_SOCKET, Net.SO_REUSEADDR, SYSTEM.ADR(optval), SIZE(INTEGER)); ASSERT(res = 0, 101); adr.sin_family := Net.PF_INET; adr.sin_port := Net.htons(SHORT(portnr)); NameToAdr(peername, adr.sin_addr, ok); IF ok THEN res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN res := Net.listen(sock, SOMAXCONN); ASSERT(res = 0, 102); NEW(tcplistener); tcplistener.sock := sock; namelen := SIZE(Net.sockaddr_in); res := Net.getsockname(sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(res = 0, 103); MakeAdr(adr, tcplistener.localAdr); l := tcplistener; res := CommStreams.done ELSE res := CommStreams.localAdrInUse END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END END NewListener; (* Stream *) PROCEDURE (s: Stream) RemoteAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(s.remoteAdr) END RemoteAdr; PROCEDURE (s: Stream) IsConnected (): BOOLEAN; (* Give an educated guess on whether the peer has closed the connection. *) (* This is not a guarantee that data sent on s will arrive at the peer. *) VAR timeout: Net.timeval; set: Net.fd_set; n, res, avail: INTEGER; BEGIN IF s.sock = INVALID_SOCKET THEN RETURN FALSE ELSE timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, set, NIL, NIL, timeout); ASSERT(n # SOCKET_ERROR, 100); IF n = 1 THEN (* a recv on s.sock would not block; find out whether there is data queued *) res := Ioctl.ioctl1(s.sock, Ioctl.FIONREAD, avail); ASSERT(res = 0, 101); (* if there is data queued, we assume the socket is still open. if no data is queued, then we know that a recv can only return with zero bytes read, telling us that the socket has been closed. *) RETURN avail > 0 ELSE (* a recv on s.sock would block, so the peer has not closed the socket yet or the connect failed entirely *) timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, NIL, NIL, set, timeout); ASSERT(n # SOCKET_ERROR, 102); IF n = 1 THEN s.Close END; RETURN n = 0 END END END IsConnected; PROCEDURE (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); written := Net.send(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, Net.MSG_NOSIGNAL); IF written = SOCKET_ERROR THEN res := Errno(); IF (res # Libc.EAGAIN) & (res # Libc.ENOTCONN) THEN Error("send()", res) END; written := 0 END END WriteBytes; PROCEDURE (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); read := Net.recv(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, {}); IF read = SOCKET_ERROR THEN res := Errno(); IF (res = Libc.EAGAIN) OR (res = Libc.ENOTCONN) THEN read := 0 (* there is nothing to be read *) ELSIF res = Libc.ECONNRESET THEN read := 0; s.Close (* prevent trap *) ELSE Error("recv()", res); read := 0; s.Close END END END ReadBytes; PROCEDURE (s: Stream) Close; VAR res: INTEGER; BEGIN res := Libc.close(s.sock); s.sock := INVALID_SOCKET END Close; PROCEDURE (s: Stream) FINALIZE-; BEGIN IF s.sock # INVALID_SOCKET THEN s.Close END END FINALIZE; PROCEDURE CreateStream ( OUT s: CommStreams.Stream; sock: Net.SOCKET; IN remoteAdr: ARRAY OF CHAR ); VAR stream: Stream; BEGIN NEW(stream); stream.sock := sock; NEW(stream.remoteAdr, LEN(remoteAdr$)+1); stream.remoteAdr^ := remoteAdr$; s := stream END CreateStream; PROCEDURE NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); (* localAdr may contain a port number *) (* remoteAdr must contain an address in the format ( ip-address | hostname ) [ ":" portnumber ] *) VAR adr: Net.sockaddr_in; rpeername, lpeername: ARRAY 64 OF CHAR; inaddr: Net.in_addr; lport, rport: INTEGER; ok: BOOLEAN; sock: Net.SOCKET; BEGIN s := NIL; ParseAdr(remoteAdr, rpeername, rport, ok); IF ok THEN sock := Net.socket(Net.PF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); IF sock # INVALID_SOCKET THEN ParseLocalAdr(localAdr, lpeername, lport, ok); IF ok & (lport >= 0) THEN (* only non-negative port numbers are legal *) adr.sin_family := Net.PF_INET; adr.sin_port := Net.htons(SHORT(lport)); NameToAdr(lpeername, adr.sin_addr, ok); res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN NameToAdr(rpeername, inaddr, ok); IF ok THEN adr.sin_family := Net.PF_INET; adr.sin_port := Net.htons(SHORT(rport)); adr.sin_addr := inaddr; res := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, res); (* set to non-blocking mode *) ASSERT(res = 0, 101); res := Net.connect(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE res := Errno(); IF res = Libc.EINPROGRESS THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE Error("connect()", res); res := Libc.close(sock); res := hostSpecificError END END ELSE res := Libc.close(sock); res := CommStreams.invalidRemoteAdr END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END ELSE Error("socket()", Errno()); res := hostSpecificError END ELSE res := CommStreams.invalidRemoteAdr END END NewStream; PROCEDURE (hook: Hook) NewListener* ( localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER ); BEGIN NewListener(localAdr, l, res) END NewListener; PROCEDURE (hook: Hook) NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); BEGIN NewStream(localAdr, remoteAdr, s, res) END NewStream; BEGIN NEW(hook); CommTCP.SetHook(hook); debug := FALSE END CommTCP__Lin.

Comm/Mod/TCP__Lin.odc

MODULE CommTCP__Obsd; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "see the CommStreams documentation for details on the semantics of this driver module" changes = " - 20070130, bh, Winsock replaced by WinNet " issues = " - ... " **) (* A. V. Shiryaev, 2012.11, 2016.11: OpenBSD CommTCP Based on 1.6 Windows CommTCP *) IMPORT SYSTEM, Libc := ObsdLibc, Net := ObsdNet, Ioctl := ObsdIoctl, Strings, Dialog, CommStreams, CommTCP; CONST hostSpecificError = -1; (* host-specific error codes *) INVALID_SOCKET = Net.INVALID_SOCKET; SOCKET_ERROR = Net.SOCKET_ERROR; TYPE Stream = POINTER TO RECORD (CommStreams.Stream) sock: Net.SOCKET; (* socket must be in non-blocking mode, otherwise recv() or send() could block *) remoteAdr: CommStreams.Adr (* remoteAdr # NIL *) END; Listener = POINTER TO RECORD (CommStreams.Listener) sock: Net.SOCKET; localAdr: CommStreams.Adr (* localAdr # NIL *) END; Hook* = POINTER TO RECORD (CommTCP.Hook) END; VAR debug*: BOOLEAN; hook: Hook; PROCEDURE Errno (): INTEGER; VAR errno: INTEGER; BEGIN SYSTEM.GET(Libc.__errno_location(), errno); RETURN errno END Errno; (* auxiliary procedures *) PROCEDURE CopyOfAdrString (a: CommStreams.Adr): CommStreams.Adr; VAR b: CommStreams.Adr; BEGIN NEW(b, LEN(a)); b := a; RETURN b END CopyOfAdrString; PROCEDURE Error (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 8 OF CHAR; BEGIN IF debug THEN CASE errno OF Libc.EINTR: s := "EINTR, interrupted system call" | Libc.EBADF: s := "EBADF, bad file descriptor" | Libc.EACCES: s := "EACCES, permission denied" | Libc.EFAULT: s := "EFAULT, bad address" | Libc.EINVAL: s := "EINVAL, invalid argument" | Libc.ENFILE: s := "ENFILE, too many open files in system" | Libc.EMFILE: s := "EMFILE, too many open files" | Libc.EPIPE: s := "EPIPE, broken pipe" | Libc.EAGAIN: s := "EAGAIN, resource temporarily unavailable" | Libc.EINPROGRESS: s := "EINPROGRESS, operation now in progress" | Libc.EALREADY: s := "EALREADY, operation already in progress" | Libc.ENOTSOCK: s := "ENOTSOCK, socket operation on non-socket" | Libc.EDESTADDRREQ: s := "EDESTADDRREQ, destination address required" | Libc.EMSGSIZE: s := "EMSGSIZE, message too long" | Libc.ENOPROTOOPT: s := "ENOPROTOOPT, protocol not available" | Libc.EPROTONOSUPPORT: s := "EPROTONOSUPPORT, protocol not supported" | Libc.EAFNOSUPPORT: s := "EAFNOSUPPORT, address family not supported by protocol family" | Libc.EADDRINUSE: s := "EADDRINUSE, address already in use" | Libc.EADDRNOTAVAIL: s := "EADDRNOTAVAIL, can't assign requested address" | Libc.ENETDOWN: s := "ENETDOWN, network is down" | Libc.ENETUNREACH: s := "ENETUNREACH, network is unreachable" | Libc.ENOBUFS: s := "ENOBUFS, no buffer space available" | Libc.EISCONN: s := "EISCONN, socket is already connected" | Libc.ENOTCONN: s := "ENOTCONN, socket is not connected" | Libc.ETIMEDOUT: s := "ETIMEDOUT, operation timed out" | Libc.ECONNREFUSED: s := "ECONNREFUSED, connection refused" | Libc.EHOSTDOWN: s := "EHOSTDOWN, host is down" | Libc.EHOSTUNREACH: s := "EHOSTUNREACH, no route to host" ELSE s := "(please look up the error number in the LinLibc symbol file and in the OpenBSD documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END Error; PROCEDURE GAIError (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 12 OF CHAR; BEGIN IF debug THEN CASE errno OF Net.EAI_ADDRFAMILY: s := "EAI_ADDRFAMILY, address family for hostname not supported" | Net.EAI_AGAIN: s := "EAI_AGAIN, temporary failure in name resolution" | Net.EAI_BADFLAGS: s := "EAI_BADFLAGS, invalid value for ai_flags" | Net.EAI_BADHINTS: s := "EAI_BADHINTS, invalid value for hints" | Net.EAI_FAIL: s := "EAI_FAIL, non-recoverable failure in name resolution" | Net.EAI_FAMILY: s := "EAI_FAMILY, ai_family not supported" | Net.EAI_MEMORY: s := "EAI_MEMORY, memory allocation failure" | Net.EAI_NODATA: s := "EAI_NODATA, no address associated with hostname" | Net.EAI_NONAME: s := "EAI_NONAME, hostname or servname not provided, or not known" | Net.EAI_OVERFLOW: s := "EAI_OVERFLOW, argument buffer overflow" | Net.EAI_PROTOCOL: s := "EAI_PROTOCOL, resolved protocol is unknown" | Net.EAI_SERVICE: s := "EAI_SERVICE, servname not supported for ai_socktype" | Net.EAI_SOCKTYPE: s := "EAI_SOCKTYPE, ai_socktype not supported" | Net.EAI_SYSTEM: s := "EAI_SYSTEM, system error returned in errno" ELSE s := "(please look up the error number in the LinNet symbol file and in the OpenBSD documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END GAIError; PROCEDURE IsIPAddress (name: ARRAY OF CHAR): BOOLEAN; (* returns TRUE iff name only contains decimal digits and "." characters *) VAR i: INTEGER; BEGIN i := 0; WHILE ("0" <= name[i]) & (name[i] <= "9") OR (name[i] = ".") DO INC(i) END; RETURN name[i] = 0X END IsIPAddress; PROCEDURE ParseAdr (adr: ARRAY OF CHAR; OUT addr: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN); (* parse address specification with syntax addr [ ":" portnumber ] *) VAR i, j, res: INTEGER; portstr: ARRAY 16 OF CHAR; BEGIN i := 0; j := 0; port := 0; ok := TRUE; WHILE (adr[i] # 0X) & (adr[i] # ":") DO IF j < LEN(addr) - 1 THEN addr[j] := adr[i]; INC(j) END; INC(i) END; ok := i = j; addr[j] := 0X; IF ok & (adr[i] = ":") THEN INC(i); j := 0; WHILE adr[i] # 0X DO portstr[j] := adr[i]; INC(i); IF j < LEN(portstr) - 1 THEN INC(j) END END; portstr[j] := 0X; Strings.StringToInt(portstr, port, res); ok := res = 0 END END ParseAdr; PROCEDURE ParseLocalAdr (IN adr: ARRAY OF CHAR; OUT peername: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN ); VAR i, res: INTEGER; BEGIN IF adr = "" THEN port := 0; peername := ""; ok := TRUE (* default port number 0 means 'don't care which port is used' *) ELSE i := 0; WHILE (adr[i] # 0X) & ((adr[i] >= "0") & (adr[i] <= "9")) OR (adr[i] = " ") DO INC(i) END; IF adr[i] # 0X THEN ParseAdr(adr, peername, port, ok) ELSE Strings.StringToInt(adr, port, res); peername := ""; ok := res = 0 END END END ParseLocalAdr; PROCEDURE NameToAdr (IN peername: ARRAY OF CHAR; VAR inaddr: Net.in_addr; OUT ok: BOOLEAN); VAR shortPName: ARRAY 64 OF SHORTCHAR; res: Net.int; result: Net.Ptraddrinfo; hints: Net.addrinfo; addr: Net.Ptrsockaddr_in; BEGIN shortPName := SHORT(peername$); IF IsIPAddress(peername) THEN IF shortPName = "" THEN inaddr.S_un.S_addr := Net.INADDR_ANY ELSE inaddr.S_un.S_addr := Net.inet_addr(shortPName) END; ok := inaddr.S_un.S_addr # Net.INADDR_NONE ELSE hints.ai_flags := {}; hints.ai_family := Net.AF_INET; hints.ai_socktype := Net.SOCK_STREAM; hints.ai_protocol := Net.IPPROTO_TCP; hints.ai_addrlen := 0; hints.ai_addr := NIL; hints.ai_canonname := NIL; hints.ai_next := NIL; res := Net.getaddrinfo(shortPName, NIL, hints, result); ok := res = 0; IF ok THEN ASSERT(result # NIL); IF (result.ai_family = Net.AF_INET) & (result.ai_socktype = Net.SOCK_STREAM) & (result.ai_protocol = Net.IPPROTO_TCP) & (result.ai_addr # NIL) THEN addr := SYSTEM.VAL(Net.Ptrsockaddr_in, result.ai_addr); inaddr := addr.sin_addr ELSE ok := FALSE END; Net.freeaddrinfo(result); ASSERT(ok) ELSE GAIError("getaddrinfo()", res) END END END NameToAdr; PROCEDURE MakeAdr (adr: Net.sockaddr_in; OUT s: CommStreams.Adr); VAR ipadr, n: INTEGER; temp, buf: ARRAY 64 OF CHAR; BEGIN ipadr := adr.sin_addr.S_un.S_addr; temp := ""; IF ipadr # 0 THEN n := ipadr MOD 256; Strings.IntToString(n, temp); n := SYSTEM.LSH(ipadr, -8); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -16); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -24); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "." + buf + ":" END; n := (adr.sin_port MOD 256) * 256 + (adr.sin_port DIV 256) MOD 256; Strings.IntToString(n, buf); temp := temp + buf; NEW(s, LEN(temp$) + 1); s^ := temp$ END MakeAdr; (* Linux, FreeBSD, OpenBSD, 32-bit *) PROCEDURE FD_ZERO (VAR set: Net.fd_set); VAR i: INTEGER; BEGIN i := LEN(set); REPEAT DEC(i); set[i] := {} UNTIL i = 0 END FD_ZERO; PROCEDURE FD_SET (fd: Net.SOCKET; VAR set: Net.fd_set); BEGIN INCL(set[fd DIV 32], fd MOD 32) END FD_SET; PROCEDURE MakeFdSet (socket: Net.SOCKET; OUT set: Net.fd_set); BEGIN FD_ZERO(set); FD_SET(socket, set) END MakeFdSet; (* Listener *) PROCEDURE (l: Listener) LocalAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(l.localAdr) END LocalAdr; PROCEDURE (l: Listener) Accept (OUT s: CommStreams.Stream); VAR timeout: Net.timeval; set: Net.fd_set; res, namelen: INTEGER; sock: Net.SOCKET; tcpstream: Stream; adr: Net.sockaddr_storage; BEGIN timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(l.sock, set); res := Net.select(l.sock + 1, set, NIL, NIL, timeout); ASSERT(res # SOCKET_ERROR, 100); IF res > 0 THEN namelen := SIZE(Net.sockaddr_storage); sock := Net.accept(l.sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(sock # INVALID_SOCKET, 101); namelen := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, namelen); (* set to non-blocking mode *) ASSERT(res = 0, 102); NEW(tcpstream); tcpstream.sock := sock; MakeAdr(SYSTEM.VAL(Net.sockaddr_in, adr), tcpstream.remoteAdr); s := tcpstream END END Accept; PROCEDURE (l: Listener) Close; VAR res: INTEGER; BEGIN IF l.sock # INVALID_SOCKET THEN res := Libc.close(l.sock); l.sock := INVALID_SOCKET END END Close; PROCEDURE (l: Listener) FINALIZE-; BEGIN WITH l: Listener DO IF l.sock # INVALID_SOCKET THEN l.Close END END END FINALIZE; PROCEDURE NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER); (* localAdr must contain a port number *) CONST SOMAXCONN = 5; (* use default length of listener backlog queue *) VAR portnr, namelen, optval: INTEGER; ok: BOOLEAN; tcplistener: Listener; adr: Net.sockaddr_in; sock: Net.SOCKET; peername: ARRAY 64 OF CHAR; BEGIN l := NIL; ParseLocalAdr(localAdr, peername, portnr, ok); IF ok & (portnr >= 0) THEN (* only non-negative port numbers are legal *) sock := Net.socket(Net.AF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); ASSERT(sock # INVALID_SOCKET, 100); optval := 1; res := Net.setsockopt(sock, Net.SOL_SOCKET, Net.SO_REUSEADDR, SYSTEM.ADR(optval), SIZE(INTEGER)); ASSERT(res = 0, 101); adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(portnr)); NameToAdr(peername, adr.sin_addr, ok); IF ok THEN res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN res := Net.listen(sock, SOMAXCONN); ASSERT(res = 0, 102); NEW(tcplistener); tcplistener.sock := sock; namelen := SIZE(Net.sockaddr_in); res := Net.getsockname(sock, SYSTEM.VAL(Net.sockaddr, adr), namelen); ASSERT(res = 0, 103); MakeAdr(adr, tcplistener.localAdr); l := tcplistener; res := CommStreams.done ELSE res := CommStreams.localAdrInUse END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END END NewListener; (* Stream *) PROCEDURE (s: Stream) RemoteAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(s.remoteAdr) END RemoteAdr; PROCEDURE (s: Stream) IsConnected (): BOOLEAN; (* Give an educated guess on whether the peer has closed the connection. *) (* This is not a guarantee that data sent on s will arrive at the peer. *) VAR timeout: Net.timeval; set: Net.fd_set; n, res, avail: INTEGER; BEGIN IF s.sock = INVALID_SOCKET THEN RETURN FALSE ELSE timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, set, NIL, NIL, timeout); ASSERT(n # SOCKET_ERROR, 100); IF n = 1 THEN (* a recv on s.sock would not block; find out whether there is data queued *) res := Ioctl.ioctl1(s.sock, Ioctl.FIONREAD, avail); ASSERT(res = 0, 101); (* if there is data queued, we assume the socket is still open. if no data is queued, then we know that a recv can only return with zero bytes read, telling us that the socket has been closed. *) RETURN avail > 0 ELSE (* a recv on s.sock would block, so the peer has not closed the socket yet or the connect failed entirely *) timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := Net.select(s.sock + 1, NIL, NIL, set, timeout); ASSERT(n # SOCKET_ERROR, 102); IF n = 1 THEN s.Close END; RETURN n = 0 END END END IsConnected; PROCEDURE (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); written := Net.send(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, Net.MSG_NOSIGNAL); IF written = SOCKET_ERROR THEN res := Errno(); IF (res # Libc.EAGAIN) & (res # Libc.ENOTCONN) THEN Error("send()", res) END; written := 0 END END WriteBytes; PROCEDURE (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); read := Net.recv(s.sock, SYSTEM.VAL(Libc.PtrVoid, SYSTEM.ADR(x) + beg), len, {}); IF read = SOCKET_ERROR THEN res := Errno(); IF (res = Libc.EAGAIN) OR (res = Libc.ENOTCONN) THEN read := 0 (* there is nothing to be read *) ELSIF res = Libc.ECONNRESET THEN read := 0; s.Close (* prevent trap *) ELSE Error("recv()", res); read := 0; s.Close END END END ReadBytes; PROCEDURE (s: Stream) Close; VAR res: INTEGER; BEGIN res := Libc.close(s.sock); s.sock := INVALID_SOCKET END Close; PROCEDURE (s: Stream) FINALIZE-; BEGIN IF s.sock # INVALID_SOCKET THEN s.Close END END FINALIZE; PROCEDURE CreateStream ( OUT s: CommStreams.Stream; sock: Net.SOCKET; IN remoteAdr: ARRAY OF CHAR ); VAR stream: Stream; BEGIN NEW(stream); stream.sock := sock; NEW(stream.remoteAdr, LEN(remoteAdr$)+1); stream.remoteAdr^ := remoteAdr$; s := stream END CreateStream; PROCEDURE NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); (* localAdr may contain a port number *) (* remoteAdr must contain an address in the format ( ip-address | hostname ) [ ":" portnumber ] *) VAR adr: Net.sockaddr_in; rpeername, lpeername: ARRAY 64 OF CHAR; inaddr: Net.in_addr; lport, rport: INTEGER; ok: BOOLEAN; sock: Net.SOCKET; BEGIN s := NIL; ParseAdr(remoteAdr, rpeername, rport, ok); IF ok THEN sock := Net.socket(Net.AF_INET, Net.SOCK_STREAM, Net.IPPROTO_TCP); IF sock # INVALID_SOCKET THEN ParseLocalAdr(localAdr, lpeername, lport, ok); IF ok & (lport >= 0) THEN (* only non-negative port numbers are legal *) adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(lport)); NameToAdr(lpeername, adr.sin_addr, ok); res := Net.bind(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN NameToAdr(rpeername, inaddr, ok); IF ok THEN adr.sin_family := SHORT(CHR(Net.AF_INET)); adr.sin_port := Net.htons(SHORT(rport)); adr.sin_addr := inaddr; res := 1; (* = 'true' *) res := Ioctl.ioctl1(sock, Ioctl.FIONBIO, res); (* set to non-blocking mode *) ASSERT(res = 0, 101); res := Net.connect(sock, SYSTEM.VAL(Net.sockaddr, adr), SIZE(Net.sockaddr_in)); IF res = 0 THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE res := Errno(); IF res = Libc.EINPROGRESS THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE Error("connect()", res); res := Libc.close(sock); res := hostSpecificError END END ELSE res := Libc.close(sock); res := CommStreams.invalidRemoteAdr END ELSE res := Libc.close(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END ELSE Error("socket()", Errno()); res := hostSpecificError END ELSE res := CommStreams.invalidRemoteAdr END END NewStream; PROCEDURE (hook: Hook) NewListener* ( localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER ); BEGIN NewListener(localAdr, l, res) END NewListener; PROCEDURE (hook: Hook) NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); BEGIN NewStream(localAdr, remoteAdr, s, res) END NewStream; BEGIN NEW(hook); CommTCP.SetHook(hook); debug := TRUE END CommTCP__Obsd.

Comm/Mod/TCP__Obsd.odc

MODULE CommTCP__Win; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" references = "see the CommStreams documentation for details on the semantics of this driver module" changes = " - 20070130, bh, Winsock replaced by WinNet - 20151013, center #78, fixing type of WinNet.hostent.h_addr_list - 20151028, center #81, supporting empty localAdr in CommTCP " issues = " - ... " **) IMPORT SYSTEM, WinApi, WinNet, Strings, Dialog, CommStreams, CommTCP; CONST hostSpecificError = -1; (* host-specific error codes *) INVALID_SOCKET = WinNet.INVALID_SOCKET; SOCKET_ERROR = WinNet.SOCKET_ERROR; FIONREAD = WinNet.IOC_OUT + 00040000H + ASH(ORD("f"), 8) + 127; (* get # bytes to read *) FIONBIO = WinNet.IOC_IN + 00040000H + ASH(ORD("f"), 8) + 126; (* set/clear non-blocking i/o *) FIOASYNC = WinNet.IOC_IN + 00040000H + ASH(ORD("f"), 8) + 125; (* set/clear async i/o *) localhost = "127.0.0.1"; TYPE Stream = POINTER TO RECORD (CommStreams.Stream) sock: WinNet.SOCKET; (* socket must be in non-blocking mode, otherwise recv() or send() could block *) remoteAdr: CommStreams.Adr (* remoteAdr # NIL *) END; Listener = POINTER TO RECORD (CommStreams.Listener) sock: WinNet.SOCKET; localAdr: CommStreams.Adr (* localAdr # NIL *) END; Hook* = POINTER TO RECORD (CommTCP.Hook) END; VAR winSockInstalled: BOOLEAN; (* WinSockets API successfully initialized? *) debug*: BOOLEAN; hook: Hook; (* auxiliary procedures *) PROCEDURE CopyOfAdrString (a: CommStreams.Adr): CommStreams.Adr; VAR b: CommStreams.Adr; BEGIN NEW(b, LEN(a)); b^ := a$; RETURN b END CopyOfAdrString; PROCEDURE Error (msg: ARRAY OF CHAR; errno: INTEGER); VAR s: ARRAY 128 OF CHAR; errnostr: ARRAY 8 OF CHAR; BEGIN IF debug THEN CASE errno OF WinNet.WSASYSNOTREADY: s := "WSASYSNOTREADY, network subsystem is unavailable" | WinNet.WSAVERNOTSUPPORTED: s := "WSAVERNOTSUPPORTED, WINSOCK.DLL version out of range" | WinNet.WSAEINVAL: s := "WSAEINVAL, invalid argument" | WinNet.WSAETIMEDOUT: s := "WSAETIMEDOUT, connection timed out" | WinNet.WSAECONNREFUSED: s := "WSAECONNREFUSED, connection refused" | WinNet.WSAEADDRNOTAVAIL: s := "WSAEADDRNOTAVAIL, cannot assign requested address" ELSE s := "(please look up the error number in the WinNet symbol file and in the Microsoft documentation)" END; Strings.IntToString(errno, errnostr); Dialog.ShowParamMsg("^0: error ^1 (^2)", msg, errnostr, s) END END Error; PROCEDURE IsIPAddress (name: ARRAY OF CHAR): BOOLEAN; (* returns TRUE iff name only contains decimal digits and "." characters *) VAR i: INTEGER; BEGIN i := 0; WHILE ("0" <= name[i]) & (name[i] <= "9") OR (name[i] = ".") DO INC(i) END; RETURN name[i] = 0X END IsIPAddress; PROCEDURE ParseAdr (adr: ARRAY OF CHAR; OUT addr: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN); (* parse address specification with syntax addr [ ":" portnumber ] *) VAR i, j, res: INTEGER; portstr: ARRAY 16 OF CHAR; BEGIN i := 0; j := 0; port := 0; ok := TRUE; WHILE (adr[i] # 0X) & (adr[i] # ":") DO IF j < LEN(addr) - 1 THEN addr[j] := adr[i]; INC(j) END; INC(i) END; ok := i = j; addr[j] := 0X; IF ok & (adr[i] = ":") THEN INC(i); j := 0; WHILE adr[i] # 0X DO portstr[j] := adr[i]; INC(i); IF j < LEN(portstr) - 1 THEN INC(j) END END; portstr[j] := 0X; Strings.StringToInt(portstr, port, res); ok := res = 0 END END ParseAdr; PROCEDURE ParseLocalAdr (IN adr: ARRAY OF CHAR; OUT peername: ARRAY OF CHAR; OUT port: INTEGER; OUT ok: BOOLEAN ); VAR i, res: INTEGER; BEGIN IF adr = "" THEN port := 0; peername := localhost; ok := TRUE (* default port number 0 means 'don't care which port is used' *) ELSE i := 0; WHILE (adr[i] # 0X) & ((adr[i] >= "0") & (adr[i] <= "9")) OR (adr[i] = " ") DO INC(i) END; IF adr[i] # 0X THEN ParseAdr(adr, peername, port, ok) ELSE Strings.StringToInt(adr, port, res); peername := localhost; ok := res = 0 END END END ParseLocalAdr; PROCEDURE NameToAdr (IN peername: ARRAY OF CHAR; VAR inaddr: WinNet.in_addr; OUT ok: BOOLEAN); VAR hostentry: WinNet.Ptrhostent; shortPName: ARRAY 64 OF SHORTCHAR; BEGIN shortPName := SHORT(peername$); IF IsIPAddress(peername) THEN inaddr.S_un.S_addr := WinNet.inet_addr(shortPName); ok := inaddr.S_un.S_addr # WinNet.INADDR_NONE ELSE hostentry := WinNet.gethostbyname(shortPName); ok := hostentry # NIL; IF ok THEN inaddr := SYSTEM.VAL(WinNet.in_addr, hostentry.h_addr_list^[0]^) ELSE Error("gethostbyname()", WinNet.WSAGetLastError()) END END END NameToAdr; PROCEDURE MakeAdr (adr: WinNet.sockaddr_in; OUT s: CommStreams.Adr); VAR ipadr, n: INTEGER; temp, buf: ARRAY 64 OF CHAR; BEGIN ipadr := adr.sin_addr.S_un.S_addr; temp := ""; IF ipadr # 0 THEN n := ipadr MOD 256; Strings.IntToString(n, temp); n := SYSTEM.LSH(ipadr, -8); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -16); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "."+ buf; n := SYSTEM.LSH(ipadr, -24); n := n MOD 256; Strings.IntToString(n, buf); temp := temp + "." + buf + ":" END; n := (adr.sin_port MOD 256) * 256 + (adr.sin_port DIV 256) MOD 256; Strings.IntToString(n, buf); temp := temp + buf; NEW(s, LEN(temp$) + 1); s^ := temp$ END MakeAdr; PROCEDURE MakeFdSet (socket: WinNet.SOCKET; OUT set: WinNet.fd_set); BEGIN set.fd_count := 1; set.fd_array[0] := socket END MakeFdSet; (* Listener *) PROCEDURE (l: Listener) LocalAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(l.localAdr) END LocalAdr; PROCEDURE (l: Listener) Accept (OUT s: CommStreams.Stream); VAR timeout: WinNet.timeval; set: WinNet.fd_set; res, namelen: INTEGER; sock: WinNet.SOCKET; tcpstream: Stream; inadr: WinNet.sockaddr_in; BEGIN timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(l.sock, set); res := WinNet.select(0, set, NIL, NIL, timeout); ASSERT(res # SOCKET_ERROR, 100); IF res > 0 THEN namelen := SIZE(WinNet.sockaddr_in); sock := WinNet.accept(l.sock, SYSTEM.VAL(WinNet.sockaddr, inadr), namelen); ASSERT(sock # INVALID_SOCKET, 101); namelen := 1; (* = 'true' *) res := WinNet.ioctlsocket(sock, FIONBIO, namelen); (* set to non-blocking mode *) ASSERT(res = 0, 102); NEW(tcpstream); tcpstream.sock := sock; MakeAdr(inadr, tcpstream.remoteAdr); s := tcpstream END END Accept; PROCEDURE (l: Listener) Close; VAR res: INTEGER; BEGIN IF l.sock # INVALID_SOCKET THEN res := WinNet.closesocket(l.sock); l.sock := INVALID_SOCKET END END Close; PROCEDURE (l: Listener) FINALIZE-; BEGIN WITH l: Listener DO IF l.sock # INVALID_SOCKET THEN l.Close END END END FINALIZE; PROCEDURE NewListener* (localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER); (* localAdr must contain a port number *) CONST SOMAXCONN = 5; (* use default length of listener backlog queue *) VAR portnr, namelen: INTEGER; ok: BOOLEAN; tcplistener: Listener; adr: WinNet.sockaddr_in; sock: WinNet.SOCKET; peername: ARRAY 64 OF CHAR; BEGIN l := NIL; IF winSockInstalled THEN ParseLocalAdr(localAdr, peername, portnr, ok); IF ok & (portnr >= 0) THEN (* only non-negative port numbers are legal *) sock := WinNet.socket(WinNet.PF_INET, WinNet.SOCK_STREAM, WinNet.IPPROTO_TCP); ASSERT(sock # INVALID_SOCKET, 100); adr.sin_family := WinNet.PF_INET; adr.sin_port := WinNet.htons(SHORT(portnr)); NameToAdr(peername, adr.sin_addr, ok); IF ok THEN res := WinNet.bind(sock, SYSTEM.VAL(WinNet.sockaddr, adr), SIZE(WinNet.sockaddr_in)); IF res = 0 THEN res := WinNet.listen(sock, SOMAXCONN); ASSERT(res = 0, 102); NEW(tcplistener); tcplistener.sock := sock; namelen := SIZE(WinNet.sockaddr_in); res := WinNet.getsockname(sock, SYSTEM.VAL(WinNet.sockaddr, adr), namelen); ASSERT(res = 0, 103); MakeAdr(adr, tcplistener.localAdr); l := tcplistener; res := CommStreams.done ELSE res := CommStreams.localAdrInUse END ELSE res := WinNet.closesocket(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.networkDown END END NewListener; (* Stream *) PROCEDURE (s: Stream) RemoteAdr (): CommStreams.Adr; BEGIN RETURN CopyOfAdrString(s.remoteAdr) END RemoteAdr; PROCEDURE (s: Stream) IsConnected (): BOOLEAN; (* Give an educated guess on whether the peer has closed the connection. *) (* This is not a guarantee that data sent on s will arrive at the peer. *) VAR timeout: WinNet.timeval; set: WinNet.fd_set; n, res, avail: INTEGER; BEGIN IF s.sock = INVALID_SOCKET THEN RETURN FALSE ELSE timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := WinNet.select(0, set, NIL, NIL, timeout); ASSERT(n # SOCKET_ERROR, 100); IF n = 1 THEN (* a recv on s.sock would not block; find out whether there is data queued *) res := WinNet.ioctlsocket(s.sock, FIONREAD, avail); ASSERT(res = 0, 101); (* if there is data queued, we assume the socket is still open. if no data is queued, then we know that a recv can only return with zero bytes read, telling us that the socket has been closed. *) RETURN avail > 0 ELSE (* a recv on s.sock would block, so the peer has not closed the socket yet or the connect failed entirely *) timeout.tv_sec := 0; timeout.tv_usec := 0; MakeFdSet(s.sock, set); n := WinNet.select(0, NIL, NIL, set, timeout); ASSERT(n # SOCKET_ERROR, 102); IF n = 1 THEN s.Close END; RETURN n = 0 END END END IsConnected; PROCEDURE (s: Stream) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER; OUT written: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); written := WinNet.send(s.sock, SYSTEM.VAL(WinApi.PtrSTR, SYSTEM.ADR(x) + beg), len, {}); IF written = SOCKET_ERROR THEN res := WinNet.WSAGetLastError(); IF (res # WinNet.WSAEWOULDBLOCK) & (res # WinNet.WSAENOTCONN) THEN Error("send()", res) END; written := 0 END END WriteBytes; PROCEDURE (s: Stream) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER; OUT read: INTEGER); VAR res: INTEGER; BEGIN ASSERT(beg >= 0, 20); ASSERT(len > 0, 21); ASSERT(LEN(x) >= beg + len, 22); read := WinNet.recv(s.sock, SYSTEM.VAL(WinApi.PtrSTR, SYSTEM.ADR(x) + beg), len, {}); IF read = SOCKET_ERROR THEN res := WinNet.WSAGetLastError(); IF (res = WinNet.WSAEWOULDBLOCK) OR (res = WinNet.WSAENOTCONN) THEN read := 0 (* there is nothing to be read *) ELSIF res = WinNet.WSAECONNRESET THEN read := 0; s.Close (* prevent trap *) ELSE Error("recv()", res); read := 0; s.Close END END END ReadBytes; PROCEDURE (s: Stream) Close; VAR res: INTEGER; BEGIN res := WinNet.closesocket(s.sock); s.sock := INVALID_SOCKET END Close; PROCEDURE (s: Stream) FINALIZE-; BEGIN IF s.sock # INVALID_SOCKET THEN s.Close END END FINALIZE; PROCEDURE CreateStream ( OUT s: CommStreams.Stream; sock: WinNet.SOCKET; IN remoteAdr: ARRAY OF CHAR ); VAR stream: Stream; BEGIN NEW(stream); stream.sock := sock; NEW(stream.remoteAdr, LEN(remoteAdr$)+1); stream.remoteAdr^ := remoteAdr$; s := stream END CreateStream; PROCEDURE NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); (* localAdr may contain a port number *) (* remoteAdr must contain an address in the format ( ip-address | hostname ) [ ":" portnumber ] *) VAR adr: WinNet.sockaddr_in; rpeername, lpeername: ARRAY 64 OF CHAR; inaddr: WinNet.in_addr; lport, rport: INTEGER; ok: BOOLEAN; sock: WinNet.SOCKET; BEGIN s := NIL; IF winSockInstalled THEN ParseAdr(remoteAdr, rpeername, rport, ok); IF ok THEN sock := WinNet.socket(WinNet.PF_INET, WinNet.SOCK_STREAM, WinNet.IPPROTO_TCP); IF sock # INVALID_SOCKET THEN ParseLocalAdr(localAdr, lpeername, lport, ok); IF ok & (lport >= 0) THEN (* only non-negative port numbers are legal *) adr.sin_family := WinNet.PF_INET; adr.sin_port := WinNet.htons(SHORT(lport)); NameToAdr(lpeername, adr.sin_addr, ok); res := WinNet.bind(sock, SYSTEM.VAL(WinNet.sockaddr, adr), SIZE(WinNet.sockaddr_in)); IF res = 0 THEN NameToAdr(rpeername, inaddr, ok); IF ok THEN adr.sin_family := WinNet.PF_INET; adr.sin_port := WinNet.htons(SHORT(rport)); adr.sin_addr := inaddr; res := 1; (* = 'true' *) res := WinNet.ioctlsocket(sock, FIONBIO, res); (* set to non-blocking mode *) ASSERT(res = 0, 101); res := WinNet.connect(sock, SYSTEM.VAL(WinNet.sockaddr, adr), SIZE(WinNet.sockaddr_in)); IF res = 0 THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE res := WinNet.WSAGetLastError(); IF res = WinNet.WSAEWOULDBLOCK THEN CreateStream(s, sock, remoteAdr); res := CommStreams.done ELSE Error("connect()", res); res := WinNet.closesocket(sock); res := hostSpecificError END END ELSE res := WinNet.closesocket(sock); res := CommStreams.invalidRemoteAdr END ELSE res := WinNet.closesocket(sock); res := CommStreams.invalidLocalAdr END ELSE res := CommStreams.invalidLocalAdr END ELSE Error("socket()", WinNet.WSAGetLastError()); res := hostSpecificError END ELSE res := CommStreams.invalidRemoteAdr END ELSE res := CommStreams.networkDown END END NewStream; PROCEDURE Init; CONST version = 00000101H; VAR data: WinNet.WSADATA; ret: INTEGER; BEGIN debug := TRUE; winSockInstalled := FALSE; ret := WinNet.WSAStartup(version, data); IF ret = 0 THEN winSockInstalled := TRUE ELSE Error("WSAStartup()", ret) END; debug := FALSE END Init; PROCEDURE Close; VAR ret: INTEGER; BEGIN ret := WinNet.WSACleanup() END Close; PROCEDURE (hook: Hook) NewListener* ( localAdr: ARRAY OF CHAR; OUT l: CommStreams.Listener; OUT res: INTEGER ); BEGIN NewListener(localAdr, l, res) END NewListener; PROCEDURE (hook: Hook) NewStream* ( localAdr, remoteAdr: ARRAY OF CHAR; OUT s: CommStreams.Stream; OUT res: INTEGER ); BEGIN NewStream(localAdr, remoteAdr, s, res) END NewStream; BEGIN Init; NEW(hook); CommTCP.SetHook(hook); CLOSE Close END CommTCP__Win.

Comm/Mod/TCP__Win.odc

MODULE CommV24; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems, Alexander Iljin, Ivan Denisov" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20130423, dia, remove ASSERT(100) from Available to prevent error for USB2COM devices - 20070205, bh, Unicode support - 20061007, ai, Deleted ASSERT(101) from procedure Available. - 20060916, ai, Added inDTRon, inRTSon support. - 20060916, ai, Some parameter restrictions enforced with ASSERTs. Added IsConnected. " issues = " - this module was not decomposed into two modules, like CommStreams/CommTCP; for better consistency, this should be corrected " **) IMPORT Kernel, Dialog; CONST bits4* = 0; bits5* = 1; bits6* = 2; bits7* = 3; stop15* = 4; stop2* = 5; even* = 6; odd* = 7; inXonXoff* = 8; outXonXoff* = 9; inRTS* = 10; inDTR* = 11; outCTS* = 12; outDSR* = 13; inDTRon* = 14; inRTSon* = 15; nonblocking* = 31; TYPE Hook* = POINTER TO ABSTRACT RECORD END; Connection* = POINTER TO EXTENSIBLE RECORD END; VAR hook: Hook; isLastSendDone*: BOOLEAN; PROCEDURE SetHook* (h: Hook); BEGIN hook := h END SetHook; PROCEDURE (h: Hook) IsConnected* (c: Connection): BOOLEAN, NEW, ABSTRACT; PROCEDURE (h: Hook) Open* (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: Connection), NEW, ABSTRACT; PROCEDURE (h: Hook) Close* (c: Connection), NEW, ABSTRACT; PROCEDURE (h: Hook) SendByte* (c: Connection; x: BYTE), NEW, ABSTRACT; PROCEDURE (h: Hook) SendBytes* (c: Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER), NEW, ABSTRACT; PROCEDURE (h: Hook) Available* (c: Connection): INTEGER, NEW, ABSTRACT; PROCEDURE (h: Hook) ReceiveByte* (c: Connection; OUT x: BYTE), NEW, ABSTRACT; PROCEDURE (h: Hook) ReceiveBytes* (c: Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER), NEW, ABSTRACT; PROCEDURE (h: Hook) SetBuffers* (c: Connection; inpBufSize, outBufSize: INTEGER), NEW, ABSTRACT; PROCEDURE (h: Hook) SetDTR* (c: Connection; on: BOOLEAN), NEW, EMPTY; PROCEDURE (h: Hook) SetRTS* (c: Connection; on: BOOLEAN), NEW, EMPTY; PROCEDURE (h: Hook) SetBreak* (c: Connection; on: BOOLEAN), NEW, ABSTRACT; PROCEDURE (h: Hook) CTSState* (c: Connection): BOOLEAN, NEW, ABSTRACT; PROCEDURE (h: Hook) DSRState* (c: Connection): BOOLEAN, NEW, ABSTRACT; PROCEDURE (h: Hook) CDState* (c: Connection): BOOLEAN, NEW, ABSTRACT; PROCEDURE IsConnected* (c: Connection): BOOLEAN; BEGIN ASSERT(c # NIL, 20); RETURN hook.IsConnected(c) END IsConnected; PROCEDURE Open* (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: Connection); BEGIN hook.Open(device, baud, opts, conn) END Open; PROCEDURE Close* (c: Connection); BEGIN hook.Close(c) END Close; PROCEDURE SendByte* (c: Connection; x: BYTE); BEGIN hook.SendByte(c, x) END SendByte; PROCEDURE SendBytes* (c: Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER); BEGIN hook.SendBytes(c, x, beg, len) END SendBytes; PROCEDURE Available* (c: Connection): INTEGER; BEGIN RETURN hook.Available(c) END Available; PROCEDURE ReceiveByte* (c: Connection; OUT x: BYTE); BEGIN hook.ReceiveByte(c, x) END ReceiveByte; PROCEDURE ReceiveBytes* (c: Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER); BEGIN hook.ReceiveBytes(c, x, beg, len) END ReceiveBytes; PROCEDURE SetBuffers* (c: Connection; inpBufSize, outBufSize: INTEGER); BEGIN hook.SetBuffers(c, inpBufSize, outBufSize) END SetBuffers; PROCEDURE SetDTR* (c: Connection; on: BOOLEAN); BEGIN hook.SetDTR(c, on) END SetDTR; PROCEDURE SetRTS* (c: Connection; on: BOOLEAN); BEGIN hook.SetRTS(c, on) END SetRTS; PROCEDURE SetBreak* (c: Connection; on: BOOLEAN); BEGIN hook.SetBreak(c, on) END SetBreak; PROCEDURE CTSState* (c: Connection): BOOLEAN; BEGIN RETURN hook.CTSState(c) END CTSState; PROCEDURE DSRState* (c: Connection): BOOLEAN; BEGIN RETURN hook.DSRState(c) END DSRState; PROCEDURE CDState* (c: Connection): BOOLEAN; BEGIN RETURN hook.CDState(c) END CDState; BEGIN IF Dialog.platform = Dialog.windows THEN Kernel.LoadMod("CommV24__Win") ELSIF Dialog.platform = Dialog.linux THEN Kernel.LoadMod("CommV24__Lin") ELSIF Dialog.platform = Dialog.openbsd THEN Kernel.LoadMod("CommV24__Obsd") END END CommV24.

Comm/Mod/V24.odc

MODULE CommV24__Lin; (* A. V. Shiryaev, 2012.11 Linux, OpenBSD 32-bit Interface corresponds to original BlackBox 1.6 CommV24 *) IMPORT SYSTEM, Libc := LinLibc, Termios := LinTermios, Ioctl := LinIoctl, CommV24; CONST bits4* = 0; bits5* = 1; bits6* = 2; bits7* = 3; stop15* = 4; stop2* = 5; even* = 6; odd* = 7; inXonXoff* = 8; outXonXoff* = 9; inRTS* = 10; inDTR* = 11; outCTS* = 12; outDSR* = 13; nonblocking* = 31; TYPE Hook* = POINTER TO RECORD (CommV24.Hook) END; Connection* = POINTER TO RECORD (CommV24.Connection) hnd: INTEGER; (* # -1: open *) opts: SET END; VAR hook: Hook; PROCEDURE DecodeBaud (baud: INTEGER; OUT speed: Termios.speed_t); BEGIN IF baud = 50 THEN speed := Termios.B50 ELSIF baud = 75 THEN speed := Termios.B75 ELSIF baud = 110 THEN speed := Termios.B110 ELSIF baud = 134 THEN speed := Termios.B134 ELSIF baud = 150 THEN speed := Termios.B150 ELSIF baud = 200 THEN speed := Termios.B200 ELSIF baud = 300 THEN speed := Termios.B300 ELSIF baud = 600 THEN speed := Termios.B600 ELSIF baud = 1200 THEN speed := Termios.B1200 ELSIF baud = 1800 THEN speed := Termios.B1800 ELSIF baud = 2400 THEN speed := Termios.B2400 ELSIF baud = 4800 THEN speed := Termios.B4800 (* ELSIF baud = 7200 THEN speed := Termios.B7200 *) (* not present in Linux *) ELSIF baud = 9600 THEN speed := Termios.B9600 (* ELSIF baud = 14400 THEN speed := Termios.B14400 *) (* not present in Linux *) ELSIF baud = 19200 THEN speed := Termios.B19200 (* ELSIF baud = 28800 THEN speed := Termios.B28800 *) (* not present in Linux *) ELSIF baud = 38400 THEN speed := Termios.B38400 ELSIF baud = 57600 THEN speed := Termios.B57600 (* ELSIF baud = 76800 THEN speed := Termios.B76800 *) (* not present in Linux *) ELSIF baud = 115200 THEN speed := Termios.B115200 ELSIF baud = 230400 THEN speed := Termios.B230400 ELSE HALT(100) END END DecodeBaud; PROCEDURE (hook: Hook) IsConnected* (c: CommV24.Connection): BOOLEAN; BEGIN ASSERT(c # NIL, 20); RETURN (c(Connection).hnd # 0) & (c(Connection).hnd # -1) END IsConnected; PROCEDURE (hook: Hook) Open* (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: CommV24.Connection); VAR c: Connection; fd: INTEGER; ss: ARRAY Libc.NAME_MAX + 1 OF SHORTCHAR; res: INTEGER; t: Termios.termios; speed: Termios.speed_t; flags: SET; BEGIN conn := NIL; ASSERT(opts * {even,odd} # {even,odd}, 20); IF bits4 IN opts THEN ASSERT(opts * {bits5,bits6,bits7} = {}, 21) END; IF bits5 IN opts THEN ASSERT(opts * {bits4,bits6,bits7} = {}, 22) END; IF bits6 IN opts THEN ASSERT(opts * {bits4,bits5,bits7} = {}, 23) END; IF bits7 IN opts THEN ASSERT(opts * {bits4,bits5,bits6} = {}, 24) END; ASSERT(opts * {stop15,stop2} # {stop15,stop2}, 25); IF stop15 IN opts THEN ASSERT(opts * {bits4,bits5} # {}, 26) END; IF stop2 IN opts THEN ASSERT(opts * {bits4,bits5} = {}, 27) END; DecodeBaud(baud, speed); ss := SHORT(device$); flags := Libc.O_RDWR; IF nonblocking IN opts THEN flags := flags + Libc.O_NONBLOCK END; fd := Libc.open(ss, flags, {1,4} (* 022 *)); IF fd # -1 THEN res := Termios.tcgetattr(fd, t); IF res = 0 THEN t.c_iflag := Termios.IGNBRK (* ignore BREAK condition *) + Termios.IGNPAR (* ignore (discard) parity errors *); IF opts * {even,odd} # {} THEN t.c_iflag := t.c_iflag + Termios.INPCK (* enable input parity checking *) END; t.c_oflag := 0; t.c_cflag := Termios.CREAD (* enable receiver *) + Termios.CLOCAL (* ignore modem status lines *); IF bits4 IN opts THEN HALT(126) (* not implemented *) ELSIF bits5 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS5 ELSIF bits6 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS6 ELSIF bits7 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS6 ELSE t.c_cflag := t.c_cflag + Termios.CS8 END; IF opts * {stop15,stop2} # {} THEN t.c_cflag := t.c_cflag + Termios.CSTOPB END; IF even IN opts THEN t.c_cflag := t.c_cflag + Termios.PARENB ELSIF odd IN opts THEN t.c_cflag := t.c_cflag + Termios.PARENB + Termios.PARODD (* ELSE parity none *) END; IF outCTS IN opts THEN HALT(126) END; (* CTS out flow control *) IF outDSR IN opts THEN HALT(126) END; (* DSR out flow control *) IF inDTR IN opts THEN HALT(126) END; (* DTR flow control handshake *) IF outXonXoff IN opts THEN HALT(126) END; (* Xon/Xoff out flow control *) IF inXonXoff IN opts THEN HALT(126) END; (* Xon/Xoff in flow control *) IF inRTS IN opts THEN HALT(126) END; (* RTS flow control handshake *) t.c_lflag := 0; res := Termios.cfsetispeed(t, speed); IF res = 0 THEN res := Termios.cfsetospeed(t, speed); IF res = 0 THEN res := Termios.tcsetattr(fd, Termios.TCSANOW, t); IF res = 0 THEN res := Termios.tcflush(fd, Termios.TCIOFLUSH); IF res = 0 THEN NEW(c); c.hnd := fd; c.opts := opts; conn := c ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END END END Open; PROCEDURE (hook: Hook) Close* (c: CommV24.Connection); VAR res: INTEGER; BEGIN ASSERT(c # NIL, 20); IF c(Connection).hnd # -1 THEN res := Libc.close(c(Connection).hnd); c(Connection).hnd := -1 END END Close; PROCEDURE (c: Connection) FINALIZE-; VAR res: INTEGER; BEGIN IF c.hnd # -1 THEN res := Libc.close(c(Connection).hnd); c(Connection).hnd := -1 END END FINALIZE; PROCEDURE (hook: Hook) SendByte* (c: CommV24.Connection; x: BYTE); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Libc.write(c(Connection).hnd, SYSTEM.ADR(x), 1); CommV24.isLastSendDone := res = 1; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res = 1, 100) END END SendByte; PROCEDURE (hook: Hook) SendBytes* (c: CommV24.Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); res := Libc.write(c(Connection).hnd, SYSTEM.ADR(x) + beg, len); CommV24.isLastSendDone := res = len; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res = len, 100) END END SendBytes; PROCEDURE (hook: Hook) Available* (c: CommV24.Connection): INTEGER; VAR res: INTEGER; read: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); read := -1; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.FIONREAD, read); IF res = -1 THEN CommV24.Close(c); read := -1 END; RETURN read END Available; PROCEDURE (hook: Hook) ReceiveByte* (c: CommV24.Connection; OUT x: BYTE); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Libc.read(c(Connection).hnd, SYSTEM.ADR(x), 1); ASSERT(res = 1, 100) END ReceiveByte; PROCEDURE (hook: Hook) ReceiveBytes* (c: CommV24.Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); res := Libc.read(c(Connection).hnd, SYSTEM.ADR(x) + beg, len); ASSERT(res = len, 100) END ReceiveBytes; PROCEDURE (hook: Hook) SetBuffers* (c: CommV24.Connection; inpBufSize, outBufSize: INTEGER); BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); (* HALT(126) *) END SetBuffers; PROCEDURE (hook: Hook) SetDTR* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(~(inDTR IN c(Connection).opts), 22); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); IF on THEN modembits := ORD(BITS(modembits) + Ioctl.TIOCM_DTR) ELSE modembits := ORD(BITS(modembits) - Ioctl.TIOCM_DTR) END; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMSET, modembits); ASSERT(res # -1, 101) END SetDTR; PROCEDURE (hook: Hook) SetRTS* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(~(inRTS IN c(Connection).opts), 22); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); IF on THEN modembits := ORD(BITS(modembits) + Ioctl.TIOCM_RTS) ELSE modembits := ORD(BITS(modembits) - Ioctl.TIOCM_RTS) END; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMSET, modembits); ASSERT(res # -1, 101) END SetRTS; PROCEDURE (hook: Hook) SetBreak* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); IF on THEN res := Ioctl.ioctl0(c(Connection).hnd, Ioctl.TIOCSBRK) ELSE res := Ioctl.ioctl0(c(Connection).hnd, Ioctl.TIOCCBRK) END; ASSERT(res # -1, 100) END SetBreak; PROCEDURE (hook: Hook) CTSState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_CTS = Ioctl.TIOCM_CTS END CTSState; PROCEDURE (hook: Hook) DSRState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_DSR = Ioctl.TIOCM_DSR END DSRState; PROCEDURE (hook: Hook) CDState* (c: CommV24.Connection): BOOLEAN; VAR res, errno: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_CAR = Ioctl.TIOCM_CAR END CDState; BEGIN NEW(hook); CommV24.SetHook(hook) END CommV24__Lin.

Comm/Mod/V24__Lin.odc

MODULE CommV24__Obsd; (* A. V. Shiryaev, 2012.11 Linux, OpenBSD 32-bit Interface corresponds to original BlackBox 1.6 CommV24 *) IMPORT SYSTEM, Libc := ObsdLibc, Termios := ObsdTermios, Ioctl := ObsdIoctl, CommV24; CONST bits4* = 0; bits5* = 1; bits6* = 2; bits7* = 3; stop15* = 4; stop2* = 5; even* = 6; odd* = 7; inXonXoff* = 8; outXonXoff* = 9; inRTS* = 10; inDTR* = 11; outCTS* = 12; outDSR* = 13; nonblocking* = 31; TYPE Hook* = POINTER TO RECORD (CommV24.Hook) END; Connection* = POINTER TO RECORD (CommV24.Connection) hnd: INTEGER; (* # -1: open *) opts: SET END; VAR hook: Hook; PROCEDURE DecodeBaud (baud: INTEGER; OUT speed: Termios.speed_t); BEGIN IF baud = 50 THEN speed := Termios.B50 ELSIF baud = 75 THEN speed := Termios.B75 ELSIF baud = 110 THEN speed := Termios.B110 ELSIF baud = 134 THEN speed := Termios.B134 ELSIF baud = 150 THEN speed := Termios.B150 ELSIF baud = 200 THEN speed := Termios.B200 ELSIF baud = 300 THEN speed := Termios.B300 ELSIF baud = 600 THEN speed := Termios.B600 ELSIF baud = 1200 THEN speed := Termios.B1200 ELSIF baud = 1800 THEN speed := Termios.B1800 ELSIF baud = 2400 THEN speed := Termios.B2400 ELSIF baud = 4800 THEN speed := Termios.B4800 (* ELSIF baud = 7200 THEN speed := Termios.B7200 *) (* not present in Linux *) ELSIF baud = 9600 THEN speed := Termios.B9600 (* ELSIF baud = 14400 THEN speed := Termios.B14400 *) (* not present in Linux *) ELSIF baud = 19200 THEN speed := Termios.B19200 (* ELSIF baud = 28800 THEN speed := Termios.B28800 *) (* not present in Linux *) ELSIF baud = 38400 THEN speed := Termios.B38400 ELSIF baud = 57600 THEN speed := Termios.B57600 (* ELSIF baud = 76800 THEN speed := Termios.B76800 *) (* not present in Linux *) ELSIF baud = 115200 THEN speed := Termios.B115200 ELSIF baud = 230400 THEN speed := Termios.B230400 ELSE HALT(100) END END DecodeBaud; PROCEDURE (hook: Hook) IsConnected* (c: CommV24.Connection): BOOLEAN; BEGIN ASSERT(c # NIL, 20); RETURN (c(Connection).hnd # 0) & (c(Connection).hnd # -1) END IsConnected; PROCEDURE (hook: Hook) Open* (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: CommV24.Connection); VAR c: Connection; fd: INTEGER; ss: ARRAY Libc.NAME_MAX + 1 OF SHORTCHAR; res: INTEGER; t: Termios.termios; speed: Termios.speed_t; flags: SET; BEGIN conn := NIL; ASSERT(opts * {even,odd} # {even,odd}, 20); IF bits4 IN opts THEN ASSERT(opts * {bits5,bits6,bits7} = {}, 21) END; IF bits5 IN opts THEN ASSERT(opts * {bits4,bits6,bits7} = {}, 22) END; IF bits6 IN opts THEN ASSERT(opts * {bits4,bits5,bits7} = {}, 23) END; IF bits7 IN opts THEN ASSERT(opts * {bits4,bits5,bits6} = {}, 24) END; ASSERT(opts * {stop15,stop2} # {stop15,stop2}, 25); IF stop15 IN opts THEN ASSERT(opts * {bits4,bits5} # {}, 26) END; IF stop2 IN opts THEN ASSERT(opts * {bits4,bits5} = {}, 27) END; DecodeBaud(baud, speed); ss := SHORT(device$); flags := Libc.O_RDWR; IF nonblocking IN opts THEN flags := flags + Libc.O_NONBLOCK END; fd := Libc.open(ss, flags, {1,4} (* 022 *)); IF fd # -1 THEN res := Termios.tcgetattr(fd, t); IF res = 0 THEN t.c_iflag := Termios.IGNBRK (* ignore BREAK condition *) + Termios.IGNPAR (* ignore (discard) parity errors *); IF opts * {even,odd} # {} THEN t.c_iflag := t.c_iflag + Termios.INPCK (* enable input parity checking *) END; t.c_oflag := 0; t.c_cflag := Termios.CREAD (* enable receiver *) + Termios.CLOCAL (* ignore modem status lines *); IF bits4 IN opts THEN HALT(126) (* not implemented *) ELSIF bits5 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS5 ELSIF bits6 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS6 ELSIF bits7 IN opts THEN t.c_cflag := t.c_cflag + Termios.CS6 ELSE t.c_cflag := t.c_cflag + Termios.CS8 END; IF opts * {stop15,stop2} # {} THEN t.c_cflag := t.c_cflag + Termios.CSTOPB END; IF even IN opts THEN t.c_cflag := t.c_cflag + Termios.PARENB ELSIF odd IN opts THEN t.c_cflag := t.c_cflag + Termios.PARENB + Termios.PARODD (* ELSE parity none *) END; IF outCTS IN opts THEN HALT(126) END; (* CTS out flow control *) IF outDSR IN opts THEN HALT(126) END; (* DSR out flow control *) IF inDTR IN opts THEN HALT(126) END; (* DTR flow control handshake *) IF outXonXoff IN opts THEN HALT(126) END; (* Xon/Xoff out flow control *) IF inXonXoff IN opts THEN HALT(126) END; (* Xon/Xoff in flow control *) IF inRTS IN opts THEN HALT(126) END; (* RTS flow control handshake *) t.c_lflag := 0; res := Termios.cfsetispeed(t, speed); IF res = 0 THEN res := Termios.cfsetospeed(t, speed); IF res = 0 THEN res := Termios.tcsetattr(fd, Termios.TCSANOW, t); IF res = 0 THEN res := Termios.tcflush(fd, Termios.TCIOFLUSH); IF res = 0 THEN NEW(c); c.hnd := fd; c.opts := opts; conn := c ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END ELSE res := Libc.close(fd) END END END Open; PROCEDURE (hook: Hook) Close* (c: CommV24.Connection); VAR res: INTEGER; BEGIN ASSERT(c # NIL, 20); IF c(Connection).hnd # -1 THEN res := Libc.close(c(Connection).hnd); c(Connection).hnd := -1 END END Close; PROCEDURE (c: Connection) FINALIZE-; VAR res: INTEGER; BEGIN IF c.hnd # -1 THEN res := Libc.close(c(Connection).hnd); c(Connection).hnd := -1 END END FINALIZE; PROCEDURE (hook: Hook) SendByte* (c: CommV24.Connection; x: BYTE); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Libc.write(c(Connection).hnd, SYSTEM.ADR(x), 1); CommV24.isLastSendDone := res = 1; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res = 1, 100) END END SendByte; PROCEDURE (hook: Hook) SendBytes* (c: CommV24.Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); res := Libc.write(c(Connection).hnd, SYSTEM.ADR(x) + beg, len); CommV24.isLastSendDone := res = len; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res = len, 100) END END SendBytes; PROCEDURE (hook: Hook) Available* (c: CommV24.Connection): INTEGER; VAR res: INTEGER; read: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); read := -1; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.FIONREAD, read); IF res = -1 THEN CommV24.Close(c); read := -1 END; RETURN read END Available; PROCEDURE (hook: Hook) ReceiveByte* (c: CommV24.Connection; OUT x: BYTE); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Libc.read(c(Connection).hnd, SYSTEM.ADR(x), 1); ASSERT(res = 1, 100) END ReceiveByte; PROCEDURE (hook: Hook) ReceiveBytes* (c: CommV24.Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER); VAR res: Libc.ssize_t; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); res := Libc.read(c(Connection).hnd, SYSTEM.ADR(x) + beg, len); ASSERT(res = len, 100) END ReceiveBytes; PROCEDURE (hook: Hook) SetBuffers* (c: CommV24.Connection; inpBufSize, outBufSize: INTEGER); BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); (* HALT(126) *) END SetBuffers; PROCEDURE (hook: Hook) SetDTR* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(~(inDTR IN c(Connection).opts), 22); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); IF on THEN modembits := ORD(BITS(modembits) + Ioctl.TIOCM_DTR) ELSE modembits := ORD(BITS(modembits) - Ioctl.TIOCM_DTR) END; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMSET, modembits); ASSERT(res # -1, 101) END SetDTR; PROCEDURE (hook: Hook) SetRTS* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(~(inRTS IN c(Connection).opts), 22); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); IF on THEN modembits := ORD(BITS(modembits) + Ioctl.TIOCM_RTS) ELSE modembits := ORD(BITS(modembits) - Ioctl.TIOCM_RTS) END; res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMSET, modembits); ASSERT(res # -1, 101) END SetRTS; PROCEDURE (hook: Hook) SetBreak* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); IF on THEN res := Ioctl.ioctl0(c(Connection).hnd, Ioctl.TIOCSBRK) ELSE res := Ioctl.ioctl0(c(Connection).hnd, Ioctl.TIOCCBRK) END; ASSERT(res # -1, 100) END SetBreak; PROCEDURE (hook: Hook) CTSState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_CTS = Ioctl.TIOCM_CTS END CTSState; PROCEDURE (hook: Hook) DSRState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_DSR = Ioctl.TIOCM_DSR END DSRState; PROCEDURE (hook: Hook) CDState* (c: CommV24.Connection): BOOLEAN; VAR res, errno: INTEGER; modembits: INTEGER; BEGIN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := Ioctl.ioctl1(c(Connection).hnd, Ioctl.TIOCMGET, modembits); ASSERT(res # -1, 100); RETURN BITS(modembits) * Ioctl.TIOCM_CAR = Ioctl.TIOCM_CAR END CDState; BEGIN NEW(hook); CommV24.SetHook(hook) END CommV24__Obsd.

Comm/Mod/V24__Obsd.odc

MODULE CommV24__Win; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems, Alexander Iljin, Ivan Denisov" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - 20130423, dia, remove ASSERT(100) from Available to prevent error for USB2COM devices - 20070205, bh, Unicode support - 20061007, ai, Deleted ASSERT(101) from procedure Available. - 20060916, ai, Added inDTRon, inRTSon support. - 20060916, ai, Some parameter restrictions enforced with ASSERTs. Added IsConnected. " issues = " - this module was not decomposed into two modules, like CommStreams/CommTCP; for better consistency, this should be corrected " **) IMPORT SYSTEM, WinApi, CommV24; CONST bits4* = 0; bits5* = 1; bits6* = 2; bits7* = 3; stop15* = 4; stop2* = 5; even* = 6; odd* = 7; inXonXoff* = 8; outXonXoff* = 9; inRTS* = 10; inDTR* = 11; outCTS* = 12; outDSR* = 13; inDTRon* = 14; inRTSon* = 15; nonblocking* = 31; TYPE Hook* = POINTER TO RECORD (CommV24.Hook) END; Connection* = POINTER TO RECORD (CommV24.Connection) hnd-: WinApi.HANDLE; (* # 0: open *) opts: SET END; VAR hook: Hook; PROCEDURE (hook: Hook) IsConnected* (c: CommV24.Connection): BOOLEAN; BEGIN ASSERT(c # NIL, 20); RETURN (c(Connection).hnd # 0) & (c(Connection).hnd # -1) END IsConnected; PROCEDURE (hook: Hook) Open* (device: ARRAY OF CHAR; baud: INTEGER; opts: SET; OUT conn: CommV24.Connection); VAR c: Connection; h: WinApi.HANDLE; res: INTEGER; dcb: WinApi.DCB; to: WinApi.COMMTIMEOUTS; s: ARRAY WinApi.MAX_PATH OF CHAR; BEGIN ASSERT(opts * {even, odd} # {even, odd}, 20); IF bits4 IN opts THEN ASSERT(opts * {bits5, bits6, bits7} = {}, 21) END; IF bits5 IN opts THEN ASSERT(opts * {bits4, bits6, bits7} = {}, 21) END; IF bits6 IN opts THEN ASSERT(opts * {bits4, bits5, bits7} = {}, 21) END; IF bits7 IN opts THEN ASSERT(opts * {bits4, bits5, bits6} = {}, 21) END; ASSERT(opts * {inDTR, inDTRon} # {inDTR, inDTRon}, 22); ASSERT(opts * {inRTS, inRTSon} # {inRTS, inRTSon}, 23); IF (device[0] # "\") & (device[0] # "/") THEN s := "\\.\" + device ELSE s := device$ END; h := WinApi.CreateFileW( s, WinApi.GENERIC_READ + WinApi.GENERIC_WRITE, {}, NIL, WinApi.OPEN_EXISTING, {}, 0 ); IF h # -1 THEN dcb.DCBlength := SIZE(WinApi.DCB); res := WinApi.GetCommState(h, dcb); IF res # 0 THEN dcb.BaudRate := baud; dcb.fBits0 := {0}; (* binary *) IF opts * {even, odd} # {} THEN INCL(dcb.fBits0, 1) END; (* check parity *) IF outCTS IN opts THEN INCL(dcb.fBits0, 2) END; (* CTS out flow control *) IF outDSR IN opts THEN INCL(dcb.fBits0, 3) END; (* DSR out flow control *) IF inDTR IN opts THEN INCL(dcb.fBits0, 5) (* DTR flow control handshake *) ELSIF inDTRon IN opts THEN INCL(dcb.fBits0, 4) END; (* DTR enable*) IF outXonXoff IN opts THEN INCL(dcb.fBits0, 8) END; (* Xon/Xoff out flow control *) IF inXonXoff IN opts THEN INCL(dcb.fBits0, 9) END; (* Xob/Xoff in flow control *) IF inRTS IN opts THEN INCL(dcb.fBits0, 13) (* RTS flow control handshake *) ELSIF inRTSon IN opts THEN INCL(dcb.fBits0, 12) END; (* RTS enable*) IF bits4 IN opts THEN dcb.ByteSize := 4X ELSIF bits5 IN opts THEN dcb.ByteSize := 5X ELSIF bits6 IN opts THEN dcb.ByteSize := 6X ELSIF bits7 IN opts THEN dcb.ByteSize := 7X ELSE dcb.ByteSize := 8X END; IF stop15 IN opts THEN dcb.StopBits := 1X ELSIF stop2 IN opts THEN dcb.StopBits := 2X ELSE dcb.StopBits := 0X END; IF even IN opts THEN dcb.Parity := 2X ELSIF odd IN opts THEN dcb.Parity := 1X ELSE dcb.Parity := 0X END; res := WinApi.SetCommState(h, dcb); IF res # 0 THEN to.ReadIntervalTimeout := 0; to.ReadTotalTimeoutMultiplier := 0; to.ReadTotalTimeoutConstant := 0; to.WriteTotalTimeoutMultiplier := 0; to.WriteTotalTimeoutConstant := 0; res := WinApi.SetCommTimeouts(h, to); IF res # 0 THEN NEW(c); c.hnd := h; c.opts := opts; conn := c END END END END END Open; PROCEDURE (hook: Hook) Close* (c: CommV24.Connection); VAR res: INTEGER; BEGIN IF hook.IsConnected(c) THEN ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := WinApi.CloseHandle(c(Connection).hnd); c(Connection).hnd := -1 END END Close; PROCEDURE (hook: Hook) SendByte* (c: CommV24.Connection; x: BYTE); VAR res, written: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); written := 0; ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := WinApi.WriteFile(c(Connection).hnd, SYSTEM.ADR(x), 1, written, NIL); CommV24.isLastSendDone := written = 1; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res # 0, 100); ASSERT(written = 1, 101) END END SendByte; PROCEDURE (hook: Hook) SendBytes* (c: CommV24.Connection; IN x: ARRAY OF BYTE; beg, len: INTEGER); VAR res, written: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); res := WinApi.WriteFile(c(Connection).hnd, SYSTEM.ADR(x) + beg, len, written, NIL); CommV24.isLastSendDone := written = len; IF ~(nonblocking IN c(Connection).opts) THEN ASSERT(res # 0, 100); ASSERT(written = 1, 101) END END SendBytes; PROCEDURE (hook: Hook) Available* (c: CommV24.Connection): INTEGER; VAR res: INTEGER; errors: SET; status: WinApi.COMSTAT; BEGIN IF hook.IsConnected(c) THEN errors := {}; status.cbInQue := 0; res := WinApi.ClearCommError(c(Connection).hnd, errors, status); IF res = 0 THEN RETURN -1 ELSE RETURN status.cbInQue END ELSE RETURN -1 END END Available; PROCEDURE (hook: Hook) ReceiveByte* (c: CommV24.Connection; OUT x: BYTE); VAR res, read: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); read := 0; ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); res := WinApi.ReadFile(c(Connection).hnd, SYSTEM.ADR(x), 1, read, NIL); ASSERT(res # 0, 100); ASSERT(read = 1, 101) END ReceiveByte; PROCEDURE (hook: Hook) ReceiveBytes* (c: CommV24.Connection; OUT x: ARRAY OF BYTE; beg, len: INTEGER); VAR res, read: INTEGER; BEGIN IF len = 0 THEN RETURN END; ASSERT(hook.IsConnected(c), 21); ASSERT(c # NIL, 20); ASSERT(c(Connection).hnd # -1, 21); ASSERT(LEN(x) >= beg + len, 22); ASSERT(len > 0, 23); read := 0; res := WinApi.ReadFile(c(Connection).hnd, SYSTEM.ADR(x) + beg, len, read, NIL); ASSERT(res # 0, 100); ASSERT(read = len, 101) END ReceiveBytes; PROCEDURE (hook: Hook) SetBuffers* (c: CommV24.Connection; inpBufSize, outBufSize: INTEGER); VAR res: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); res := WinApi.SetupComm(c(Connection).hnd, inpBufSize, outBufSize); ASSERT(res # 0, 100) END SetBuffers; PROCEDURE (hook: Hook) SetDTR* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); ASSERT(~(inDTR IN c(Connection).opts), 22); IF on THEN res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.SETDTR) ELSE res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.CLRDTR) END; ASSERT(res # 0, 100) END SetDTR; PROCEDURE (hook: Hook) SetRTS* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); ASSERT(~(inRTS IN c(Connection).opts), 22); IF on THEN res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.SETRTS) ELSE res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.CLRRTS) END; ASSERT(res # 0, 100) END SetRTS; PROCEDURE (hook: Hook) SetBreak* (c: CommV24.Connection; on: BOOLEAN); VAR res: INTEGER; BEGIN ASSERT(hook.IsConnected(c), 21); IF on THEN res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.SETBREAK) ELSE res := WinApi.EscapeCommFunction(c(Connection).hnd, WinApi.CLRBREAK) END; ASSERT(res # 0, 100) END SetBreak; PROCEDURE (hook: Hook) CTSState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; s: SET; BEGIN ASSERT(hook.IsConnected(c), 21); s := {}; res := WinApi.GetCommModemStatus(c(Connection).hnd, s); ASSERT(res # 0, 100); RETURN s * WinApi.MS_CTS_ON # {} END CTSState; PROCEDURE (hook: Hook) DSRState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; s: SET; BEGIN ASSERT(hook.IsConnected(c), 21); s := {}; res := WinApi.GetCommModemStatus(c(Connection).hnd, s); ASSERT(res # 0, 100); RETURN s * WinApi.MS_DSR_ON # {} END DSRState; PROCEDURE (hook: Hook) CDState* (c: CommV24.Connection): BOOLEAN; VAR res: INTEGER; s: SET; BEGIN ASSERT(hook.IsConnected(c), 21); s := {}; res := WinApi.GetCommModemStatus(c(Connection).hnd, s); ASSERT(res # 0, 100); RETURN s * WinApi.MS_RLSD_ON # {} END CDState; BEGIN NEW(hook); CommV24.SetHook(hook) END CommV24__Win.

Comm/Mod/V24__Win.odc

ConsLog Log implementation for console. Example: MODULE ConsHello0; IMPORT Log; PROCEDURE Do*; BEGIN Log.String("hello world"); Log.Ln END Do; BEGIN Do END ConsHello0. DevCompiler.Compile You can run this example from GUI version of framework. ConsHello0.Do The message will appear in the Log window, because StdLog implementation is used. To use ConsLog implementation just add it in the linked modules with required dependencies. For Windows: DevLinker.LinkExe dos hello0.exe := Kernel+ Utf WinKernel Files WinEnv WinFiles Log Services Math Strings Fonts StdLibrarian Dialog Console WinConsole ConsLog ConsHello0 For Linux: DevLinker1.LinkElfExe Linux hello0 := Kernel+ Utf LinKernel Files LinEnv LinFiles Log Services Math Strings Fonts StdLibrarian Dialog Console LinConsole ConsLog ConsHello0

Cons/Docu/Log.odc

MODULE ConsCompiler; (* A. V. Shiryaev, 2012.09 *) IMPORT StdLog, DevCompiler, DevMarkers, TextModels, TextViews, Views, Files; PROCEDURE LogStr (IN s: ARRAY OF CHAR); BEGIN StdLog.String(s) END LogStr; PROCEDURE LogInt (x: LONGINT); BEGIN StdLog.Int(x) END LogInt; PROCEDURE LogLn; BEGIN StdLog.Ln END LogLn; PROCEDURE LogMarks (r: TextModels.Reader); VAR v: Views.View; v1: DevMarkers.View; BEGIN r.SetPos(0); r.ReadView(v); WHILE ~r.eot DO IF v IS DevMarkers.View THEN v1 := v(DevMarkers.View); v1.SetMode(DevMarkers.message); LogStr(" pos = "); LogInt(r.Pos()); LogStr(", error = '"); LogStr(v1.msg); LogStr("'"); LogLn END; r.ReadView(v) END END LogMarks; PROCEDURE Load0 (f: Files.File): TextModels.Model; VAR r: Files.Reader; w: TextModels.Writer; m: TextModels.Model; x: BYTE; BEGIN r := f.NewReader(NIL); m := TextModels.dir.New(); w := m.NewWriter(NIL); r.ReadByte(x); WHILE ~r.eof DO IF x = 0AH THEN w.WriteChar(TextModels.line) ELSE w.WriteChar(CHR(x)) END; r.ReadByte(x) END; RETURN m END Load0; PROCEDURE Do (IN path, name: ARRAY OF CHAR); VAR loc: Files.Locator; f: Files.File; v: Views.View; src: TextModels.Model; PROCEDURE Do1 (src: TextModels.Model); VAR error: BOOLEAN; BEGIN DevCompiler.CompileText(src, 0, error); IF error THEN LogMarks(src.NewReader(NIL)) END END Do1; BEGIN loc := Files.dir.This(path); IF loc.res = 0 THEN v := Views.OldView(loc, name$); IF v # NIL THEN WITH v: TextViews.View DO src := v.ThisModel(); Do1(src) ELSE LogStr("file open error: "); LogStr(path); LogStr(" "); LogStr(name); LogLn END ELSE (* try compile text file *) f := Files.dir.Old(loc, name$, TRUE); IF f # NIL THEN src := Load0(f); f.Close; Do1(src) ELSE LogStr("file not found: "); LogStr(path); LogStr(" "); LogStr(name); LogLn END END ELSE LogStr("path not found: "); LogStr(path); LogLn END END Do; PROCEDURE Compile* (IN path, name: ARRAY OF CHAR); BEGIN LogStr("compiling "); LogStr(path); LogStr(" "); LogStr(name); LogLn; Do(path, name) END Compile; END ConsCompiler.

Cons/Mod/Compiler.odc

MODULE ConsFonts; (* for Texts, HostTextConv *) IMPORT Fonts; CONST defTypeface = "*"; defSize = 10 * Fonts.point; defW = 161925; defAsc = 142875; defDsc = 28575; TYPE Font* = POINTER TO RECORD (Fonts.Font) alias-: Fonts.Typeface; (* alias # typeface & typeface # "*" == alien font *) END; Directory = POINTER TO RECORD (Fonts.Directory) END; VAR defFont-: Font; (* for HostTextConv *) ti: Fonts.TypefaceInfo; dir: Directory; PROCEDURE (f: Font) GetBounds* (OUT asc, dsc, w: INTEGER); BEGIN asc := defAsc; dsc := defDsc; w := defW END GetBounds; PROCEDURE (f: Font) StringWidth* (IN s: ARRAY OF CHAR): INTEGER; BEGIN RETURN LEN(s$) * defW END StringWidth; PROCEDURE (f: Font) SStringWidth* (IN s: ARRAY OF SHORTCHAR): INTEGER; BEGIN RETURN LEN(s$) * defW END SStringWidth; PROCEDURE (f: Font) IsAlien* (): BOOLEAN; BEGIN RETURN TRUE END IsAlien; PROCEDURE (d: Directory) This (typeface: Fonts.Typeface; size: INTEGER; style: SET; weight: INTEGER): Font; BEGIN RETURN defFont END This; PROCEDURE (d: Directory) Default (): Font; BEGIN RETURN defFont END Default; PROCEDURE (d: Directory) TypefaceList (): Fonts.TypefaceInfo; BEGIN RETURN ti END TypefaceList; PROCEDURE Init; BEGIN NEW(defFont); defFont.Init(defTypeface, defSize, {}, Fonts.normal); defFont.alias := "Arial"; NEW(ti); ti.typeface := defTypeface; NEW(dir); Fonts.SetDir(dir) END Init; BEGIN Init END ConsFonts.

Cons/Mod/Fonts.odc

MODULE ConsInterp; (* A. V. Shiryaev, 2012.09, 2019.10 *) IMPORT Console, Dialog, DevCommanders, TextModels, StdLog; VAR textR: TextModels.Reader; PROCEDURE ShowStdLog; VAR c: CHAR; BEGIN StdLog.text.Append(StdLog.buf); textR.SetPos(0); textR.ReadChar(c); WHILE ~textR.eot DO IF c = 0DX THEN Console.WriteLn ELSE Console.WriteChar(c) END; textR.ReadChar(c) END; StdLog.text.Delete(0, StdLog.text.Length()) END ShowStdLog; PROCEDURE Call1 (IN s: ARRAY OF CHAR; i: INTEGER): BOOLEAN; VAR j: INTEGER; res: INTEGER; par: DevCommanders.Par; m: TextModels.Model; w: TextModels.Writer; BEGIN (* ASSERT 0X in s[ i:LEN(s) ) *) j := i; WHILE s[j] # 0X DO INC(j) END; IF j > i THEN m := TextModels.dir.New(); w := m.NewWriter(NIL); WHILE i < j DO w.WriteChar(s[i]); INC(i) END; NEW(par); par.text := m; par.beg := 0; par.end := m.Length(); DevCommanders.par := par END; Dialog.Call(s, " ", res); DevCommanders.par := NIL; ShowStdLog; RETURN res = 0 END Call1; PROCEDURE Call0 (VAR s: ARRAY OF CHAR): BOOLEAN; VAR i: INTEGER; res: BOOLEAN; inStr: BOOLEAN; BEGIN (* ASSERT s is 0X terminated and not empty *) i := 0; WHILE (s[i] # 0X) & (s[i] # ' ') & (s[i] # '(') DO INC(i) END; IF s[i] = 0X THEN res := Call1(s, i) ELSIF s[i] = ' ' THEN s[i] := 0X; res := Call1(s, i + 1) ELSE (* s[i] = '(' *) INC(i); inStr := FALSE; WHILE (s[i] # 0X) & ~(~inStr & (s[i] = ')')) DO IF s[i] = "'" THEN inStr := ~inStr END; INC(i) END; IF s[i] # 0X THEN INC(i); IF s[i] = 0X THEN res := Call1(s, i) ELSE s[i] := 0X; res := Call1(s, i + 1) END ELSE res := FALSE END END; RETURN res END Call0; PROCEDURE Call (VAR s: ARRAY OF CHAR): BOOLEAN; VAR i: INTEGER; res: BOOLEAN; BEGIN i := 0; WHILE (i < LEN(s)) & (s[i] # 0AX) & (s[i] # 0DX) & (s[i] # 0X) DO INC(i) END; IF (i < LEN(s)) & (s[i] # 0X) THEN IF (i > 0) & (s[0] # '#') THEN s[i] := 0X; res := Call0(s) ELSE (* skip empty strings and comments *) res := TRUE END ELSE (* end of input *) res := FALSE END; RETURN res END Call; PROCEDURE Run*; VAR s: ARRAY 4096 OF CHAR; BEGIN Console.ReadLn(s); WHILE Call(s) DO Console.ReadLn(s) END END Run; BEGIN textR := StdLog.text.NewReader(NIL) END ConsInterp.

Cons/Mod/Interp.odc

MODULE ConsLog; IMPORT Log, Strings, Dialog, Console; TYPE LogHook = POINTER TO RECORD (Log.Hook) END; ShowHook = POINTER TO RECORD (Dialog.ShowHook) END; VAR hook: LogHook; s: ARRAY 1024 OF CHAR; PROCEDURE (log: LogHook) Guard* (o: ANYPTR): BOOLEAN; BEGIN RETURN TRUE END Guard; PROCEDURE (log: LogHook) ClearBuf*; BEGIN (* has no buffer *) END ClearBuf; PROCEDURE (log: LogHook) FlushBuf*; BEGIN (* has no buffer *) END FlushBuf; PROCEDURE (log: LogHook) Beep*; BEGIN Dialog.Beep END Beep; PROCEDURE (log: LogHook) Char* (ch: CHAR); BEGIN Console.WriteChar(ch) END Char; PROCEDURE (log: LogHook) Int* (n: LONGINT); BEGIN Strings.IntToString(n, s); Console.WriteStr(" " + s) END Int; PROCEDURE (log: LogHook) Real* (x: REAL); BEGIN Strings.RealToString(x, s); Console.WriteStr(" " + s) END Real; PROCEDURE (log: LogHook) String* (IN str: ARRAY OF CHAR); BEGIN Console.WriteStr(str) END String; PROCEDURE (log: LogHook) Bool* (x: BOOLEAN); BEGIN IF x THEN s := "$TRUE" ELSE s := "$FALSE" END; Console.WriteStr(s) END Bool; PROCEDURE (log: LogHook) Set* (x: SET); BEGIN Strings.SetToString(x, s); Console.WriteStr(s) END Set; PROCEDURE (log: LogHook) IntForm* (x: LONGINT; base, minWidth: INTEGER; fillCh: CHAR; showBase: BOOLEAN); BEGIN Strings.IntToStringForm(x, base, minWidth, fillCh, showBase, s); Console.WriteStr(s) END IntForm; PROCEDURE (log: LogHook) RealForm* (x: REAL; precision, minW, expW: INTEGER; fillCh: CHAR); BEGIN Strings.RealToStringForm(x, precision, minW, expW, fillCh, s); Console.WriteStr(s) END RealForm; PROCEDURE (log: LogHook) Tab*; BEGIN Console.WriteChar(09X) END Tab; PROCEDURE (log: LogHook) Ln*; BEGIN Console.WriteLn END Ln; PROCEDURE (log: LogHook) Para*; BEGIN log.Ln END Para; PROCEDURE (log: LogHook) View* (v: ANYPTR); BEGIN log.String("View not implemented."); log.Ln END View; PROCEDURE (log: LogHook) ViewForm* (v: ANYPTR; w, h: INTEGER); BEGIN log.String("ViewForm not implemented."); log.Ln END ViewForm; PROCEDURE (log: LogHook) ParamMsg* (IN s, p0, p1, p2: ARRAY OF CHAR); VAR msg: ARRAY 256 OF CHAR; i: INTEGER; ch: CHAR; BEGIN Dialog.MapParamString(s, p0, p1, p2, msg); i := 0; ch := msg[0]; WHILE ch # 0X DO IF ch = 0DX THEN log.Ln ELSIF ch = 0EX THEN log.Para ELSIF ch = 9X THEN log.Tab ELSIF ch >= " " THEN log.Char(ch) END; INC(i); ch := msg[i]; END; log.Ln END ParamMsg; (* ShowHook *) PROCEDURE (shook: ShowHook) ShowParamMsg (IN s, p0, p1, p2: ARRAY OF CHAR); BEGIN hook.ParamMsg(s, p0, p1, p2) END ShowParamMsg; PROCEDURE (shook: ShowHook) ShowParamStatus (IN s, p0, p1, p2: ARRAY OF CHAR); BEGIN IF Dialog.showsStatus THEN hook.ParamMsg(s, p0, p1, p2) END END ShowParamStatus; PROCEDURE Open*; VAR showHook: ShowHook; BEGIN NEW(showHook); Log.SetHook(hook); Dialog.SetShowHook(showHook) END Open; BEGIN NEW(hook); Open END ConsLog.

Cons/Mod/Log.odc

MODULE ConsWindows; (* for Views *) IMPORT Windows, Controllers, Views, Files, Converters, Documents, Ports; TYPE Window = POINTER TO EXTENSIBLE RECORD (Windows.Window) next: Window; (* window ring, to prevent garbage collection of windows *) END; Directory = POINTER TO EXTENSIBLE RECORD (Windows.Directory) END; VAR dir: Directory; winAnchor: Window; (* list of all windows, from top to bottom, first is dumy header *) (** Window **) PROCEDURE (w: Window) ForwardCtrlMsg (VAR msg: Controllers.Message), EXTENSIBLE; BEGIN HALT(126) END ForwardCtrlMsg; PROCEDURE (w: Window) SetSize (width, height: INTEGER); BEGIN HALT(126) END SetSize; PROCEDURE (w: Window) SetTitle (title: Views.Title); BEGIN HALT(126) END SetTitle; PROCEDURE (w: Window) RefreshTitle; BEGIN HALT(126) END RefreshTitle; PROCEDURE (w: Window) GetTitle (OUT title: Views.Title); BEGIN HALT(126) END GetTitle; PROCEDURE (w: Window) SetSpec (loc: Files.Locator; name: Files.Name; conv: Converters.Converter); BEGIN HALT(126) END SetSpec; PROCEDURE (w: Window) MouseDown (x, y, time: INTEGER; modifiers: SET); BEGIN HALT(126) END MouseDown; PROCEDURE (w: Window) KeyDown (ch: CHAR; buttons: SET); BEGIN HALT(126) END KeyDown; PROCEDURE (w: Window) Close; BEGIN ASSERT(w.frame # NIL, 20); HALT(126); w.Close^; ASSERT(w.frame = NIL, 60) END Close; (* Directory *) PROCEDURE (d: Directory) Open ( w: Windows.Window; doc: Documents.Document; flags: SET; name: Views.Title; loc: Files.Locator; fname: Files.Name; conv: Converters.Converter ); VAR p: Ports.Port; BEGIN WITH w: Window DO END END Open; PROCEDURE (d: Directory) First (): Window; BEGIN RETURN winAnchor.next END First; PROCEDURE (d: Directory) Next (w: Windows.Window): Window; BEGIN IF w # NIL THEN RETURN w(Window).next ELSE RETURN NIL END END Next; PROCEDURE (d: Directory) New (): Window, EXTENSIBLE; VAR w: Window; BEGIN NEW(w); RETURN w END New; PROCEDURE (d: Directory) Focus (target: BOOLEAN): Window; BEGIN RETURN NIL END Focus; PROCEDURE (d: Directory) Select (w: Windows.Window; lazy: BOOLEAN); BEGIN WITH w: Window DO HALT(126) END END Select; PROCEDURE (d: Directory) GetThisWindow (p: Ports.Port; px, py: INTEGER; OUT x, y: INTEGER; OUT w: Windows.Window); BEGIN w := NIL END GetThisWindow; PROCEDURE (d: Directory) Close (w: Windows.Window); VAR v, u: Windows.Window; h: Window; BEGIN h := winAnchor; WHILE (h.next # NIL) & (h.next # w) DO h := h.next END; IF h.next = w THEN IF ~w.sub THEN v := w.link; WHILE v # w DO u := v.link; v.Close; v := u END END; w.Close END END Close; PROCEDURE (d: Directory) GetBounds (OUT w, h: INTEGER); BEGIN HALT(126) END GetBounds; PROCEDURE Init; VAR d: Directory; BEGIN NEW(d); d.l := -1; d.t := -1; d.r := -1; d.b := -1; dir := d; Windows.SetDir(d); NEW(winAnchor); winAnchor.next := NIL; (* dummy header *) END Init; BEGIN Init END ConsWindows.

Cons/Mod/Windows.odc

Console/Rsrc/Test.odc

CtlAccess9 CtlAccess9 contains the automation interface for Microsoft Access 9.0. The objects contained in this module are explained in the corresponding help file (ACMAIN9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/Access9.odc

CtlADODB CtlADODB contains the automation interface for Microsoft ActiveX Data Objects 2.0. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/ADODB.odc

CtlC This module has a private interface, it is only used internally (by code generated with the OLE Automation generator DevComInterfaceGen).

Ctl/Docu/C.odc

CtlDAO36 CtlDAO36 contains the automation interface for Microsoft Data Access Objects 3.6 (DAO). The objects contained in this module are explained in the corresponding help file (DAO36.HLP) which is located on the MS Office CD. This Module is equal to the module CtlDAO in previous releases of BlackBox. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/DAO36.odc

Ctl Subsystem Developer Manual Introduction The Ctl subsystem contains tools for writing OLE automation controllers in BlackBox. OLE Automation is a standard for controlling objects implemented in one application (server) from within another application (controller). The interface of a server application is described in a type library. A type library specifies the objects provided by the application and the operations on these objects. To write a controller in BlackBox, an interface module is used which contains a Component Pascal object for each object in the type library. These objects can be used like other Component Pascal objects in a convenient and typesafe way and hide the details of the automation standard used to communicate with the server application. Elements of an interface module An automation interface module declares the following elements: • Constants Constant declarations correspond to constant declarations in the type library. They are usually used as values for integer parameters of methods. • Alias Types Alias Types can be declared for all legal automation types (see below). • Object Types Object types are the main elements of an automation interface module. In general, automation objects can have methods and properties (fields). In BlackBox both methods and properties are implemented as methods. For a property with name Prop and type Type two methods are declared: PROCEDURE (this: Object) Prop (): Type; PROCEDURE (this: Object) PUTProp (val: Type); The latter is omitted if the property is read-only. The type of a property or method parameter can be any legal automation type (see below). • Procedures For an object type with name Object, the following procedures are declared: PROCEDURE IsObject (v: CtlT.Any): BOOLEAN; PROCEDURE ThisObject (v: CtlT.Any): Object; The two serve as type-test and type-guard for automation objects. These procedures can be used in places where otherwise one would call QueryInterface to retrieve the IDispatch interface of an object. For objects marked as creatable in the type library an additional procedure is used for the allocation of a new object of that type: PROCEDURE NewObject (): Object; Legal data types Because OLE Automation is a standard used to communicate between applications potentially written in different languages, a restricted set of legal data types must be used. Basic Types: BOOLEAN FALSE or TRUE BYTE 1 byte SHORTINT 2 bytes INTEGER 4 bytes SHORTREAL 4 bytes REAL 8 bytes CtlT.OleCy (=LONGINT) 8 bytes, scaled by 10000 CtlT.Date (=REAL) date & time as a real value, see CtlT for conversion ARRAY OF CHAR Unicode strings CtlT.RESULT (=INTEGER) OLE result values (4 bytes) CtlT.IUnknown OLE Interfaces (usually not used) Object Types: Object types are declared as record extensions of the type CtlT.Object. Arrays: In Ole Automation, multidimensional arrays of all types above can be used. Only one- and two-dimensional array are supported in BlackBox. Unspecified Type: In OLE Automation there is a type covering all other legal automation types. It is used when a property or parameter is not statically typed at all. The type used in BlackBox for this purpose is CtlT.Any. The type CtlT.Object is an extension of CtlT.Any. Because basic types cannot be extensions of such a type in Component Pascal, a record type which is an extension of CtlT.Any is provided for each basic and array type. See CtlT for details. Example The following is a short example relating plain OLE programming to the BlackBox approach. To open a document in word, one has first to create an object for the application. Second, from this object a list of documents can be retrieved. Third, to this list a new document can be added. Below are the first two steps formulated each in C++ and in Component Pascal using the Word9 interface module. Creating a new application, C++ version: ::CoInitialize(NULL); CLSID clsid; CLSIDFromProgID(L"Word.Application", &clsid); IUnknown* pUnk; HRESULT hr = ::CoCreateInstance(clsid, NULL, CLSCTX_SERVER, IID_IUnknown, (void**) &pUnk); IDispatch* pDispApp; hr = pUnk->QueryInterface(IID_IDispatch, (void**)&pDispApp); Creating a new application, BlackBox version: VAR app: CtlWord9._Application; ... app := CtlWord9.NewApplication() Retrieving the list of documents, C++ version: DISPPARAMS dpNoArgs = {NULL, NULL, 0, 0}; VARIANT vResult; OLECHAR FAR* szFunction; IDispatch* pDispDocs; DISPID dispid_Docs; szFunction = OLESTR("Documents"); hr = pDispApp->GetIDsOfNames (IID_NULL, &szFunction, 1, LOCALE_USER_DEFAULT, &dispid_Docs); hr = pDispApp->Invoke (dispid_Docs, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &dpNoArgs, &vResult, NULL, NULL); pDispDocs = vResult.pdispVal; Retrieving the list of documents, BlackBox version: VAR docs: CtlWord9.Documents; ... docs := app.Documents() Callback interfaces In contrast to normal interfaces, a callback interface is implemented by the controller application and called by the server. In an automation interface, module callback interfaces are declared as abstract objects which are extensions of CtlT.OutObject. Such objects must be implemented in the controlling program and connected to the corresponding server object. Connection is done using CtlT.Connect for normal automation objects or OleViews.Connect for a server object contained in a BlackBox View. Error Handling There are two general error sources: An automation method call can fail because of an exception in the server application, or because of an out-of-memory situation. An exception in the server raises a trap 10 in the automation interface module. Two string variables visible in the trap window, namely source and description, show the available information about where and why the exception occurred. A third variable param holds the number of the parameter if the error belongs to a parameter value. An out-of-memory condition leads to a trap 11. Available Automation interfaces The following table contains all automation interfaces currently available in BlackBox. The modules were generated automatically from the corresponding type libraries. The semantics of the objects contained in these modules are explained in the corresponding help files which are all contained on the MS Office CD but are not installed by default. Module Name Controlled Application Help File CtlExcel9 MS Excel 9.0 VBAXL9.CHM CtlWord9 MS Word 9.0 VBAWRD9.CHM CtlOutlook9 MS Outlook 9.0 VBAOUTL9.CHM CtlPowerPoint9 MS PowerPoint 9.0 VBAPPT9.CHM CtlAccess9 MS Access 9.0 ACMAIN9.CHM CtlGraph9 MS Graph 9.0 VBAGRP9.CHM CtlOffice MS Office 9.0 VBAOFF9.CHM / VBAOFF8.HLP CtlOfficeBinder MS Binder 9.0 VBABDR8.HLP CtlMSForms MS Forms 2.0 FM20.HLP CtlDAO36 MS Data Access Objects 3.6 DAO36.HLP CtlADODB MS ActiveX Data Objects 2.0 - CtlVBIDE MS Visual Basic VEENOB3.HLP CtlStdType Standard OLE Types - CtlVBIDE and CtlStdType contain types imported by other modules and are usually not used directly.

Ctl/Docu/Dev-Man.odc

CtlExcel9 CtlExcel9 contains the automation interface for Microsoft Excel 9.0. The objects contained in this module are explained in the corresponding help file (VBAXL9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu. MODULE ObxExcel; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT CtlT, CtlExcel := CtlExcel9, Dates, Views, Containers, OleViews, TextModels, TextViews, TextMappers, StdLog; PROCEDURE ShowExcel*; VAR ws: CtlExcel.Worksheet; wb: CtlExcel.Workbook; range: CtlExcel.Range; a: ARRAY 3 OF INTEGER; d: Dates.Date; t: Dates.Time; date: CtlT.OleDate; (* = REAL *) cy: CtlT.OleCy; (* = LONGINT *) v: Views.View; text: TextModels.Model; out: TextMappers.Formatter; BEGIN v := OleViews.NewObjectView("Excel.Sheet"); IF v # NIL THEN (* in excel 8.0 Excel.Sheet is a workbook object ! *) wb := CtlExcel.This_Workbook(OleViews.AutoObject(v)); ws := CtlExcel.This_Worksheet(wb.Worksheets().Item(CtlT.Int(1))); range := ws.Range(CtlT.Str("A1"), NIL); range.PUTValue(CtlT.Str("Hello World")); range.PUTColumnWidth(CtlT.Int(12)); (* unit = width of "0" in standard font *) ws.Range(CtlT.Str("B1"), NIL).PUTValue(CtlT.Int(13)); d.year := 1996; d.month := 8; d.day := 5; t.hour := 10; t.minute := 5; t.second := 30; date := CtlT.OleDateFromDateAndTime(d, t); (* (day - 1.1.1900 + 2) + hour / 24 + minute / (24 * 60) + ... *) range := ws.Range(CtlT.Str("C1"), NIL); range.PUTValue(CtlT.Date(date)); range.PUTColumnWidth(CtlT.Int(15)); cy := 133500; (* 13.35 *) ws.Range(CtlT.Str("D1"), NIL).PUTValue(CtlT.Cy(cy)); a[0] := 1; a[1] := 2; a[2] := 3; ws.Range(CtlT.Str("A2"), CtlT.Str("C2")).PUTValue(CtlT.IntArr(a)); ws.Range(CtlT.Str("D2"), NIL).PUTValue(CtlT.Str("=A2+B2+C2")); text := TextModels.dir.New(); out.ConnectTo(text); out.WriteString("Excel Automation Example"); out.WriteLn; out.WriteLn; out.WriteLn; out.WriteTab; out.WriteTab; out.WriteView(v); out.WriteLn; out.WriteLn; out.WriteLn; Views.OpenView(TextViews.dir.New(text)); ELSE StdLog.String("cannot open excel object"); StdLog.Ln END END ShowExcel; PROCEDURE ReadExcel*; VAR v: Views.View; ws: CtlExcel.Worksheet; obj: CtlT.Object; p: POINTER TO ARRAY OF ARRAY OF CtlT.Any; val, cell: CtlT.Any; r, c: INTEGER; date: Dates.Date; time: Dates.Time; str: ARRAY 256 OF CHAR; BEGIN v := Containers.FocusSingleton(); IF v # NIL THEN IF OleViews.IsAutoView(v) THEN obj:= OleViews.AutoObject(v); IF CtlExcel.Is_Workbook(obj) THEN ws := CtlExcel.This_Worksheet(CtlExcel.This_Workbook(obj).Worksheets().Item(CtlT.Int(1))); val := ws.Range(CtlT.Str("A1"), CtlT.Str("E5")).Value(); ASSERT(val # NIL, 10); ASSERT(val.dim = 2, 11); ASSERT(val.typeId = CtlT.any, 12); p := val(CtlT.AnyArray2).p; r := 0; StdLog.Int(LEN(p^)); StdLog.Int(LEN(p^, 1)); StdLog.Ln; WHILE r < LEN(p^) DO c := 0; WHILE c < LEN(p^, 1) DO cell := p[r, c]; IF cell # NIL THEN ASSERT(cell.dim = 0, 13); StdLog.String("Cell "); StdLog.Char(CHR(c + ORD("A"))); StdLog.Int(r); StdLog.String(": "); CASE cell.typeId OF | CtlT.byte: StdLog.Int(cell(CtlT.ByteT).val) | CtlT.shortint: StdLog.Int(cell(CtlT.ShortInt).val) | CtlT.integer: StdLog.Int(cell(CtlT.Integer).val) | CtlT.shortreal: StdLog.Real(cell(CtlT.ShortReal).val) | CtlT.real: StdLog.Real(cell(CtlT.RealT).val) | CtlT.result: StdLog.IntForm(cell(CtlT.Result).val, 16, 8, "0", FALSE) | CtlT.date: CtlT.OleDateToDateAndTime(cell(CtlT.DateT).val, date, time); Dates.DateToString(date, Dates.short, str); StdLog.String(str); StdLog.String(" "); Dates.TimeToString(time, str); StdLog.String(str) | CtlT.currency: StdLog.Int(SHORT(cell(CtlT.Currency).val DIV 10000)); StdLog.Char("."); StdLog.IntForm(SHORT(cell(CtlT.Currency).val MOD 10000), 10, 4, "0", FALSE); | CtlT.boolean: StdLog.Bool(cell(CtlT.Boolean).val) | CtlT.string: StdLog.String(cell(CtlT.String).val^) | CtlT.object: StdLog.String("<object>") | CtlT.interface: StdLog.String("<interface>") END; StdLog.Ln END; INC(c) END; INC(r) END ELSE StdLog.String("not a worksheet"); StdLog.Ln END ELSE StdLog.String("not an OLE object"); StdLog.Ln END ELSE StdLog.String("no singleton"); StdLog.Ln END END ReadExcel; PROCEDURE OpenChart*; VAR ws: CtlExcel.Worksheet; wb: CtlExcel.Workbook; ch: CtlExcel.Chart; obj: CtlT.Object; v: Views.View; a: CtlExcel.Application; BEGIN v := Containers.FocusSingleton(); IF v # NIL THEN IF OleViews.IsAutoView(v) THEN obj:= OleViews.AutoObject(v); IF CtlExcel.Is_Workbook(obj) THEN ws := CtlExcel.This_Worksheet(CtlExcel.This_Workbook(obj).Worksheets().Item(CtlT.Int(1))); a := ws.Application(); a.PUTVisible(TRUE); wb := a.Workbooks().Add(NIL); ch := CtlExcel.This_Chart(wb.Sheets().Add(NIL, NIL, NIL, CtlT.Int(CtlExcel.xlChart))); ch.ChartWizard(ws.Range(CtlT.Str("A2"), CtlT.Str("E2")), CtlT.Int(CtlExcel.xlBar), NIL, NIL, NIL, NIL, NIL, CtlT.Str("Demo Chart"), NIL, NIL, NIL); ELSE StdLog.String("not a worksheet"); StdLog.Ln END ELSE StdLog.String("not an OLE object"); StdLog.Ln END ELSE StdLog.String("no singleton"); StdLog.Ln END END OpenChart; END ObxExcel.

Ctl/Docu/Excel9.odc

CtlGraph9 CtlGraph9 contains the automation interface for Microsoft Graph 9.0. The objects contained in this module are explained in the corresponding help file (VBAGRP9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/Graph9.odc

CtlMSForms CtlMSForms contains the automation interface for Microsoft Forms 2.0. The objects contained in this module are explained in the corresponding help file (FM20.HLP) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/MSForms.odc

CtlOffice CtlOffice contains the automation interface for Microsoft Office 9.0, which is compatible to the interface of version 8.0. The objects contained in this module are explained in the corresponding help file (VBAOFF9.CHM or VBAOFF8.HLP for Office 8.0) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/Office.odc

CtlOfficeBinder CtlOfficeBinder contains the automation interface for Microsoft Binder 9.0, which is equal to the interface of version 8.0. The objects contained in this module are explained in the corresponding help file (VBABDR8.HLP) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/OfficeBinder.odc

CtlOutlook9 CtlOutlook9 contains the automation interface for Microsoft Outlook 9.0. The objects contained in this module are explained in the corresponding help file (VBAOUTL9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/Outlook9.odc

CtlPowerPoint9 CtlPowerPoint9 contains the automation interface for Microsoft PowerPoint 9.0. The objects contained in this module are explained in the corresponding help file (VBAPPT9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/PowerPoint9.odc

CtlStdType This module has a private interface, it is only used internally (by code generated with the OLE Automation generator DevComInterfaceGen).

Ctl/Docu/StdType.odc

Map to the Ctl Subsystem DeveloperManual T base module for automation Excel9 MS Excel 9.0 automation interface Word9 MS Word 9.0 automation interface Outlook9 MS Outlook 9.0 automation interface PowerPoint9 MS PowerPoint 9.0 automation interface Access9 MS Access 9.0 automation interface Graph9 MS Graph 9.0 automation interface Office MS Office 9.0 automation interface OfficeBinder MS Binder 9.0 automation interface MSForms MS Forms 2.0 automation interface DAO36 MS Data Access Objects 3.6 automation interface ADODB MS ActiveX Data Objects 2.0 automation interface VBIDE MS Visual Basic automation interface

Ctl/Docu/Sys-Map.odc

CtlT DEFINITION CtlT; IMPORT Dates; CONST shortint = 2; integer = 3; shortreal = 4; real = 5; currency = 6; date = 7; string = 8; object = 9; result = 10; boolean = 11; any = 12; interface = 13; byte = 17; enumerator = -1; TYPE Strg = POINTER TO ARRAY OF CHAR; OleCy = LONGINT; OleDate = REAL; IUnknown = COM.IUnknown; IDispatch = WinOleAut.IDispatch; RESULT = INTEGER; GUID = COM.GUID; Variant = WinOleAut.VARIANT; ParList = ARRAY [untagged] OF Variant; Any = POINTER TO ABSTRACT RECORD typeId, dim: SHORTINT; (x: Any) Bool (): BOOLEAN, NEW, EXTENSIBLE; (x: Any) Byte (): BYTE, NEW, EXTENSIBLE; (x: Any) Cy (): OleCy, NEW, EXTENSIBLE; (x: Any) Date (): OleDate, NEW, EXTENSIBLE; (x: Any) Int (): INTEGER, NEW, EXTENSIBLE; (x: Any) Real (): REAL, NEW, EXTENSIBLE; (x: Any) SInt (): SHORTINT, NEW, EXTENSIBLE; (x: Any) SReal (): SHORTREAL, NEW, EXTENSIBLE; (x: Any) Str (): Strg, NEW, EXTENSIBLE END; Object = POINTER TO ABSTRACT RECORD (Any) disp: IDispatch END; OutObject = POINTER TO ABSTRACT RECORD (Object) source: Object; (obj: OutObject) GetIID (OUT iid: GUID), NEW, ABSTRACT; (obj: OutObject) Invoke (id, n: INTEGER; VAR [nil] par: ParList; VAR [nil] ret: Variant), NEW, ABSTRACT END; ByteT = POINTER TO RECORD (Any) val: BYTE END; ShortInt = POINTER TO RECORD (Any) val: SHORTINT END; Integer = POINTER TO RECORD (Any) val: INTEGER END; ShortReal = POINTER TO RECORD (Any) val: SHORTREAL END; RealT = POINTER TO RECORD (Any) val: REAL END; Boolean = POINTER TO RECORD (Any) val: BOOLEAN END; Result = POINTER TO RECORD (Any) val: RESULT END; Currency = POINTER TO RECORD (Any) val: OleCy END; DateT = POINTER TO RECORD (Any) val: OleDate END; String = POINTER TO RECORD (Any) val: Strg END; Interface = POINTER TO RECORD (Any) val: IUnknown END; AnyArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF Any END; ObjectArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF Object END; ByteArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF BYTE END; ShortIntArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF SHORTINT END; IntegerArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF INTEGER END; ShortRealArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF SHORTREAL END; RealArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF REAL END; BooleanArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF BOOLEAN END; ResultArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF RESULT END; CurrencyArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF OleCy END; DateArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF OleDate END; StringArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF Strg END; InterfaceArray = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF IUnknown END; AnyArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF Any END; ObjectArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF Object END; ByteArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF BYTE END; ShortIntArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF SHORTINT END; IntegerArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF INTEGER END; ShortRealArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF SHORTREAL END; RealArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF REAL END; BooleanArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF BOOLEAN END; ResultArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF RESULT END; CurrencyArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF OleCy END; DateArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF OleDate END; StringArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF Strg END; InterfaceArray2 = POINTER TO RECORD (Any) p: POINTER TO ARRAY OF ARRAY OF IUnknown END; Enumerator = POINTER TO ABSTRACT RECORD (e: Enumerator) First (): Any, NEW, ABSTRACT; (e: Enumerator) Next (): Any, NEW, ABSTRACT END; VAR context: SET; lcid: INTEGER; PROCEDURE OleDateFromDateAndTime (IN date: Dates.Date; IN time: Dates.Time): OleDate; PROCEDURE OleDateToDateAndTime (d: OleDate; OUT date: Dates.Date; OUT time: Dates.Time); PROCEDURE Obj (disp: IDispatch): Object; PROCEDURE Byte (val: BYTE): ByteT; PROCEDURE SInt (val: SHORTINT): ShortInt; PROCEDURE Int (val: INTEGER): Integer; PROCEDURE SReal (val: SHORTREAL): ShortReal; PROCEDURE Real (val: REAL): RealT; PROCEDURE Bool (val: BOOLEAN): Boolean; PROCEDURE Res (val: RESULT): Result; PROCEDURE Cy (val: OleCy): Currency; PROCEDURE Date (val: OleDate): DateT; PROCEDURE Str (IN val: ARRAY OF CHAR): String; PROCEDURE Intfce (val: IUnknown): Interface; PROCEDURE AnyArr (IN val: ARRAY OF Any): AnyArray; PROCEDURE ObjArr (IN val: ARRAY OF Object): ObjectArray; PROCEDURE ByteArr (IN val: ARRAY OF BYTE): ByteArray; PROCEDURE SIntArr (IN val: ARRAY OF SHORTINT): ShortIntArray; PROCEDURE IntArr (IN val: ARRAY OF INTEGER): IntegerArray; PROCEDURE SRealArr (IN val: ARRAY OF SHORTREAL): ShortRealArray; PROCEDURE RealArr (IN val: ARRAY OF REAL): RealArray; PROCEDURE BoolArr (IN val: ARRAY OF BOOLEAN): BooleanArray; PROCEDURE ResArr (IN val: ARRAY OF RESULT): ResultArray; PROCEDURE CyArr (IN val: ARRAY OF OleCy): CurrencyArray; PROCEDURE DateArr (IN val: ARRAY OF OleDate): DateArray; PROCEDURE StrArr (IN val: ARRAY OF Strg): StringArray; PROCEDURE IntfceArr (IN val: ARRAY OF IUnknown): InterfaceArray; PROCEDURE AnyArr2 (IN val: ARRAY OF ARRAY OF Any): AnyArray2; PROCEDURE ObjArr2 (IN val: ARRAY OF ARRAY OF Object): ObjectArray2; PROCEDURE ByteArr2 (IN val: ARRAY OF ARRAY OF BYTE): ByteArray2; PROCEDURE SIntArr2 (IN val: ARRAY OF ARRAY OF SHORTINT): ShortIntArray2; PROCEDURE IntArr2 (IN val: ARRAY OF ARRAY OF INTEGER): IntegerArray2; PROCEDURE SRealArr2 (IN val: ARRAY OF ARRAY OF SHORTREAL): ShortRealArray2; PROCEDURE RealArr2 (IN val: ARRAY OF ARRAY OF REAL): RealArray2; PROCEDURE BoolArr2 (IN val: ARRAY OF ARRAY OF BOOLEAN): BooleanArray2; PROCEDURE ResArr2 (IN val: ARRAY OF ARRAY OF RESULT): ResultArray2; PROCEDURE CyArr2 (IN val: ARRAY OF ARRAY OF OleCy): CurrencyArray2; PROCEDURE DateArr2 (IN val: ARRAY OF ARRAY OF OleDate): DateArray2; PROCEDURE StrArr2 (IN val: ARRAY OF ARRAY OF Strg): StringArray2; PROCEDURE IntfceArr2 (IN val: ARRAY OF ARRAY OF IUnknown): InterfaceArray2; PROCEDURE Connect (sink: OutObject; source: Object); PROCEDURE Disconnect (sink: OutObject; source: Object); PROCEDURE Disp (obj: Object): IDispatch; END CtlT. Base module for OLE automation controller applications. For an introduction to automation controller development see the DeveloperManual. CONST any, object, byte, shortint, integer, shortreal, real, boolean, result, currency, date, string, interface, enumerator Constants used as values of the typeId field of type Any. TYPE Strg Basic string type. Used for string-typed out- and in/out-parameters and return values. For in-parameters the type ARRAY OF CHAR is used to permit string constants as actual parameters. TYPE OleCy Basic currency type used in OLE. OleCy is a fixed point number with 4 decimal digits after the decimal point, stored in a 64 bit integer. The integer value 73500 corresponds to the currency value 7.35. TYPE OleDate Basic date/time type used in OLE. OleDate is a 64 bit floating point number containing a fractional day count. The value 2.0 corresponds to midnight 1.1.1900. The exact conversion formula is: x := ((second / 60 + minute) / 60 + hour) / 24 + day + 2 where x is the resulting real number and day is the day count since 1.1.1900. The procedures OleDateFromDateAndTime and OleDateToDateAndTime are provided for conversions between OleDate and the BlackBox types Dates.Date amd Dates.Time. TYPE IUnknown, IDispatch, RESULT, GUID, Variant, ParList OLE types used internally in the automation interface modules. TYPE Any ABSTRACT Base type of all automation types. Covers all possible automation types including arrays. Any is used if the type of a parameter of an automation method is not statically defined. NIL can be used for parameters of type Any if the parameter is not used at all (legal for optional parameters). typeId: SHORTINT dim: SHORTINT Type and (array-) dimension of the represented value. dim is 0 for a scalar value and > 0 for an array. typeId can be one of the basic types byte, shortint, integer, shortreal, real, boolean, result, currency, date, string, or interface; or one of the special types object, enumerator, or any. typeId = enumerator implies dim = 0. typeId = any is only used with dim > 0 and means an array with unspecified or inhomogeneous element type. PROCEDURE (x: Any) Bool (): BOOLEAN PROCEDURE (x: Any) Byte (): BYTE PROCEDURE (x: Any) Cy (): OleCy PROCEDURE (x: Any) Date (): OleDate PROCEDURE (x: Any) Int (): INTEGER PROCEDURE (x: Any) Real (): REAL PROCEDURE (x: Any) SInt (): SHORTINT PROCEDURE (x: Any) SReal (): SHORTREAL PROCEDURE (x: Any) Str (): Strg NEW, EXTENSIBLE Used for convenient access to basic type values. Values are converted to the return type if necessary. Pre value type is convertible to result type 20 TYPE Object (Any) ABSTRACT Base type of all automation objects implemented in automation interface modules. disp: IDispatch Used internally. TYPE OutObject (Object) ABSTRACT Base type of all callback objects. An abstract extension with the specific methods is declared in the automation interface module. A concrete implementation can be declared in a user module and connected to an event source by Connect or OleViews.Connect. source: Object; The connected source object. PROCEDURE (obj: OutObject) GetIID (OUT iid: GUID) PROCEDURE (obj: OutObject) Invoke (id, n: INTEGER; VAR [nil] par: ParList; VAR [nil] ret: Variant), NEW, ABSTRACT Implemented in the automation interface module, used internally. TYPE ByteT, ShortInt, Integer, ShortReal, RealT, Boolean, Result, Currency, DateT, String, Interface Concrete implementations of scalar basic type objects. val: <type> Actual value. TYPE AnyArray, ObjectArray, ByteArray, ShortIntArray, IntegerArray, ShortRealArray, RealArray, BooleanArray, ResultArray, CurrencyArray, DateArray, StringArray, InterfaceArray Concrete implementations of one-dimensional array objects. p: POINTER TO ARRAY OF <type> Actual values. TYPE AnyArray2, ObjectArray2, ByteArray2, ShortIntArray2, IntegerArray2, ShortRealArray2, RealArray2, BooleanArray2, ResultArray2, CurrencyArray2, DateArray2, StringArray2, InterfaceArray2 Concrete implementations of two-dimensional array objects. p: POINTER TO ARRAY OF ARRAY OF <type> Actual values. TYPE Enumerator ABSTRACT Base type of enumerators. Enumerators are used to access all elements of a collection object in a systematic way. A concrete enumerator can be requested from a collection object through the method _NewEnum. PROCEDURE (e: Enumerator) First (): Any NEW, ABSTRACT Returns the first object from a collection or NIL if the collection is empty. PROCEDURE (e: Enumerator) Next (): Any NEW, ABSTRACT Returns the next consecutive object from a collection or NIL if the there are no more objects in the collection. VAR context: SET The COM object allocation contect used to allocate new automation objects. Initialized to WinOle.CLSCTX_INPROC_SERVER + WinOle.CLSCTX_LOCAL_SERVER. Can be changed if a different allocation context should be used. VAR lcid: INTEGER The language identifier used in automation method calls. Initialized to WinApi.LOCALE_SYSTEM_DEFAULT . Can be changed if a different language identifier should be used. PROCEDURE OleDateFromDateAndTime (IN date: Dates.Date; IN time: Dates.Time): OleDate Converts BlackBox Date and Time structures to an OleDate value. PROCEDURE OleDateToDateAndTime (d: OleDate; OUT date: Dates.Date; OUT time: Dates.Time) Converts an OleDate value to BlackBox Date and Time structures. PROCEDURE Connect (sink: OutObject; source: Object) Used to connect a callback object (an object implementing a callback interface) to an event source. Pre sink is not connected 20 source is connectable 21 PROCEDURE Disconnect (sink: OutObject; source: Object) Used to disconnect a callback object (an object implementing a callback interface) from an event source. Pre sink is connected to source 20 PROCEDURE Obj (disp: IDispatch): Object PROCEDURE Byte (val: BYTE): ByteT PROCEDURE SInt (val: SHORTINT): ShortInt PROCEDURE Int (val: INTEGER): Integer PROCEDURE SReal (val: SHORTREAL): ShortReal PROCEDURE Real (val: REAL): RealT PROCEDURE Bool (val: BOOLEAN): Boolean PROCEDURE Res (val: RESULT): Result PROCEDURE Cy (val: OleCy): Currency PROCEDURE Date (val: OleDate): DateT PROCEDURE Str (IN val: ARRAY OF CHAR): String PROCEDURE Intfce (val: IUnknown): Interface Generator functions for scalar basic type objects. PROCEDURE AnyArr (IN val: ARRAY OF Any): AnyArray PROCEDURE ObjArr (IN val: ARRAY OF Object): ObjectArray PROCEDURE ByteArr (IN val: ARRAY OF BYTE): ByteArray PROCEDURE SIntArr (IN val: ARRAY OF SHORTINT): ShortIntArray PROCEDURE IntArr (IN val: ARRAY OF INTEGER): IntegerArray PROCEDURE SRealArr (IN val: ARRAY OF SHORTREAL): ShortRealArray PROCEDURE RealArr (IN val: ARRAY OF REAL): RealArray PROCEDURE BoolArr (IN val: ARRAY OF BOOLEAN): BooleanArray PROCEDURE ResArr (IN val: ARRAY OF RESULT): ResultArray PROCEDURE CyArr (IN val: ARRAY OF OleCy): CurrencyArray PROCEDURE DateArr (IN val: ARRAY OF OleDate): DateArray PROCEDURE StrArr (IN val: ARRAY OF Strg): StringArray PROCEDURE IntfceArr (IN val: ARRAY OF IUnknown): InterfaceArray Generator functions for one-dimensional array objects. PROCEDURE AnyArr2 (IN val: ARRAY OF ARRAY OF Any): AnyArray2 PROCEDURE ObjArr2 (IN val: ARRAY OF ARRAY OF Object): ObjectArray2 PROCEDURE ByteArr2 (IN val: ARRAY OF ARRAY OF BYTE): ByteArray2 PROCEDURE SIntArr2 (IN val: ARRAY OF ARRAY OF SHORTINT): ShortIntArray2 PROCEDURE IntArr2 (IN val: ARRAY OF ARRAY OF INTEGER): IntegerArray2 PROCEDURE SRealArr2 (IN val: ARRAY OF ARRAY OF SHORTREAL): ShortRealArray2 PROCEDURE RealArr2 (IN val: ARRAY OF ARRAY OF REAL): RealArray2 PROCEDURE BoolArr2 (IN val: ARRAY OF ARRAY OF BOOLEAN): BooleanArray2 PROCEDURE ResArr2 (IN val: ARRAY OF ARRAY OF RESULT): ResultArray2 PROCEDURE CyArr2 (IN val: ARRAY OF ARRAY OF OleCy): CurrencyArray2 PROCEDURE DateArr2 (IN val: ARRAY OF ARRAY OF OleDate): DateArray2 PROCEDURE StrArr2 (IN val: ARRAY OF ARRAY OF Strg): StringArray2 PROCEDURE IntfceArr2 (IN val: ARRAY OF ARRAY OF IUnknown): InterfaceArray2 Generator functions for two-dimensional array objects. PROCEDURE Disp (obj: Object): IDispatch Used internally.

Ctl/Docu/T.odc

CtlVBIDE CtlVBIDE contains the automation interface for Microsoft Visual Basic for Applications (for its integrated development environment). The objects contained in this module are explained in the corresponding Microsoft help file (VEENOB3.HLP). For more information about automation controllers in BlackBox see the CtlDocu.

Ctl/Docu/VBIDE.odc

CtlWord9 CtlWord9 contains the automation interface for Microsoft Word 9.0. The objects contained in this module are explained in the corresponding help file (VBAWRD9.CHM) which is located on the MS Office CD but is not installed by default. For more information about automation controllers in BlackBox see the CtlDocu. Since all calls to the CtlWord9 interface go across the border of the process, they are not as efficient as ordenary calls in BlackBox. They can be as much as 50.000 times slower. Getting Started The interface of CtlWord9 is quite big, but generally not difficult to understand. To start with, there are only a few Objects Types that need to be known. Look at the Interface of CtlWord9 for more. CtlWord9.Application Represents the Word application. A new application can be obtained by calling NewApplication() which starts a new Word application and returns a application object. Windows might reuse this application when the user starts Word himself. Therefore closing an application object might also close documents of the user, while not closing it leaves a unused Word application in the memory. It is recommended never to open or close applications by yourself. Use the following procedures instead to get an Application object: VAR app: CtlWord9.Application; connect_doc: CtlWord9.Document; PROCEDURE Connect; BEGIN connect_doc := CtlWord9.NewDocument(); connect_doc.Windows().Item(CtlT.Int(1)).PUTVisible(FALSE); app := connect_doc.Application() END Connect; PROCEDURE Disconnect; BEGIN connect_doc.Close(NIL, NIL, NIL); app := NIL END Disconnect; CtlWord9.Document Represents a Word document. Such a document can be obtained by calling the methods app.ActiveDocument(), app.Documents().Item(CtlT.Int(1)), app.Documents().Add(NIL, NIL, NIL, NIL) and app.Documents().Open(CtlT.Str(filename), NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL) where app is an application object, or simply by calling CtlWord9.NewDocument(). CtlWord9.Range Represents a part of the content of a document. It can be obtained in various ways from a document. The easiest way is to use the method CtlWord9.Document.Range(CtlT.Int(beg),CtlT.Int(end)) to access a part of the document, or CtlWord9.Document.Content() to get its whole content. To edit the text of a Range, the methods CtlWord9.Range.Text() and CtlWord9.Range.PUTText() can be used. The location of the Range can be moved by various CtlWord9.Range.MoveXXX methods, the CtlWord9.Range.Next method or by setting the start and the end point to a different value with CtlWord9.Range.PUTStart and CtlWord9.Range.PUTEnd. CtlWord9.Font Represents a font of a text. It can be obtained from a CtlWord9.Range object by calling the CtlWord9.Range.Font() method. Attention: Since the font of a Range might not be homogeneous, not all properties might be defined. A good starting point to use CtlWord9 is also the ObxWordEditExample. MODULE ObxWordEdit; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" purpose = "Some examples of how the Word Automation Interface 9.0 can be used." changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) IMPORT CtlWord9, CtlT, StdLog, Fonts, Services; VAR app: CtlWord9.Application; connectDoc: CtlWord9.Document; PROCEDURE GetApplication (): CtlWord9.Application; BEGIN RETURN app END GetApplication; (* Connecting / Disconnecting *) PROCEDURE Connect*; (* Connects to a Word application. If Word is not running, it is started. *) BEGIN connectDoc := CtlWord9.NewDocument(); connectDoc.Windows().Item(CtlT.Int(1)).PUTVisible(FALSE); app := connectDoc.Application(); StdLog.String(' Connected to Word.'); StdLog.Ln() END Connect; PROCEDURE Disconnect*; (* Disconnects from Word. If nobody else is using the application, it is terminated. *) BEGIN connectDoc.Close(NIL, NIL, NIL); app := NIL; StdLog.String(' Disconnected to Word.'); StdLog.Ln() END Disconnect; (* Starting / Quitting *) PROCEDURE Start*; (* Starts a new Word application. *) BEGIN app := CtlWord9.NewApplication(); app.Options().PUTSmartCutPaste(FALSE); app.PUTVisible(TRUE); StdLog.String(' Word started.'); StdLog.Ln() END Start; PROCEDURE Quit*; (* Quits Word. *) BEGIN app.Quit(CtlT.Bool(FALSE),NIL,NIL); app := NIL; StdLog.String(' Word quited.'); StdLog.Ln() END Quit; PROCEDURE Restart*; (* Restarts Word. *) BEGIN Quit; Start END Restart; (* File *) PROCEDURE NewDoc*; (* Creates a new document using CtlWord9.NewDocument() and makes it visible. *) (* The document is created in the oldest running Word. If there is no Word running, it is started. *) VAR doc: CtlWord9.Document; BEGIN doc := CtlWord9.NewDocument(); doc.Windows().Item(CtlT.Int(1)).PUTVisible(TRUE); StdLog.String("New Document created. "); StdLog.Ln END NewDoc; PROCEDURE CreateDoc*; (* Creates a new, visible document using CtlWord9.Application.Documents().Add. *) (* It is only visible, if the application is visible. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().Documents().Add(NIL, NIL, NIL, CtlT.Bool(TRUE)); StdLog.String(' Document '); StdLog.String(doc.FullName()); StdLog.String(' created.'); StdLog.Ln END CreateDoc; PROCEDURE CreateInvisibleDoc*; (* Creates a new, invisible document. It is also invisible, if the application is visible. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().Documents().Add(NIL, NIL, NIL, CtlT.Bool(FALSE)); StdLog.String(' Document '); StdLog.String(doc.FullName()); StdLog.String(' created invisible.'); StdLog.Ln END CreateInvisibleDoc; PROCEDURE OpenDoc (filename: ARRAY OF CHAR); (* Opens the file filename. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().Documents().Open(CtlT.Str(filename),NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL); StdLog.String(' Document '); StdLog.String(doc.FullName()); StdLog.String(' opened.'); StdLog.Ln END OpenDoc; PROCEDURE OpenDocTest*; (* Opens a test file. *) BEGIN OpenDoc('D:\Users\Juerg\test.doc') END OpenDocTest; PROCEDURE CloseDoc*; (* Closes the active document without saving. *) VAR doc: CtlWord9.Document; name: CtlT.Strg; BEGIN doc := GetApplication().ActiveDocument(); name := doc.FullName(); doc.Close(CtlT.Int(CtlWord9.wdDoNotSaveChanges),NIL,NIL); StdLog.String(' Document '); StdLog.String(name); StdLog.String(' closed.'); StdLog.Ln END CloseDoc; PROCEDURE SaveAndCloseDoc*; (* Saves the active document and closes it. *) VAR doc: CtlWord9.Document; name: CtlT.Strg; BEGIN doc := GetApplication().ActiveDocument(); name := doc.FullName(); doc.Close(CtlT.Int(CtlWord9.wdSaveChanges),NIL,NIL); StdLog.String(' Document '); StdLog.String(name); StdLog.String(' saved and closed.'); StdLog.Ln END SaveAndCloseDoc; PROCEDURE SaveDoc*; (* Saves the active document. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); doc.Save; StdLog.String(' Document '); StdLog.String(doc.FullName()); StdLog.String(' saved.'); StdLog.Ln END SaveDoc; PROCEDURE Print*; (* Prints the active document. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); doc.PrintOut(NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL); StdLog.String(' Document '); StdLog.String(doc.FullName()); StdLog.String(' printed.'); StdLog.Ln END Print; (* Application *) PROCEDURE DispDocs*; (* Displays the full names of all the open documents. *) VAR count, i: INTEGER; docs: CtlWord9.Documents; BEGIN docs := GetApplication().Documents(); count := docs.Count(); StdLog.Int(count); StdLog.String(' Documents available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(docs.Item(CtlT.Int(i)).FullName()); StdLog.Ln END END DispDocs; PROCEDURE DispFontNames*; (* Displays the names of the available fonts in Word. *) VAR fontNames : CtlWord9.FontNames; count, i: INTEGER; BEGIN fontNames := GetApplication().FontNames(); count := fontNames.Count(); StdLog.Int(count); StdLog.String(' FontNames available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(fontNames.Item(i)); StdLog.Ln END END DispFontNames; PROCEDURE DispBBFontNames*; (* Displays the names of the available fonts in BlackBox. There are more than in Word. *) VAR t: Fonts.TypefaceInfo; BEGIN StdLog.String(' BB FontNames:'); t := Fonts.dir.TypefaceList(); WHILE t # NIL DO StdLog.String(t.typeface); StdLog.Ln; t := t.next END END DispBBFontNames; PROCEDURE DispLanguages*; (* Displays the languages available in Word. *) VAR count: INTEGER; languages: CtlWord9.Languages; lang: CtlWord9.Language; enum: CtlT.Enumerator; BEGIN languages := GetApplication().Languages(); count := languages.Count(); StdLog.Int(count); StdLog.String(' Languages available.'); StdLog.Ln; enum:= languages._NewEnum(); lang := CtlWord9.ThisLanguage(enum.First()); WHILE lang # NIL DO StdLog.String(lang.NameLocal()); StdLog.Ln; lang := CtlWord9.ThisLanguage(enum.Next()) END END DispLanguages; PROCEDURE DispLanguagesAndDictionaries*; (* Displays the languages available in Word and whether they have a dictionary. *) (* Attention: ActiveSpellingDictionary traps if there is no dictionary available... *) VAR count: INTEGER; languages : CtlWord9.Languages; lang: CtlWord9.Language; enum:CtlT.Enumerator; BEGIN languages := GetApplication().Languages(); count := languages.Count(); StdLog.Int(count); StdLog.String(' Languages available.'); StdLog.Ln; enum:= languages._NewEnum(); lang := CtlWord9.ThisLanguage(enum.First()); WHILE lang # NIL DO StdLog.String(lang.NameLocal()); IF lang.ActiveSpellingDictionary() # NIL THEN StdLog.String(' (Dict)') END; StdLog.Ln; lang := CtlWord9.ThisLanguage(enum.Next()) END END DispLanguagesAndDictionaries; PROCEDURE UseSmartCutPaste*; (* Sets the option SmartCutPaste. *) BEGIN GetApplication().Options().PUTSmartCutPaste(TRUE); StdLog.String(' SmartCutPaste turned on.'); StdLog.Ln END UseSmartCutPaste; (* Visibility *) PROCEDURE MakeWordVisible*; (* Makes all documents visible, also the ones that were created invisible. *) BEGIN GetApplication().PUTVisible(TRUE); StdLog.String(' Word made visible.'); StdLog.Ln END MakeWordVisible; PROCEDURE MakeWordInvisible*; (* Makes all documents invisible. *) BEGIN GetApplication().PUTVisible(FALSE); StdLog.String(' Word made invisible.'); StdLog.Ln END MakeWordInvisible; PROCEDURE MakeWinVisible*; (* Makes the first window of the active document visible. *) BEGIN GetApplication().ActiveDocument().Windows().Item(CtlT.Int(1)).PUTVisible(TRUE); StdLog.String(' Window made visible.'); StdLog.Ln END MakeWinVisible; PROCEDURE MakeWinInvisible*; (* Makes the first window of the active document invisible. *) BEGIN GetApplication().ActiveDocument().Windows().Item(CtlT.Int(1)).PUTVisible(FALSE); StdLog.String(' Window made invisible.'); StdLog.Ln END MakeWinInvisible; PROCEDURE IsWinVisible*; (* Displays whether the first window of the active document is visible. *) BEGIN StdLog.Bool(GetApplication().ActiveDocument().Windows().Item(CtlT.Int(1)).Visible()); StdLog.Ln END IsWinVisible; (* Document *) PROCEDURE Undo*; (* Undoes the last action. Actions, such a typing characters, can be merged to one action by Word. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); IF doc.Undo(CtlT.Int(1)) THEN StdLog.String(' Undone.') ELSE StdLog.String(' Undo not possible.') END; StdLog.Ln END Undo; PROCEDURE Redo*; (* Redoes the last undone action. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); IF doc.Redo(CtlT.Int(1)) THEN StdLog.String(' Redone.') ELSE StdLog.String(' Redo not possible.') END; StdLog.Ln END Redo; PROCEDURE Protect*; (* Protects the active document. *) BEGIN GetApplication().ActiveDocument().Protect(CtlWord9.wdAllowOnlyFormFields, NIL, NIL); StdLog.String('Document locked.'); StdLog.Ln END Protect; PROCEDURE Unprotect*; (* Unprotects the active document. *) BEGIN GetApplication().ActiveDocument().Unprotect(NIL); StdLog.String('Document unlocked.'); StdLog.Ln END Unprotect; (* Accessing the Content of a Document *) PROCEDURE DispContent*; (* Displays the content of the active document. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); StdLog.String('Document content: '); StdLog.String(doc.Content().Text()); StdLog.Ln END DispContent; PROCEDURE DispParagraphs*; (* Displays the paragraphs of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; paras: CtlWord9.Paragraphs; BEGIN doc := GetApplication().ActiveDocument(); paras := doc.Paragraphs(); count := paras.Count(); StdLog.Int(count); StdLog.String(' Paragraphs available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(paras.Item(i).Range().Text()); StdLog.Ln; StdLog.Ln END END DispParagraphs; PROCEDURE DispListParagraphs*; (* Displays the ListParagraphs of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; paras: CtlWord9.ListParagraphs; BEGIN doc := GetApplication().ActiveDocument(); paras := doc.ListParagraphs(); count := paras.Count(); StdLog.Int(count); StdLog.String(' ListParagraphs available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(paras.Item(i).Range().Text()); StdLog.Ln; StdLog.Ln END END DispListParagraphs; PROCEDURE DispLists*; (* Displays the Lists of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; lists: CtlWord9.Lists; BEGIN doc := GetApplication().ActiveDocument(); lists := doc.Lists(); count := lists.Count(); StdLog.Int(count); StdLog.String(' Lists available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(lists.Item(i).Range().Text()); StdLog.Ln; StdLog.Ln END END DispLists; PROCEDURE DispWords*; (* Displays the Words of the active document, using the CtlWord9.Document.Words method. *) VAR count, i: INTEGER; doc: CtlWord9.Document; words: CtlWord9.Words; BEGIN doc := GetApplication().ActiveDocument(); words := doc.Words(); count := words.Count(); StdLog.Int(count); StdLog.String(' Words available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(words.Item(i).Text()); StdLog.Ln END END DispWords; PROCEDURE DispWords2*; (* Displays the Words of the active document, using the CtlWord9.Range.Next method. *) VAR len: INTEGER; doc: CtlWord9.Document; r: CtlWord9.Range; BEGIN doc := GetApplication().ActiveDocument(); len := doc.Characters().Count(); r := doc.Range(CtlT.Int(0),CtlT.Int(0)); StdLog.String(' Words: '); StdLog.Ln; REPEAT r := r.Next(CtlT.Int(CtlWord9.wdWord), NIL); StdLog.String(r.Text()); StdLog.Ln UNTIL r.End() >= len END DispWords2; PROCEDURE DispWords3*; (* Displays the Words of the active document, using the CtlWord9.Range.MoveEnd method. *) VAR moved, lastEnd: INTEGER; doc: CtlWord9.Document; r: CtlWord9.Range; BEGIN doc := GetApplication().ActiveDocument(); r := doc.Range(CtlT.Int(0),CtlT.Int(0)); lastEnd := -1; StdLog.String(' Words: '); StdLog.Ln; REPEAT lastEnd := r.End(); moved := r.MoveEnd(CtlT.Int(CtlWord9.wdWord), CtlT.Int(1)); StdLog.String(r.Text()); StdLog.Ln; r.Collapse(CtlT.Int(CtlWord9.wdCollapseEnd)) UNTIL lastEnd = r.End() END DispWords3; PROCEDURE DispCharacters*; (* Displays the Characters of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; chars: CtlWord9.Characters; BEGIN doc := GetApplication().ActiveDocument(); chars := doc.Characters(); count := chars.Count(); StdLog.Int(count); StdLog.String(' Characters available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(chars.Item(i).Text()); StdLog.String(' ') END END DispCharacters; PROCEDURE DispSentences*; (* Displays the Sentences of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; sentences: CtlWord9.Sentences; BEGIN doc := GetApplication().ActiveDocument(); sentences := doc.Sentences(); count := sentences.Count(); StdLog.Int(count); StdLog.String(' Sentences available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(sentences.Item(i).Text()); StdLog.Ln; StdLog.Ln END END DispSentences; PROCEDURE DispStoryRanges*; (* Displays the StoryRanges of the active document. *) VAR count, i: INTEGER; doc: CtlWord9.Document; storyRanges: CtlWord9.StoryRanges; BEGIN doc := GetApplication().ActiveDocument(); storyRanges := doc.StoryRanges(); count := storyRanges.Count(); StdLog.Int(count); StdLog.String(' StoryRanges available.'); StdLog.Ln; FOR i := 1 TO count DO StdLog.String(storyRanges.Item(i).Text()); StdLog.Ln; StdLog.Ln END END DispStoryRanges; PROCEDURE DispRuns*; (* Should write the runs of the active document, but it does not work! How can we get the runs? *) VAR len: INTEGER; doc: CtlWord9.Document; r: CtlWord9.Range; BEGIN doc := GetApplication().ActiveDocument(); len := doc.Characters().Count(); r := doc.Range(CtlT.Int(0),CtlT.Int(0)); StdLog.String('Runs: '); StdLog.Ln; REPEAT r := r.Next(CtlT.Int(CtlWord9.wdCharacterFormatting), NIL); StdLog.String(r.Text()); StdLog.Ln UNTIL r.End() >= len END DispRuns; (* Editing Text *) PROCEDURE AppendThisText*; (* Appends "This Text" to the end of the active document. This means that it is insert in front of the last 0DX. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); doc.Content().InsertAfter('This Text'); StdLog.String('This Text appended.'); StdLog.Ln END AppendThisText; PROCEDURE OverwriteLastCharWithA*; (* Overwrites the last character, which is always a 0DX, with "A". Word then inserts a new 0DX at the end. *) VAR count: INTEGER; doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); count := doc.Characters().Count(); doc.Range(CtlT.Int(count-1), CtlT.Int(count)).PUTText('A'); StdLog.String('Last Character overwritten.'); StdLog.Ln END OverwriteLastCharWithA; PROCEDURE CopyText*; (* Copies and inserts the first 10 chars at the beginning of the active document. *) VAR doc: CtlWord9.Document; text: CtlT.Strg; BEGIN doc := GetApplication().ActiveDocument(); text := doc.Range(CtlT.Int(0),CtlT.Int(10)).Text(); doc.Range(CtlT.Int(0),CtlT.Int(0)).PUTText(text); StdLog.String('Text copied.'); StdLog.Ln END CopyText; PROCEDURE CopyFormattedText*; (* Copies and inserts the first 10 chars at the beginning of the active document, formatted. *) VAR doc: CtlWord9.Document; formattedText: CtlWord9.Range; BEGIN doc := GetApplication().ActiveDocument(); formattedText := doc.Range(CtlT.Int(0),CtlT.Int(10)).FormattedText(); doc.Range(CtlT.Int(0),CtlT.Int(0)).PUTFormattedText(formattedText); StdLog.String('Formatted text copied.'); StdLog.Ln END CopyFormattedText; PROCEDURE DeleteText*; (* Deletes the first 10 character of the active document. *) VAR doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); doc.Range(CtlT.Int(0),CtlT.Int(10)).PUTText(''); StdLog.String('Text deleted.'); StdLog.Ln END DeleteText; (* Font *) PROCEDURE Disp2ndParagraphFontName*; (* Displays the name of the font of the 2nd paragraph of the active document, if it is defined. *) VAR doc: CtlWord9.Document; fontName: ARRAY 100 OF CHAR; BEGIN doc := GetApplication().ActiveDocument(); fontName := doc.Paragraphs().Item(2).Range().Font().Name()$; IF fontName[0] = 0X THEN StdLog.String('2nd Paragraph Font Name is not defined (result = empty string)') ELSE StdLog.String('2nd Paragraph Font Name = '); StdLog.String(fontName) END; StdLog.Ln END Disp2ndParagraphFontName; PROCEDURE Is1stParagraphBold*; (* Displays whether the 1st paragraph of the active document is bold or not, if it is defined. *) VAR bold: INTEGER; doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); bold := doc.Paragraphs().Item(1).Range().Bold(); StdLog.String('The first paragraph '); IF bold = 0 THEN StdLog.String('is Not Bold') ELSIF bold = -1 THEN StdLog.String('is Bold') ELSE StdLog.String('is neither Bold nor Not Bold') END; StdLog.String(' (result = '); StdLog.Int(bold); StdLog.String(')'); StdLog.Ln END Is1stParagraphBold; PROCEDURE Disp1stParagraphFontSize*; (* Displays the size of the font of the 1st paragraph of the active document, if it is defined. *) VAR size: SHORTREAL; doc: CtlWord9.Document; BEGIN doc := GetApplication().ActiveDocument(); StdLog.String('The first paragraph: size ='); size := doc.Paragraphs().Item(1).Range().Font().Size(); IF size # CtlWord9.wdUndefined THEN StdLog.Real(size) ELSE StdLog.String('undefined (result = '); StdLog.Real(size); StdLog.String(' )') END; StdLog.Ln END Disp1stParagraphFontSize; (* Performance *) PROCEDURE Performance*; CONST wordTries = 1000; bbTries = 100000000; VAR start, counterTime, wordTime, bbTime : LONGINT; i : INTEGER; opt: CtlWord9.Options; PROCEDURE Put (newValue: BOOLEAN); VAR value: BOOLEAN; BEGIN value := newValue END Put; BEGIN IF app = NIL THEN Start END; opt := GetApplication().Options(); start:= Services.Ticks(); FOR i := 1 TO wordTries DO END; counterTime := Services.Ticks() - start; start:= Services.Ticks(); FOR i := 1 TO wordTries DO opt.PUTSmartCutPaste(TRUE) END; wordTime := Services.Ticks() - start - counterTime; StdLog.Int(wordTries); StdLog.String(" PUTSmartCutPaste took "); StdLog.Real(wordTime / Services.resolution); StdLog.String(" sec."); StdLog.Ln; start:= Services.Ticks(); FOR i := 1 TO bbTries DO END; counterTime := Services.Ticks() - start; start := Services.Ticks(); FOR i := 1 TO bbTries DO Put(TRUE) END; bbTime := Services.Ticks() - start - counterTime; StdLog.Int(bbTries); StdLog.String(" BlackBox procedure calls took "); StdLog.Real(bbTime / Services.resolution); StdLog.String(" sec."); StdLog.Ln; StdLog.String("Properties are "); StdLog.Int( (wordTime * bbTries) DIV (bbTime * wordTries)); StdLog.String(" times slower."); StdLog.Ln END Performance; END ObxWordEdit. ObxWordEditExample Stumbling Blocks Here are some things we found out using Word with this interface and which one might expect to be differently. - The CtlWord9.NewApplication() method always creates a new application. If the user also opens a new Word application and there is no Word running, the user gets the SAME application as BlackBox. Never expect that you are the only one using the application. If you documents are invisible, the user sees that there are other documents open in the Window menu, but he is not able to access them. - The CtlWord9.NewDocument() method creates a new document in the oldest running Word. It has the same effect as if the user chooses Word from the Start menu. If no Word is not running, one is started. If this Document is closed and there is no other open document in that application, the application might also terminated. However, if the application has been created with NewApplication, the application also remains running after the last document has been closed. - A Word document always ends with a new-line (0DX). If a character is inserted after this mark, Word will insert a new 0DX after that character. If the method Collapse(CtlT.Int(CtlWord9.wdCollapseEnd)) is called for a Range which includes this ending character, the Range will be collapsed BEFORE this character. To avoid problems, this character should not be regarded part of the content. - All the Collection objects are indexed starting at 1. A collection object is a object that has a name ending in 's' and which has the procedures Item and _NewEnum. However the CtlWord9.Range objects start indexing at 0. Range(CtlT.Int(2), CtlT.Int(4)) for example returns a range of length 2, starting at the 3rd character. - Languages objects are also collections, but they cannot be indexed using numbers. The only way to access languages is by the language's name, if this is known, or by creating an enumeration object. - BlackBox has more font available in the Fonts.dir.TypefaceList() than Word in CtlWord9.Application.FontNames(). - The properties of a CtlWord9.Font are possibly undefined. Then, the constant CtlWord9.wdUndefined is used. When the property is set, it has the value -1, and when it is not set, 0. This is not documented in the MSDN. The underline property has different values, according to the CtlWord9.wdUnderlineXXX constants. The CtlWord9.Font.Name() returns an empty string, if there is no typeface defined. - A CtlWord9.Language can have a dictionary installed. Then the method ActiveSpellingDictionary() returns a dictionary. Otherwise Word might ask if it should install the dictionary for some languages. - The method CtlWord9.Range.Delete(NIL, NIL) deletes the content of the Range, if it is not empty. however if the content is empty (collapsed), it deletes the character to the right of the Range. Therefore Delete has a similar effect as pressing the delete key. If this is not desirable, use the method CtlWord9.Range.PUTText(''), which does nothing if the content of the Range is empty. - The unit CtlWord9.wdCharacterFormatting can be used to access the runs of a text. A run is a homogeneous part of the text. However, we have not found a method which would accept this unit. We have not found a way to get runs from Word. - In Word, every window and the application have a visible property. A window is only visible if both, the property of the document and the application are set to TRUE. Changing the property of the application also changes the properties of all the windows.

Ctl/Docu/Word9.odc

MODULE CtlAccess9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Access 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\acmain9.chm, id: 0 *) (* guid: {4AFFC9A0-5F99-101B-AF4E-00AA003F0F07}, lcid: 0, syskind: win32, version: 9.0 *) IMPORT CtlT, CtlC, CtlADODB, CtlDAO := CtlDAO36, CtlOffice, CtlVBIDE; CONST (* OldConstants *) V_EMPTY* = 0; V_NULL* = 1; V_INTEGER* = 2; V_LONG* = 3; V_SINGLE* = 4; V_DOUBLE* = 5; V_CURRENCY* = 6; V_DATE* = 7; V_STRING* = 8; DB_BINARY* = 9; DB_OLE* = 11; DB_NONULLS* = 3; A_TABLE* = 0; A_QUERY* = 1; A_FORM* = 2; A_REPORT* = 3; A_MACRO* = 4; A_MODULE* = 5; A_FORMBAR* = 0; A_FILE* = 0; A_EDITMENU* = 1; A_RECORDSMENU* = 3; A_NEW* = 0; A_SAVEFORM* = 2; A_SAVEFORMAS* = 3; A_SAVERECORD* = 4; A_UNDO* = 0; A_UNDOFIELD* = 1; A_CUT* = 2; A_COPY* = 3; A_PASTE* = 4; A_DELETE* = 6; A_SELECTRECORD* = 7; A_SELECTALLRECORDS* = 8; A_OBJECT* = 14; A_REFRESH* = 2; A_OBJECTVERB* = 0; A_OBJECTUPDATE* = 3; A_ANYWHERE* = 0; A_ENTIRE* = 1; A_START* = 2; A_UP* = 0; A_DOWN* = 1; A_CURRENT* = 1; A_ALL* = 0; A_PREVIOUS* = 0; A_NEXT* = 1; A_FIRST* = 2; A_LAST* = 3; A_GOTO* = 4; A_NEWREC* = 5; A_NORMAL* = 0; A_DESIGN* = 1; A_PREVIEW* = 2; A_FORMDS* = 3; A_ADD* = 0; A_EDIT* = 1; A_READONLY* = 2; A_HIDDEN* = 1; A_ICON* = 2; A_DIALOG* = 3; A_PRINTALL* = 0; A_SELECTION* = 1; A_PAGES* = 2; A_HIGH* = 0; A_MEDIUM* = 1; A_LOW* = 2; A_DRAFT* = 3; A_PROMPT* = 0; A_SAVE* = 1; A_EXIT* = 2; A_IMPORT* = 0; A_EXPORT* = 1; A_ATTACH* = 2; A_IMPORTDELIM* = 0; A_IMPORTFIXED* = 1; A_EXPORTDELIM* = 2; A_EXPORTFIXED* = 3; A_EXPORTMERGE* = 4; OLE_CHANGED* = 0; OLE_SAVED* = 1; OLE_CLOSED* = 2; OLE_RENAMED* = 3; OLE_RELEASE* = 5; SHIFT_MASK* = 1; CTRL_MASK* = 2; ALT_MASK* = 4; LEFT_BUTTON* = 1; RIGHT_BUTTON* = 2; MIDDLE_BUTTON* = 4; DATA_ERRCONTINUE* = 0; DATA_ERRDISPLAY* = 1; DATA_ERRADDED* = 2; LB_INITIALIZE* = 0; LB_OPEN* = 1; LB_GETROWCOUNT* = 3; LB_GETCOLUMNCOUNT* = 4; LB_GETCOLUMNWIDTH* = 5; LB_GETVALUE* = 6; LB_GETFORMAT* = 7; LB_CLOSE* = 8; LB_END* = 9; SYSCMD_INITMETER* = 1; SYSCMD_UPDATEMETER* = 2; SYSCMD_REMOVEMETER* = 3; SYSCMD_SETSTATUS* = 4; SYSCMD_CLEARSTATUS* = 5; SYSCMD_RUNTIME* = 6; SYSCMD_ACCESSVER* = 7; SYSCMD_INIFILE* = 8; SYSCMD_ACCESSDIR* = 9; SYSCMD_GETOBJECTSTATE* = 10; SYSCMD_CLEARHELPTOPIC* = 11; OBJSTATE_OPEN* = 1; OBJSTATE_NEW* = 4; OBJSTATE_DIRTY* = 2; A_DELETE_V2* = 7; A_SELECTRECORD_V2* = 8; A_SELECTALLRECORDS_V2* = 9; A_TOOLBAR_YES* = 0; A_TOOLBAR_WHERE_APPROP* = 1; A_TOOLBAR_NO* = 2; DELETE_OK* = 0; DELETE_CANCEL* = 1; DELETE_USER_CANCEL* = 2; DB_SEC_FRMRPT_READDEF* = 4; DB_SEC_FRMRPT_WRITEDEF* = 65548; DB_SEC_FRMRPT_EXECUTE* = 256; DB_SEC_MAC_READDEF* = 10; DB_SEC_MAC_WRITEDEF* = 65542; DB_SEC_MAC_EXECUTE* = 8; DB_SEC_MOD_READDEF* = 2; DB_SEC_MOD_WRITEDEF* = 65542; A_MENU_VER1X* = 11; A_MENU_VER20* = 20; A_FORMATRTF* = "Rich Text Format (*.rtf)"; A_FORMATXLS* = "Microsoft Excel (*.xls)"; A_FORMATTXT* = "MS-DOS Text (*.txt)"; DB_OPEN_TABLE* = 1; DB_OPEN_DYNASET* = 2; DB_OPEN_SNAPSHOT* = 4; DB_DENYWRITE* = 1; DB_DENYREAD* = 2; DB_READONLY* = 4; DB_APPENDONLY* = 8; DB_INCONSISTENT* = 16; DB_CONSISTENT* = 32; DB_SQLPASSTHROUGH* = 64; DB_FAILONERROR* = 128; DB_FORWARDONLY* = 256; DB_OPTIONINIPATH* = 1; DB_FIXEDFIELD* = 1; DB_VARIABLEFIELD* = 2; DB_AUTOINCRFIELD* = 16; DB_UPDATABLEFIELD* = 32; DB_DESCENDING* = 1; DB_BOOLEAN* = 1; DB_BYTE* = 2; DB_INTEGER* = 3; DB_LONG* = 4; DB_CURRENCY* = 5; DB_SINGLE* = 6; DB_DOUBLE* = 7; DB_DATE* = 8; DB_TEXT* = 10; DB_LONGBINARY* = 11; DB_MEMO* = 12; DB_RELATIONUNIQUE* = 1; DB_RELATIONDONTENFORCE* = 2; DB_RELATIONINHERITED* = 4; DB_RELATIONUPDATECASCADE* = 256; DB_RELATIONDELETECASCADE* = 4096; DB_RELATIONLEFT* = 16777216; DB_RELATIONRIGHT* = 33554432; DB_ATTACHEXCLUSIVE* = 65536; DB_ATTACHSAVEPWD* = 131072; DB_SYSTEMOBJECT* = -2147483646; DB_ATTACHEDTABLE* = 1073741824; DB_ATTACHEDODBC* = 536870912; DB_HIDDENOBJECT* = 1; DB_TABLE* = 1; DB_QUERYDEF* = 5; DB_QSELECT* = 0; DB_QACTION* = 240; DB_QCROSSTAB* = 16; DB_QDELETE* = 32; DB_QUPDATE* = 48; DB_QAPPEND* = 64; DB_QMAKETABLE* = 80; DB_QDDL* = 96; DB_QSQLPASSTHROUGH* = 112; DB_QSETOPERATION* = 128; DB_QSPTBULK* = 144; DB_UNIQUE* = 1; DB_PRIMARY* = 2; DB_PROHIBITNULL* = 4; DB_IGNORENULL* = 8; DB_LANG_ARABIC* = ";LANGID=0x0401;CP=1256;COUNTRY=0"; DB_LANG_CZECH* = ";LANGID=0x0405;CP=1250;COUNTRY=0"; DB_LANG_DUTCH* = ";LANGID=0x0413;CP=1252;COUNTRY=0"; DB_LANG_GENERAL* = ";LANGID=0x0409;CP=1252;COUNTRY=0"; DB_LANG_GREEK* = ";LANGID=0x0408;CP=1253;COUNTRY=0"; DB_LANG_HEBREW* = ";LANGID=0x040D;CP=1255;COUNTRY=0"; DB_LANG_HUNGARIAN* = ";LANGID=0x040E;CP=1250;COUNTRY=0"; DB_LANG_ICELANDIC* = ";LANGID=0x040F;CP=1252;COUNTRY=0"; DB_LANG_NORDIC* = ";LANGID=0x041D;CP=1252;COUNTRY=0"; DB_LANG_NORWDAN* = ";LANGID=0x0414;CP=1252;COUNTRY=0"; DB_LANG_POLISH* = ";LANGID=0x0415;CP=1250;COUNTRY=0"; DB_LANG_CYRILLIC* = ";LANGID=0x0419;CP=1251;COUNTRY=0"; DB_LANG_SPANISH* = ";LANGID=0x040A;CP=1252;COUNTRY=0"; DB_LANG_SWEDFIN* = ";LANGID=0x040B;CP=1252;COUNTRY=0"; DB_LANG_TURKISH* = ";LANGID=0x041F;CP=1254;COUNTRY=0"; DB_VERSION10* = 1; DB_ENCRYPT* = 2; DB_DECRYPT* = 4; DB_VERSION11* = 8; DB_VERSION20* = 16; DB_SORTARABIC* = 267; DB_SORTCYRILLIC* = 263; DB_SORTCZECH* = 264; DB_SORTDUTCH* = 259; DB_SORTGENERAL* = 256; DB_SORTGREEK* = 269; DB_SORTHEBREW* = 268; DB_SORTHUNGARIAN* = 265; DB_SORTICELANDIC* = 262; DB_SORTNORWDAN* = 261; DB_SORTPDXINTL* = 4096; DB_SORTPDXNOR* = 4098; DB_SORTPDXSWE* = 4097; DB_SORTPOLISH* = 266; DB_SORTSPANISH* = 258; DB_SORTSWEDFIN* = 260; DB_SORTTURKISH* = 270; DB_SORTUNDEFINED* = -1; DB_FREELOCKS* = 1; DB_SEC_NOACCESS* = 0; DB_SEC_FULLACCESS* = 1048575; DB_SEC_DELETE* = 65536; DB_SEC_READSEC* = 131072; DB_SEC_WRITESEC* = 262144; DB_SEC_WRITEOWNER* = 524288; DB_SEC_DBCREATE* = 1; DB_SEC_DBOPEN* = 2; DB_SEC_DBEXCLUSIVE* = 4; DB_SEC_CREATE* = 1; DB_SEC_READDEF* = 4; DB_SEC_WRITEDEF* = 65548; DB_SEC_RETRIEVEDATA* = 20; DB_SEC_INSERTDATA* = 32; DB_SEC_REPLACEDATA* = 64; DB_SEC_DELETEDATA* = 128; (* Constants: Predefined constants *) acDataErrContinue* = 0; acDataErrDisplay* = 1; acDataErrAdded* = 2; acDeleteOK* = 0; acDeleteCancel* = 1; acDeleteUserCancel* = 2; acObjStateOpen* = 1; acObjStateNew* = 4; acObjStateDirty* = 2; acLBInitialize* = 0; acLBOpen* = 1; acLBGetRowCount* = 3; acLBGetColumnCount* = 4; acLBGetColumnWidth* = 5; acLBGetValue* = 6; acLBGetFormat* = 7; acLBClose* = 8; acLBEnd* = 9; acPropCatNA* = 0; acPropCatLayout* = 1; acPropCatData* = 2; acPropCatEvent* = 4; acPropCatOther* = 8; acPrompt* = 0; acSave* = 1; acExit* = 2; acOLEEither* = 2; acOLECreateEmbed* = 0; acOLECreateNew* = 0; acOLECreateLink* = 1; acOLECreateFromFile* = 1; acOLECopy* = 4; acOLEPaste* = 5; acOLEUpdate* = 6; acOLEActivate* = 7; acOLEClose* = 9; acOLEDelete* = 10; acOLEInsertObjDlg* = 14; acOLEPasteSpecialDlg* = 15; acOLEFetchVerbs* = 17; acOLEDisplayContent* = 0; acOLEDisplayIcon* = 1; acOLELinked* = 0; acOLEEmbedded* = 1; acOLENone* = 3; acOLESizeClip* = 0; acOLESizeStretch* = 1; acOLESizeAutoSize* = 2; acOLESizeZoom* = 3; acOLEUpdateAutomatic* = 0; acOLEUpdateFrozen* = 1; acOLEUpdateManual* = 2; acOLEActivateManual* = 0; acOLEActivateGetFocus* = 1; acOLEActivateDoubleClick* = 2; acOLEVerbPrimary* = 0; acOLEVerbShow* = -1; acOLEVerbOpen* = -2; acOLEVerbHide* = -3; acOLEVerbInPlaceUIActivate* = -4; acOLEVerbInPlaceActivate* = -5; acMenuVer1X* = 11; acMenuVer20* = 20; acMenuVer70* = 70; acFormBar* = 0; acFile* = 0; acEditMenu* = 1; acRecordsMenu* = 5; acNew* = 0; acSaveForm* = 4; acSaveFormAs* = 5; acSaveRecord* = 4; acUndo* = 0; acCut* = 1; acCopy* = 2; acPaste* = 3; acDelete* = 6; acSelectRecord* = 8; acSelectAllRecords* = 9; acObject* = 14; acRefresh* = 5; acObjectVerb* = 0; acObjectUpdate* = 3; acFormatRTF* = "Rich Text Format (*.rtf)"; acFormatXLS* = "Microsoft Excel (*.xls)"; acFormatTXT* = "MS-DOS Text (*.txt)"; acFormatHTML* = "HTML (*.html)"; acFormatIIS* = "Microsoft IIS (*.htx; *.idc)"; acFormatASP* = "Microsoft Active Server Pages (*.asp)"; acFormatDAP* = "Microsoft Access Data Access Page (*.html)"; acFormatSNP* = "Snapshot Format (*.snp)"; acSecFrmRptReadDef* = 4; acSecFrmRptWriteDef* = 65548; acSecFrmRptExecute* = 256; acSecMacReadDef* = 10; acSecMacWriteDef* = 65542; acSecMacExecute* = 8; acSecModReadDef* = 2; acSecModWriteDef* = 65542; acMenuUngray* = 0; acMenuGray* = 1; acMenuUncheck* = 2; acMenuCheck* = 3; acEffectNormal* = 0; acEffectRaised* = 1; acEffectSunken* = 2; acEffectEtched* = 3; acEffectShadow* = 4; acEffectChisel* = 5; acGridlinesNone* = 0; acGridlinesHoriz* = 1; acGridlinesVert* = 2; acGridlinesBoth* = 3; acGridlinesBothV2* = -1; acFilterByForm* = 0; acFilterAdvanced* = 1; acServerFilterByForm* = 2; acShowAllRecords* = 0; acApplyFilter* = 1; acCloseFilterWindow* = 2; acApplyServerFilter* = 3; acCloseServerFilterWindow* = 4; acShiftMask* = 1; acCtrlMask* = 2; acAltMask* = 4; acLeftButton* = 1; acRightButton* = 2; acMiddleButton* = 4; acOLEChanged* = 0; acOLESaved* = 1; acOLEClosed* = 2; acOLERenamed* = 3; vbKeyLButton* = 1; vbKeyRButton* = 2; vbKeyCancel* = 3; vbKeyMButton* = 4; vbKeyBack* = 8; vbKeyTab* = 9; vbKeyClear* = 12; vbKeyReturn* = 13; vbKeyShift* = 16; vbKeyControl* = 17; vbKeyMenu* = 18; vbKeyPause* = 19; vbKeyCapital* = 20; vbKeyEscape* = 27; vbKeySpace* = 32; vbKeyPageUp* = 33; vbKeyPageDown* = 34; vbKeyEnd* = 35; vbKeyHome* = 36; vbKeyLeft* = 37; vbKeyUp* = 38; vbKeyRight* = 39; vbKeyDown* = 40; vbKeySelect* = 41; vbKeyPrint* = 42; vbKeyExecute* = 43; vbKeySnapshot* = 44; vbKeyInsert* = 45; vbKeyDelete* = 46; vbKeyHelp* = 47; vbKeyNumlock* = 144; vbKeyA* = 65; vbKeyB* = 66; vbKeyC* = 67; vbKeyD* = 68; vbKeyE* = 69; vbKeyF* = 70; vbKeyG* = 71; vbKeyH* = 72; vbKeyI* = 73; vbKeyJ* = 74; vbKeyK* = 75; vbKeyL* = 76; vbKeyM* = 77; vbKeyN* = 78; vbKeyO* = 79; vbKeyP* = 80; vbKeyQ* = 81; vbKeyR* = 82; vbKeyS* = 83; vbKeyT* = 84; vbKeyU* = 85; vbKeyV* = 86; vbKeyW* = 87; vbKeyX* = 88; vbKeyY* = 89; vbKeyZ* = 90; vbKey0* = 48; vbKey1* = 49; vbKey2* = 50; vbKey3* = 51; vbKey4* = 52; vbKey5* = 53; vbKey6* = 54; vbKey7* = 55; vbKey8* = 56; vbKey9* = 57; vbKeyNumpad0* = 96; vbKeyNumpad1* = 97; vbKeyNumpad2* = 98; vbKeyNumpad3* = 99; vbKeyNumpad4* = 100; vbKeyNumpad5* = 101; vbKeyNumpad6* = 102; vbKeyNumpad7* = 103; vbKeyNumpad8* = 104; vbKeyNumpad9* = 105; vbKeyMultiply* = 106; vbKeyAdd* = 107; vbKeySeparator* = 108; vbKeySubtract* = 109; vbKeyDecimal* = 110; vbKeyDivide* = 111; vbKeyF1* = 112; vbKeyF2* = 113; vbKeyF3* = 114; vbKeyF4* = 115; vbKeyF5* = 116; vbKeyF6* = 117; vbKeyF7* = 118; vbKeyF8* = 119; vbKeyF9* = 120; vbKeyF10* = 121; vbKeyF11* = 122; vbKeyF12* = 123; vbKeyF13* = 124; vbKeyF14* = 125; vbKeyF15* = 126; vbKeyF16* = 127; (* AcModuleType *) acStandardModule* = 0; acClassModule* = 1; (* AcCloseSave *) acSavePrompt* = 0; acSaveYes* = 1; acSaveNo* = 2; (* AcQuitOption *) acQuitPrompt* = 0; acQuitSaveAll* = 1; acQuitSaveNone* = 2; (* AcSection *) acDetail* = 0; acHeader* = 1; acFooter* = 2; acPageHeader* = 3; acPageFooter* = 4; acGroupLevel1Header* = 5; acGroupLevel1Footer* = 6; acGroupLevel2Header* = 7; acGroupLevel2Footer* = 8; (* AcControlType *) acLabel* = 100; acRectangle* = 101; acLine* = 102; acImage* = 103; acCommandButton* = 104; acOptionButton* = 105; acCheckBox* = 106; acOptionGroup* = 107; acBoundObjectFrame* = 108; acTextBox* = 109; acListBox* = 110; acComboBox* = 111; acSubform* = 112; acObjectFrame* = 114; acPageBreak* = 118; acCustomControl* = 119; acToggleButton* = 122; acTabCtl* = 123; acPage* = 124; (* AcDataObjectType *) acActiveDataObject* = -1; acDataTable* = 0; acDataQuery* = 1; acDataForm* = 2; acDataServerView* = 7; acDataStoredProcedure* = 9; (* AcDataTransferType *) acImport* = 0; acExport* = 1; acLink* = 2; (* AcSendObjectType *) acSendNoObject* = -1; acSendTable* = 0; acSendQuery* = 1; acSendForm* = 2; acSendReport* = 3; acSendModule* = 5; acSendDataAccessPage* = 6; (* AcObjectType *) acDefault* = -1; acTable* = 0; acQuery* = 1; acForm* = 2; acReport* = 3; acMacro* = 4; acModule* = 5; acDataAccessPage* = 6; acServerView* = 7; acDiagram* = 8; acStoredProcedure* = 9; (* AcFindField *) acCurrent* = -1; acAll* = 0; (* AcFindMatch *) acAnywhere* = 0; acEntire* = 1; acStart* = 2; (* AcFormView *) acNormal* = 0; acDesign* = 1; acPreview* = 2; acFormDS* = 3; (* AcDataAccessPageView *) acDataAccessPageBrowse* = 0; acDataAccessPageDesign* = 1; (* AcOpenDataMode *) acAdd* = 0; acEdit* = 1; acReadOnly* = 2; (* AcFormOpenDataMode *) acFormPropertySettings* = -1; acFormAdd* = 0; acFormEdit* = 1; acFormReadOnly* = 2; (* AcOutputObjectType *) acOutputTable* = 0; acOutputQuery* = 1; acOutputForm* = 2; acOutputReport* = 3; acOutputModule* = 5; acOutputDataAccessPage* = 6; acOutputServerView* = 7; acOutputStoredProcedure* = 9; (* AcPrintQuality *) acHigh* = 0; acMedium* = 1; acLow* = 2; acDraft* = 3; (* AcPrintRange *) acPrintAll* = 0; acSelection* = 1; acPages* = 2; (* AcRecord *) acPrevious* = 0; acNext* = 1; acFirst* = 2; acLast* = 3; acGoTo* = 4; acNewRec* = 5; (* AcSearchDirection *) acUp* = 0; acDown* = 1; acSearchAll* = 2; (* AcSysCmdAction *) acSysCmdInitMeter* = 1; acSysCmdUpdateMeter* = 2; acSysCmdRemoveMeter* = 3; acSysCmdSetStatus* = 4; acSysCmdClearStatus* = 5; acSysCmdRuntime* = 6; acSysCmdAccessVer* = 7; acSysCmdIniFile* = 8; acSysCmdAccessDir* = 9; acSysCmdGetObjectState* = 10; acSysCmdClearHelpTopic* = 11; acSysCmdProfile* = 12; acSysCmdGetWorkgroupFile* = 13; (* AcTextTransferType *) acImportDelim* = 0; acImportFixed* = 1; acExportDelim* = 2; acExportFixed* = 3; acExportMerge* = 4; acLinkDelim* = 5; acLinkFixed* = 6; acImportHTML* = 7; acExportHTML* = 8; acLinkHTML* = 9; (* AcView *) acViewNormal* = 0; acViewDesign* = 1; acViewPreview* = 2; (* AcWindowMode *) acWindowNormal* = 0; acHidden* = 1; acIcon* = 2; acDialog* = 3; (* AcFilterType *) acFilterNormal* = 0; acServerFilter* = 1; (* AcSpreadSheetType *) acSpreadsheetTypeExcel3* = 0; acSpreadsheetTypeLotusWK1* = 2; acSpreadsheetTypeLotusWK3* = 3; acSpreadsheetTypeLotusWJ2* = 4; acSpreadsheetTypeExcel5* = 5; acSpreadsheetTypeExcel7* = 5; acSpreadsheetTypeExcel4* = 6; acSpreadsheetTypeLotusWK4* = 7; acSpreadsheetTypeExcel97* = 8; acSpreadsheetTypeExcel8* = 8; acSpreadsheetTypeExcel9* = 8; (* AcImeMode *) acImeModeNoControl* = 0; acImeModeOn* = 1; acImeModeOff* = 2; acImeModeDisable* = 3; acImeModeHiragana* = 4; acImeModeKatakana* = 5; acImeModeKatakanaHalf* = 6; acImeModeAlphaFull* = 7; acImeModeAlpha* = 8; acImeModeHangulFull* = 9; acImeModeHangul* = 10; (* AcImeSentenceMode *) acImeSentenceModePhrasePredict* = 0; acImeSentenceModePluralClause* = 1; acImeSentenceModeConversation* = 2; acImeSentenceModeNone* = 3; (* AcHyperlinkPart *) acDisplayedValue* = 0; acDisplayText* = 1; acAddress* = 2; acSubAddress* = 3; acScreenTip* = 4; acFullAddress* = 5; (* AcProjectType *) acNull* = 0; acADP* = 1; acMDB* = 2; (* AcCommand *) acCmdWindowUnhide* = 1; acCmdWindowHide* = 2; acCmdExit* = 3; acCmdCompactDatabase* = 4; acCmdEncryptDecryptDatabase* = 5; acCmdRepairDatabase* = 6; acCmdMakeMDEFile* = 7; acCmdMoreWindows* = 8; acCmdAppRestore* = 9; acCmdAppMaximize* = 10; acCmdAppMinimize* = 11; acCmdAppMove* = 12; acCmdAppSize* = 13; acCmdDocRestore* = 14; acCmdDocMaximize* = 15; acCmdDocMove* = 16; acCmdDocSize* = 17; acCmdRefresh* = 18; acCmdFont* = 19; acCmdSave* = 20; acCmdSaveAs* = 21; acCmdWindowCascade* = 22; acCmdTileVertically* = 23; acCmdWindowArrangeIcons* = 24; acCmdOpenDatabase* = 25; acCmdNewDatabase* = 26; acCmdOLEDDELinks* = 27; acCmdRecordsGoToNew* = 28; acCmdReplace* = 29; acCmdFind* = 30; acCmdRunMacro* = 31; acCmdPageSetup* = 32; acCmdInsertObject* = 33; acCmdDuplicate* = 34; acCmdAboutMicrosoftAccess* = 35; acCmdFormHdrFtr* = 36; acCmdReportHdrFtr* = 37; acCmdPasteAppend* = 38; acCmdInsertFile* = 39; acCmdSelectForm* = 40; acCmdTabOrder* = 41; acCmdFieldList* = 42; acCmdAlignLeft* = 43; acCmdAlignRight* = 44; acCmdAlignTop* = 45; acCmdAlignBottom* = 46; acCmdAlignToGrid* = 47; acCmdSizeToGrid* = 48; acCmdOptions* = 49; acCmdSelectRecord* = 50; acCmdSortingAndGrouping* = 51; acCmdBringToFront* = 52; acCmdSendToBack* = 53; acCmdPrintPreview* = 54; acCmdApplyDefault* = 55; acCmdSetControlDefaults* = 56; acCmdOLEObjectDefaultVerb* = 57; acCmdClose* = 58; acCmdSizeToFit* = 59; acCmdDocMinimize* = 60; acCmdViewRuler* = 61; acCmdSnapToGrid* = 62; acCmdViewGrid* = 63; acCmdPasteSpecial* = 64; acCmdRecordsGoToNext* = 65; acCmdRecordsGoToPrevious* = 66; acCmdRecordsGoToFirst* = 67; acCmdRecordsGoToLast* = 68; acCmdSizeToFitForm* = 69; acCmdEditingAllowed* = 70; acCmdClearGrid* = 71; acCmdJoinProperties* = 72; acCmdQueryTotals* = 73; acCmdQueryTypeCrosstab* = 74; acCmdTableNames* = 75; acCmdQueryParameters* = 76; acCmdFormatCells* = 77; acCmdDataEntry* = 78; acCmdHideColumns* = 79; acCmdUnhideColumns* = 80; acCmdDeleteQueryColumn* = 81; acCmdInsertQueryColumn* = 82; acCmdRemoveTable* = 84; acCmdViewToolbox* = 85; acCmdMacroNames* = 86; acCmdMacroConditions* = 87; acCmdSingleStep* = 88; acCmdQueryTypeSelect* = 89; acCmdQueryTypeUpdate* = 90; acCmdQueryTypeAppend* = 91; acCmdQueryTypeDelete* = 92; acCmdApplyFilterSort* = 93; acCmdQueryTypeMakeTable* = 94; acCmdLoadFromQuery* = 95; acCmdSaveAsQuery* = 96; acCmdSaveRecord* = 97; acCmdAdvancedFilterSort* = 99; acCmdMicrosoftAccessHelpTopics* = 100; acCmdLinkTables* = 102; acCmdUserAndGroupPermissions* = 103; acCmdUserAndGroupAccounts* = 104; acCmdFreezeColumn* = 105; acCmdUnfreezeAllColumns* = 106; acCmdPrimaryKey* = 107; acCmdSubformDatasheet* = 108; acCmdSelectAllRecords* = 109; acCmdViewTables* = 110; acCmdViewQueries* = 111; acCmdViewForms* = 112; acCmdViewReports* = 113; acCmdViewMacros* = 114; acCmdViewModules* = 115; acCmdRowHeight* = 116; acCmdColumnWidth* = 117; acCmdInsertFileIntoModule* = 118; acCmdSaveModuleAsText* = 119; acCmdFindPrevious* = 120; acCmdWindowSplit* = 121; acCmdProcedureDefinition* = 122; acCmdDebugWindow* = 123; acCmdReset* = 124; acCmdCompileAllModules* = 125; acCmdCompileAndSaveAllModules* = 126; acCmdGoContinue* = 127; acCmdStepOver* = 128; acCmdSetNextStatement* = 129; acCmdShowNextStatement* = 130; acCmdToggleBreakpoint* = 131; acCmdClearAllBreakpoints* = 132; acCmdRelationships* = 133; acCmdNewObjectTable* = 134; acCmdNewObjectQuery* = 135; acCmdNewObjectForm* = 136; acCmdNewObjectReport* = 137; acCmdNewObjectMacro* = 138; acCmdNewObjectModule* = 139; acCmdNewObjectClassModule* = 140; acCmdLayoutPreview* = 141; acCmdSaveAsReport* = 142; acCmdRename* = 143; acCmdRemoveFilterSort* = 144; acCmdSaveLayout* = 145; acCmdClearAll* = 146; acCmdHideTable* = 147; acCmdShowDirectRelationships* = 148; acCmdShowAllRelationships* = 149; acCmdCreateRelationship* = 150; acCmdEditRelationship* = 151; acCmdIndexes* = 152; acCmdAlignToShortest* = 153; acCmdAlignToTallest* = 154; acCmdSizeToNarrowest* = 155; acCmdSizeToWidest* = 156; acCmdHorizontalSpacingMakeEqual* = 157; acCmdHorizontalSpacingDecrease* = 158; acCmdHorizontalSpacingIncrease* = 159; acCmdVerticalSpacingMakeEqual* = 160; acCmdVerticalSpacingDecrease* = 161; acCmdVerticalSpacingIncrease* = 162; acCmdSortAscending* = 163; acCmdSortDescending* = 164; acCmdToolbarsCustomize* = 165; acCmdOLEObjectConvert* = 167; acCmdQueryTypeSQLDataDefinition* = 168; acCmdQueryTypeSQLPassThrough* = 169; acCmdViewCode* = 170; acCmdConvertDatabase* = 171; acCmdCallStack* = 172; acCmdSend* = 173; acCmdOutputToExcel* = 175; acCmdOutputToRTF* = 176; acCmdOutputToText* = 177; acCmdInvokeBuilder* = 178; acCmdZoomBox* = 179; acCmdQueryTypeSQLUnion* = 180; acCmdRun* = 181; acCmdPageHdrFtr* = 182; acCmdDesignView* = 183; acCmdSQLView* = 184; acCmdShowTable* = 185; acCmdCloseWindow* = 186; acCmdInsertRows* = 187; acCmdDeleteRows* = 188; acCmdCut* = 189; acCmdCopy* = 190; acCmdPaste* = 191; acCmdAutoDial* = 192; acCmdNewObjectAutoForm* = 193; acCmdNewObjectAutoReport* = 194; acCmdWordMailMerge* = 195; acCmdTestValidationRules* = 196; acCmdControlWizardsToggle* = 197; acCmdEnd* = 198; acCmdRedo* = 199; acCmdObjectBrowser* = 200; acCmdAddWatch* = 201; acCmdEditWatch* = 202; acCmdQuickWatch* = 203; acCmdStepToCursor* = 204; acCmdIndent* = 205; acCmdOutdent* = 206; acCmdFilterByForm* = 207; acCmdFilterBySelection* = 208; acCmdViewLargeIcons* = 209; acCmdViewDetails* = 210; acCmdViewSmallIcons* = 211; acCmdViewList* = 212; acCmdLineUpIcons* = 213; acCmdArrangeIconsByName* = 214; acCmdArrangeIconsByType* = 215; acCmdArrangeIconsByCreated* = 216; acCmdArrangeIconsByModified* = 217; acCmdArrangeIconsAuto* = 218; acCmdCreateShortcut* = 219; acCmdToggleFilter* = 220; acCmdOpenTable* = 221; acCmdInsertPicture* = 222; acCmdDeleteRecord* = 223; acCmdStartupProperties* = 224; acCmdPageNumber* = 225; acCmdDateAndTime* = 226; acCmdChangeToTextBox* = 227; acCmdChangeToLabel* = 228; acCmdChangeToListBox* = 229; acCmdChangeToComboBox* = 230; acCmdChangeToCheckBox* = 231; acCmdChangeToToggleButton* = 232; acCmdChangeToOptionButton* = 233; acCmdChangeToImage* = 234; acCmdAnswerWizard* = 235; acCmdMicrosoftOnTheWeb* = 236; acCmdClearItemDefaults* = 237; acCmdZoom200* = 238; acCmdZoom150* = 239; acCmdZoom100* = 240; acCmdZoom75* = 241; acCmdZoom50* = 242; acCmdZoom25* = 243; acCmdZoom10* = 244; acCmdFitToWindow* = 245; acCmdPreviewOnePage* = 246; acCmdPreviewTwoPages* = 247; acCmdPreviewFourPages* = 248; acCmdPreviewEightPages* = 249; acCmdPreviewTwelvePages* = 250; acCmdOpenURL* = 251; acCmdOpenStartPage* = 252; acCmdOpenSearchPage* = 253; acCmdRegisterActiveXControls* = 254; acCmdDeleteTab* = 255; acCmdDatabaseProperties* = 256; acCmdImport* = 257; acCmdInsertActiveXControl* = 258; acCmdInsertHyperlink* = 259; acCmdReferences* = 260; acCmdAutoCorrect* = 261; acCmdInsertProcedure* = 262; acCmdCreateReplica* = 263; acCmdSynchronizeNow* = 264; acCmdRecoverDesignMaster* = 265; acCmdResolveConflicts* = 266; acCmdDeleteWatch* = 267; acCmdSpelling* = 269; acCmdAutoFormat* = 270; acCmdDeleteTableColumn* = 271; acCmdInsertTableColumn* = 272; acCmdInsertLookupColumn* = 273; acCmdRenameColumn* = 274; acCmdSetDatabasePassword* = 275; acCmdUserLevelSecurityWizard* = 276; acCmdFilterExcludingSelection* = 277; acCmdQuickPrint* = 278; acCmdConvertMacrosToVisualBasic* = 279; acCmdSaveAllModules* = 280; acCmdFormView* = 281; acCmdDatasheetView* = 282; acCmdAnalyzePerformance* = 283; acCmdAnalyzeTable* = 284; acCmdDocumenter* = 285; acCmdTileHorizontally* = 286; acCmdProperties* = 287; acCmdTransparentBackground* = 288; acCmdTransparentBorder* = 289; acCmdCompileLoadedModules* = 290; acCmdInsertLookupField* = 291; acCmdUndo* = 292; acCmdInsertChart* = 293; acCmdGoBack* = 294; acCmdGoForward* = 295; acCmdStopLoadingPage* = 296; acCmdRefreshPage* = 297; acCmdFavoritesOpen* = 298; acCmdFavoritesAddTo* = 299; acCmdShowOnlyWebToolbar* = 300; acCmdToolbarControlProperties* = 301; acCmdShowMembers* = 302; acCmdListConstants* = 303; acCmdQuickInfo* = 304; acCmdParameterInfo* = 305; acCmdCompleteWord* = 306; acCmdBookmarksToggle* = 307; acCmdBookmarksNext* = 308; acCmdBookmarksPrevious* = 309; acCmdBookmarksClearAll* = 310; acCmdStepOut* = 311; acCmdFindPrevWordUnderCursor* = 312; acCmdFindNextWordUnderCursor* = 313; acCmdObjBrwFindWholeWordOnly* = 314; acCmdObjBrwShowHiddenMembers* = 315; acCmdObjBrwHelp* = 316; acCmdObjBrwViewDefinition* = 317; acCmdObjBrwGroupMembers* = 318; acCmdSelectReport* = 319; acCmdPublish* = 320; acCmdSaveAsHTML* = 321; acCmdSaveAsIDC* = 322; acCmdSaveAsASP* = 323; acCmdPublishDefaults* = 324; acCmdEditHyperlink* = 325; acCmdOpenHyperlink* = 326; acCmdOpenNewHyperlink* = 327; acCmdCopyHyperlink* = 328; acCmdHyperlinkDisplayText* = 329; acCmdTabControlPageOrder* = 330; acCmdInsertPage* = 331; acCmdDeletePage* = 332; acCmdSelectAll* = 333; acCmdCreateMenuFromMacro* = 334; acCmdCreateToolbarFromMacro* = 335; acCmdCreateShortcutMenuFromMacro* = 336; acCmdDelete* = 337; acCmdRunOpenMacro* = 338; acCmdLastPosition* = 339; acCmdPrint* = 340; acCmdFindNext* = 341; acCmdStepInto* = 342; acCmdClearHyperlink* = 343; acCmdDataAccessPageBrowse* = 344; acCmdNewObjectDataAccessPage* = 346; acCmdSelectDataAccessPage* = 347; acCmdViewDataAccessPages* = 349; acCmdNewObjectView* = 350; acCmdNewObjectStoredProcedure* = 351; acCmdNewObjectDiagram* = 352; acCmdViewFieldList* = 353; acCmdViewDiagrams* = 354; acCmdViewStoredProcedures* = 355; acCmdViewViews* = 356; acCmdViewShowPaneSQL* = 357; acCmdViewShowPaneDiagram* = 358; acCmdViewShowPaneGrid* = 359; acCmdViewVerifySQL* = 360; acCmdQueryGroupBy* = 361; acCmdQueryAddToOutput* = 362; acCmdViewTableColumnNames* = 363; acCmdViewTableNameOnly* = 364; acCmdHidePane* = 365; acCmdRemove* = 366; acCmdViewTableColumnProperties* = 368; acCmdViewTableKeys* = 369; acCmdViewTableUserView* = 370; acCmdZoomSelection* = 371; acCmdDiagramNewLabel* = 372; acCmdDiagramAddRelatedTables* = 373; acCmdDiagramShowRelationshipLabels* = 374; acCmdDiagramModifyUserDefinedView* = 375; acCmdDiagramViewPageBreaks* = 376; acCmdDiagramRecalculatePageBreaks* = 377; acCmdDiagramAutosizeSelectedTables* = 378; acCmdDiagramLayoutSelection* = 379; acCmdDiagramLayoutDiagram* = 380; acCmdDiagramNewTable* = 381; acCmdDiagramDeleteRelationship* = 382; acCmdConnection* = 383; acCmdEditTriggers* = 384; acCmdDataAccessPageDesignView* = 385; acCmdPromote* = 386; acCmdGroupByTable* = 387; acCmdDemote* = 388; acCmdSaveAsDataAccessPage* = 389; acCmdMicrosoftScriptEditor* = 390; (* AcShowToolbar *) acToolbarYes* = 0; acToolbarWhereApprop* = 1; acToolbarNo* = 2; (* AcFormatConditionType *) acFieldValue* = 0; acExpression* = 1; acFieldHasFocus* = 2; (* AcFormatConditionOperator *) acBetween* = 0; acNotBetween* = 1; acEqual* = 2; acNotEqual* = 3; acGreaterThan* = 4; acLessThan* = 5; acGreaterThanOrEqual* = 6; acLessThanOrEqual* = 7; (* AcColorIndex *) acColorIndexBlack* = 0; acColorIndexMaroon* = 1; acColorIndexGreen* = 2; acColorIndexOlive* = 3; acColorIndexDarkBlue* = 4; acColorIndexViolet* = 5; acColorIndexTeal* = 6; acColorIndexGray* = 7; acColorIndexSilver* = 8; acColorIndexRed* = 9; acColorIndexBrightGreen* = 10; acColorIndexYellow* = 11; acColorIndexBlue* = 12; acColorIndexFuschia* = 13; acColorIndexAqua* = 14; acColorIndexWhite* = 15; (* RefKind, hidden *) TypeLib* = 0; Project* = 1; (* ProcKind, hidden *) Proc* = 0; Let* = 1; Set* = 2; Get* = 3; TYPE AcModuleType* = INTEGER; AcCloseSave* = INTEGER; AcQuitOption* = INTEGER; AcSection* = INTEGER; AcControlType* = INTEGER; AcDataObjectType* = INTEGER; AcDataTransferType* = INTEGER; AcSendObjectType* = INTEGER; AcObjectType* = INTEGER; AcFindField* = INTEGER; AcFindMatch* = INTEGER; AcFormView* = INTEGER; AcDataAccessPageView* = INTEGER; AcOpenDataMode* = INTEGER; AcFormOpenDataMode* = INTEGER; AcOutputObjectType* = INTEGER; AcPrintQuality* = INTEGER; AcPrintRange* = INTEGER; AcRecord* = INTEGER; AcSearchDirection* = INTEGER; AcSysCmdAction* = INTEGER; AcTextTransferType* = INTEGER; AcView* = INTEGER; AcWindowMode* = INTEGER; AcFilterType* = INTEGER; AcSpreadSheetType* = INTEGER; AcImeMode* = INTEGER; AcImeSentenceMode* = INTEGER; AcHyperlinkPart* = INTEGER; AcProjectType* = INTEGER; AcCommand* = INTEGER; AcShowToolbar* = INTEGER; AcFormatConditionType* = INTEGER; AcFormatConditionOperator* = INTEGER; AcColorIndex* = INTEGER; DoCmd* = POINTER TO RECORD (CtlT.Object) END; _RecordsetEvents* = POINTER TO RECORD (CtlT.Object) END; _AccessProperty* = POINTER TO RECORD (CtlT.Object) END; Properties* = POINTER TO RECORD (CtlT.Object) END; _FormatCondition* = POINTER TO RECORD (CtlT.Object) END; FormatCondition* = _FormatCondition; FormatConditions* = POINTER TO RECORD (CtlT.Object) END; _ItemsSelected* = POINTER TO RECORD (CtlT.Object) END; Children* = POINTER TO RECORD (CtlT.Object) END; _AccessField* = POINTER TO RECORD (CtlT.Object) END; AccessField* = _AccessField; _Hyperlink* = POINTER TO RECORD (CtlT.Object) END; Hyperlink* = _Hyperlink; Page* = _Page; Pages* = POINTER TO RECORD (CtlT.Object) END; _Control* = POINTER TO RECORD (CtlT.Object) END; Control* = _Control; _ControlInReportEvents* = _Control; Controls* = POINTER TO RECORD (CtlT.Object) END; _Label* = POINTER TO RECORD (CtlT.Object) END; Label* = _Label; _ChildLabel* = _Label; _Rectangle* = POINTER TO RECORD (CtlT.Object) END; Rectangle* = _Rectangle; _Line* = POINTER TO RECORD (CtlT.Object) END; Line* = _Line; _Image* = POINTER TO RECORD (CtlT.Object) END; Image* = _Image; _CommandButton* = POINTER TO RECORD (CtlT.Object) END; CommandButton* = _CommandButton; _OptionButton* = POINTER TO RECORD (CtlT.Object) END; OptionButton* = _OptionButton; _OptionButtonInOption* = _OptionButton; _Checkbox* = POINTER TO RECORD (CtlT.Object) END; CheckBox* = _Checkbox; _CheckBoxInOption* = _Checkbox; _OptionGroup* = POINTER TO RECORD (CtlT.Object) END; OptionGroup* = _OptionGroup; _BoundObjectFrame* = POINTER TO RECORD (CtlT.Object) END; BoundObjectFrame* = _BoundObjectFrame; _Textbox* = POINTER TO RECORD (CtlT.Object) END; TextBox* = _Textbox; _ListBox* = POINTER TO RECORD (CtlT.Object) END; ListBox* = _ListBox; _Combobox* = POINTER TO RECORD (CtlT.Object) END; ComboBox* = _Combobox; _ObjectFrame* = POINTER TO RECORD (CtlT.Object) END; ObjectFrame* = _ObjectFrame; _PageBreak* = POINTER TO RECORD (CtlT.Object) END; PageBreak* = _PageBreak; _ToggleButton* = POINTER TO RECORD (CtlT.Object) END; ToggleButton* = _ToggleButton; _ToggleButtonInOption* = _ToggleButton; _PaletteButton* = POINTER TO RECORD (CtlT.Object) END; PaletteButton* = _PaletteButton; _SubForm* = POINTER TO RECORD (CtlT.Object) END; SubForm* = _SubForm; _SubReport* = POINTER TO RECORD (CtlT.Object) END; SubReport* = _SubReport; _CustomControl* = POINTER TO RECORD (CtlT.Object) END; CustomControl* = _CustomControl; _CustomControlInReport* = _CustomControl; _TabControl* = POINTER TO RECORD (CtlT.Object) END; TabControl* = _TabControl; _Page* = POINTER TO RECORD (CtlT.Object) END; _Section* = POINTER TO RECORD (CtlT.Object) END; Section* = _Section; _GroupLevel* = POINTER TO RECORD (CtlT.Object) END; GroupLevel* = _GroupLevel; _SectionInReport* = _Section; _PageHdrFtrInReport* = _Section; RefKind* = INTEGER; ProcKind* = INTEGER; Module* = POINTER TO RECORD (CtlT.Object) END; Modules* = POINTER TO RECORD (CtlT.Object) END; _Form* = POINTER TO RECORD (CtlT.Object) END; Form* = _Form; Forms* = POINTER TO RECORD (CtlT.Object) END; _Report* = POINTER TO RECORD (CtlT.Object) END; Report* = _Report; Reports* = POINTER TO RECORD (CtlT.Object) END; Screen* = POINTER TO RECORD (CtlT.Object) END; _Application* = POINTER TO RECORD (CtlT.Object) END; Application* = _Application; Reference* = POINTER TO RECORD (CtlT.Object) END; _References* = POINTER TO RECORD (CtlT.Object) END; _References_Events* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; References* = _References; _Dummy* = POINTER TO RECORD (CtlT.Object) END; _DataAccessPage* = POINTER TO RECORD (CtlT.Object) END; DataAccessPage* = _DataAccessPage; DataAccessPages* = POINTER TO RECORD (CtlT.Object) END; AllObjects* = POINTER TO RECORD (CtlT.Object) END; AllForms* = AllObjects; AllReports* = AllObjects; AllMacros* = AllObjects; AllModules* = AllObjects; AllDataAccessPages* = AllObjects; AllTables* = AllObjects; AllQueries* = AllObjects; AllViews* = AllObjects; AllStoredProcedures* = AllObjects; AllDatabaseDiagrams* = AllObjects; AccessObjectProperty* = POINTER TO RECORD (CtlT.Object) END; AccessObjectProperties* = POINTER TO RECORD (CtlT.Object) END; _CurrentProject* = POINTER TO RECORD (CtlT.Object) END; _CurrentData* = POINTER TO RECORD (CtlT.Object) END; CurrentProject* = _CurrentProject; CurrentData* = _CurrentData; CodeProject* = _CurrentProject; CodeData* = _CurrentData; AccessObject* = POINTER TO RECORD (CtlT.Object) END; _WizHook* = POINTER TO RECORD (CtlT.Object) END; WizHook* = _WizHook; _DefaultWebOptions* = POINTER TO RECORD (CtlT.Object) END; DefaultWebOptions* = _DefaultWebOptions; _WebOptions* = POINTER TO RECORD (CtlT.Object) END; WebOptions* = _WebOptions; Class* = _Dummy; PROCEDURE ThisDoCmd* (v: CtlT.Any): DoCmd; VAR new: DoCmd; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{C547E760-9658-101B-81EE-00AA004750E2}"); RETURN new ELSE RETURN NIL END END ThisDoCmd; PROCEDURE IsDoCmd* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{C547E760-9658-101B-81EE-00AA004750E2}") END IsDoCmd; PROCEDURE This_RecordsetEvents* (v: CtlT.Any): _RecordsetEvents; VAR new: _RecordsetEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{45165490-EF32-11D0-86FB-006097C9818C}"); RETURN new ELSE RETURN NIL END END This_RecordsetEvents; PROCEDURE Is_RecordsetEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{45165490-EF32-11D0-86FB-006097C9818C}") END Is_RecordsetEvents; PROCEDURE This_AccessProperty* (v: CtlT.Any): _AccessProperty; VAR new: _AccessProperty; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{331FDD00-CF31-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_AccessProperty; PROCEDURE Is_AccessProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{331FDD00-CF31-11CD-8701-00AA003F0F07}") END Is_AccessProperty; PROCEDURE ThisProperties* (v: CtlT.Any): Properties; VAR new: Properties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{331FDD02-CF31-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisProperties; PROCEDURE IsProperties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{331FDD02-CF31-11CD-8701-00AA003F0F07}") END IsProperties; PROCEDURE This_FormatCondition* (v: CtlT.Any): _FormatCondition; VAR new: _FormatCondition; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{E27A992C-A330-11D0-81DD-00C04FC2F51B}"); RETURN new ELSE RETURN NIL END END This_FormatCondition; PROCEDURE Is_FormatCondition* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{E27A992C-A330-11D0-81DD-00C04FC2F51B}") END Is_FormatCondition; PROCEDURE ThisFormatConditions* (v: CtlT.Any): FormatConditions; VAR new: FormatConditions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{E27A992E-A330-11D0-81DD-00C04FC2F51B}"); RETURN new ELSE RETURN NIL END END ThisFormatConditions; PROCEDURE IsFormatConditions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{E27A992E-A330-11D0-81DD-00C04FC2F51B}") END IsFormatConditions; PROCEDURE This_ItemsSelected* (v: CtlT.Any): _ItemsSelected; VAR new: _ItemsSelected; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{31B09710-EADC-11CD-B9F7-00AA004753B5}"); RETURN new ELSE RETURN NIL END END This_ItemsSelected; PROCEDURE Is_ItemsSelected* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{31B09710-EADC-11CD-B9F7-00AA004753B5}") END Is_ItemsSelected; PROCEDURE ThisChildren* (v: CtlT.Any): Children; VAR new: Children; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E977-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisChildren; PROCEDURE IsChildren* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E977-E47C-11CD-8701-00AA003F0F07}") END IsChildren; PROCEDURE This_AccessField* (v: CtlT.Any): _AccessField; VAR new: _AccessField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{B1C1EAC1-486F-11CE-A65D-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_AccessField; PROCEDURE Is_AccessField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{B1C1EAC1-486F-11CE-A65D-00AA003F0F07}") END Is_AccessField; PROCEDURE This_Hyperlink* (v: CtlT.Any): _Hyperlink; VAR new: _Hyperlink; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{50D56611-60AC-11CF-82C9-00AA004B9FE6}"); RETURN new ELSE RETURN NIL END END This_Hyperlink; PROCEDURE Is_Hyperlink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{50D56611-60AC-11CF-82C9-00AA004B9FE6}") END Is_Hyperlink; PROCEDURE ThisPages* (v: CtlT.Any): Pages; VAR new: Pages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E978-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisPages; PROCEDURE IsPages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E978-E47C-11CD-8701-00AA003F0F07}") END IsPages; PROCEDURE This_Control* (v: CtlT.Any): _Control; VAR new: _Control; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{26B96540-8F8E-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Control; PROCEDURE Is_Control* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{26B96540-8F8E-101B-AF4E-00AA003F0F07}") END Is_Control; PROCEDURE ThisControls* (v: CtlT.Any): Controls; VAR new: Controls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5970C574-EB8C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisControls; PROCEDURE IsControls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5970C574-EB8C-11CD-8701-00AA003F0F07}") END IsControls; PROCEDURE This_Label* (v: CtlT.Any): _Label; VAR new: _Label; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E948-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Label; PROCEDURE Is_Label* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E948-E47C-11CD-8701-00AA003F0F07}") END Is_Label; PROCEDURE This_Rectangle* (v: CtlT.Any): _Rectangle; VAR new: _Rectangle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E94A-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Rectangle; PROCEDURE Is_Rectangle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E94A-E47C-11CD-8701-00AA003F0F07}") END Is_Rectangle; PROCEDURE This_Line* (v: CtlT.Any): _Line; VAR new: _Line; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E94C-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Line; PROCEDURE Is_Line* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E94C-E47C-11CD-8701-00AA003F0F07}") END Is_Line; PROCEDURE This_Image* (v: CtlT.Any): _Image; VAR new: _Image; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E94E-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Image; PROCEDURE Is_Image* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E94E-E47C-11CD-8701-00AA003F0F07}") END Is_Image; PROCEDURE This_CommandButton* (v: CtlT.Any): _CommandButton; VAR new: _CommandButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E950-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_CommandButton; PROCEDURE Is_CommandButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E950-E47C-11CD-8701-00AA003F0F07}") END Is_CommandButton; PROCEDURE This_OptionButton* (v: CtlT.Any): _OptionButton; VAR new: _OptionButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E952-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_OptionButton; PROCEDURE Is_OptionButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E952-E47C-11CD-8701-00AA003F0F07}") END Is_OptionButton; PROCEDURE This_Checkbox* (v: CtlT.Any): _Checkbox; VAR new: _Checkbox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E954-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Checkbox; PROCEDURE Is_Checkbox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E954-E47C-11CD-8701-00AA003F0F07}") END Is_Checkbox; PROCEDURE This_OptionGroup* (v: CtlT.Any): _OptionGroup; VAR new: _OptionGroup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E956-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_OptionGroup; PROCEDURE Is_OptionGroup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E956-E47C-11CD-8701-00AA003F0F07}") END Is_OptionGroup; PROCEDURE This_BoundObjectFrame* (v: CtlT.Any): _BoundObjectFrame; VAR new: _BoundObjectFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E958-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_BoundObjectFrame; PROCEDURE Is_BoundObjectFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E958-E47C-11CD-8701-00AA003F0F07}") END Is_BoundObjectFrame; PROCEDURE This_Textbox* (v: CtlT.Any): _Textbox; VAR new: _Textbox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E946-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Textbox; PROCEDURE Is_Textbox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E946-E47C-11CD-8701-00AA003F0F07}") END Is_Textbox; PROCEDURE This_ListBox* (v: CtlT.Any): _ListBox; VAR new: _ListBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E95A-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_ListBox; PROCEDURE Is_ListBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E95A-E47C-11CD-8701-00AA003F0F07}") END Is_ListBox; PROCEDURE This_Combobox* (v: CtlT.Any): _Combobox; VAR new: _Combobox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E95C-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Combobox; PROCEDURE Is_Combobox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E95C-E47C-11CD-8701-00AA003F0F07}") END Is_Combobox; PROCEDURE This_ObjectFrame* (v: CtlT.Any): _ObjectFrame; VAR new: _ObjectFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E95E-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_ObjectFrame; PROCEDURE Is_ObjectFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E95E-E47C-11CD-8701-00AA003F0F07}") END Is_ObjectFrame; PROCEDURE This_PageBreak* (v: CtlT.Any): _PageBreak; VAR new: _PageBreak; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E960-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_PageBreak; PROCEDURE Is_PageBreak* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E960-E47C-11CD-8701-00AA003F0F07}") END Is_PageBreak; PROCEDURE This_ToggleButton* (v: CtlT.Any): _ToggleButton; VAR new: _ToggleButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E962-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_ToggleButton; PROCEDURE Is_ToggleButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E962-E47C-11CD-8701-00AA003F0F07}") END Is_ToggleButton; PROCEDURE This_PaletteButton* (v: CtlT.Any): _PaletteButton; VAR new: _PaletteButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9CD4A760-A6A9-11CE-A686-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_PaletteButton; PROCEDURE Is_PaletteButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9CD4A760-A6A9-11CE-A686-00AA003F0F07}") END Is_PaletteButton; PROCEDURE This_SubForm* (v: CtlT.Any): _SubForm; VAR new: _SubForm; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E964-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_SubForm; PROCEDURE Is_SubForm* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E964-E47C-11CD-8701-00AA003F0F07}") END Is_SubForm; PROCEDURE This_SubReport* (v: CtlT.Any): _SubReport; VAR new: _SubReport; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E966-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_SubReport; PROCEDURE Is_SubReport* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E966-E47C-11CD-8701-00AA003F0F07}") END Is_SubReport; PROCEDURE This_CustomControl* (v: CtlT.Any): _CustomControl; VAR new: _CustomControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E968-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_CustomControl; PROCEDURE Is_CustomControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E968-E47C-11CD-8701-00AA003F0F07}") END Is_CustomControl; PROCEDURE This_TabControl* (v: CtlT.Any): _TabControl; VAR new: _TabControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E971-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_TabControl; PROCEDURE Is_TabControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E971-E47C-11CD-8701-00AA003F0F07}") END Is_TabControl; PROCEDURE This_Page* (v: CtlT.Any): _Page; VAR new: _Page; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3B06E974-E47C-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Page; PROCEDURE Is_Page* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3B06E974-E47C-11CD-8701-00AA003F0F07}") END Is_Page; PROCEDURE This_Section* (v: CtlT.Any): _Section; VAR new: _Section; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{331FDCFC-CF31-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Section; PROCEDURE Is_Section* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{331FDCFC-CF31-11CD-8701-00AA003F0F07}") END Is_Section; PROCEDURE This_GroupLevel* (v: CtlT.Any): _GroupLevel; VAR new: _GroupLevel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{331FDD27-CF31-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_GroupLevel; PROCEDURE Is_GroupLevel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{331FDD27-CF31-11CD-8701-00AA003F0F07}") END Is_GroupLevel; PROCEDURE ThisModule* (v: CtlT.Any): Module; VAR new: Module; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{331FDCFE-CF31-11CD-8701-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisModule; PROCEDURE IsModule* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{331FDCFE-CF31-11CD-8701-00AA003F0F07}") END IsModule; PROCEDURE ThisModules* (v: CtlT.Any): Modules; VAR new: Modules; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9DD0AF42-6E28-11CF-9008-00AA0042B7CE}"); RETURN new ELSE RETURN NIL END END ThisModules; PROCEDURE IsModules* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9DD0AF42-6E28-11CF-9008-00AA0042B7CE}") END IsModules; PROCEDURE This_Form* (v: CtlT.Any): _Form; VAR new: _Form; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{E5135D80-8F8D-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Form; PROCEDURE Is_Form* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{E5135D80-8F8D-101B-AF4E-00AA003F0F07}") END Is_Form; PROCEDURE ThisForms* (v: CtlT.Any): Forms; VAR new: Forms; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{B1BB0E80-6128-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisForms; PROCEDURE IsForms* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{B1BB0E80-6128-101B-AF4E-00AA003F0F07}") END IsForms; PROCEDURE This_Report* (v: CtlT.Any): _Report; VAR new: _Report; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{3E8B6B00-91FF-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Report; PROCEDURE Is_Report* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{3E8B6B00-91FF-101B-AF4E-00AA003F0F07}") END Is_Report; PROCEDURE ThisReports* (v: CtlT.Any): Reports; VAR new: Reports; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{D1523700-6128-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisReports; PROCEDURE IsReports* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{D1523700-6128-101B-AF4E-00AA003F0F07}") END IsReports; PROCEDURE ThisScreen* (v: CtlT.Any): Screen; VAR new: Screen; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{DC6B66C0-6128-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END ThisScreen; PROCEDURE IsScreen* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{DC6B66C0-6128-101B-AF4E-00AA003F0F07}") END IsScreen; PROCEDURE This_Application* (v: CtlT.Any): _Application; VAR new: _Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{68CCE6C0-6129-101B-AF4E-00AA003F0F07}"); RETURN new ELSE RETURN NIL END END This_Application; PROCEDURE Is_Application* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{68CCE6C0-6129-101B-AF4E-00AA003F0F07}") END Is_Application; PROCEDURE ThisReference* (v: CtlT.Any): Reference; VAR new: Reference; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{EB106212-9C89-11CF-A2B3-00A0C90542FF}"); RETURN new ELSE RETURN NIL END END ThisReference; PROCEDURE IsReference* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{EB106212-9C89-11CF-A2B3-00A0C90542FF}") END IsReference; PROCEDURE This_References* (v: CtlT.Any): _References; VAR new: _References; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{EB106213-9C89-11CF-A2B3-00A0C90542FF}"); RETURN new ELSE RETURN NIL END END This_References; PROCEDURE Is_References* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{EB106213-9C89-11CF-A2B3-00A0C90542FF}") END Is_References; PROCEDURE This_Dummy* (v: CtlT.Any): _Dummy; VAR new: _Dummy; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8B06E320-B23C-11CF-89A8-00A0C9054129}"); RETURN new ELSE RETURN NIL END END This_Dummy; PROCEDURE Is_Dummy* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8B06E320-B23C-11CF-89A8-00A0C9054129}") END Is_Dummy; PROCEDURE This_DataAccessPage* (v: CtlT.Any): _DataAccessPage; VAR new: _DataAccessPage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{493D8A72-1DB1-11D1-98A2-006008197D41}"); RETURN new ELSE RETURN NIL END END This_DataAccessPage; PROCEDURE Is_DataAccessPage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{493D8A72-1DB1-11D1-98A2-006008197D41}") END Is_DataAccessPage; PROCEDURE ThisDataAccessPages* (v: CtlT.Any): DataAccessPages; VAR new: DataAccessPages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{493D8A71-1DB1-11D1-98A2-006008197D41}"); RETURN new ELSE RETURN NIL END END ThisDataAccessPages; PROCEDURE IsDataAccessPages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{493D8A71-1DB1-11D1-98A2-006008197D41}") END IsDataAccessPages; PROCEDURE ThisAllObjects* (v: CtlT.Any): AllObjects; VAR new: AllObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{DDBD4001-44D5-11D1-98C0-006008197D41}"); RETURN new ELSE RETURN NIL END END ThisAllObjects; PROCEDURE IsAllObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{DDBD4001-44D5-11D1-98C0-006008197D41}") END IsAllObjects; PROCEDURE ThisAccessObjectProperty* (v: CtlT.Any): AccessObjectProperty; VAR new: AccessObjectProperty; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{1FE3E471-A7D0-11D1-9944-006008197D41}"); RETURN new ELSE RETURN NIL END END ThisAccessObjectProperty; PROCEDURE IsAccessObjectProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{1FE3E471-A7D0-11D1-9944-006008197D41}") END IsAccessObjectProperty; PROCEDURE ThisAccessObjectProperties* (v: CtlT.Any): AccessObjectProperties; VAR new: AccessObjectProperties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0921F331-A7C9-11D1-9944-006008197D41}"); RETURN new ELSE RETURN NIL END END ThisAccessObjectProperties; PROCEDURE IsAccessObjectProperties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0921F331-A7C9-11D1-9944-006008197D41}") END IsAccessObjectProperties; PROCEDURE This_CurrentProject* (v: CtlT.Any): _CurrentProject; VAR new: _CurrentProject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9212BA71-3E79-11D1-98BD-006008197D41}"); RETURN new ELSE RETURN NIL END END This_CurrentProject; PROCEDURE Is_CurrentProject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9212BA71-3E79-11D1-98BD-006008197D41}") END Is_CurrentProject; PROCEDURE This_CurrentData* (v: CtlT.Any): _CurrentData; VAR new: _CurrentData; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9212BA73-3E79-11D1-98BD-006008197D41}"); RETURN new ELSE RETURN NIL END END This_CurrentData; PROCEDURE Is_CurrentData* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9212BA73-3E79-11D1-98BD-006008197D41}") END Is_CurrentData; PROCEDURE ThisAccessObject* (v: CtlT.Any): AccessObject; VAR new: AccessObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{ABE316B1-3FF6-11D1-98BD-006008197D41}"); RETURN new ELSE RETURN NIL END END ThisAccessObject; PROCEDURE IsAccessObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{ABE316B1-3FF6-11D1-98BD-006008197D41}") END IsAccessObject; PROCEDURE This_WizHook* (v: CtlT.Any): _WizHook; VAR new: _WizHook; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{CB9D3171-4728-11D1-8334-006008197CC8}"); RETURN new ELSE RETURN NIL END END This_WizHook; PROCEDURE Is_WizHook* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{CB9D3171-4728-11D1-8334-006008197CC8}") END Is_WizHook; PROCEDURE This_DefaultWebOptions* (v: CtlT.Any): _DefaultWebOptions; VAR new: _DefaultWebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{416ED4F0-AB31-11D1-BF72-0060083E43CF}"); RETURN new ELSE RETURN NIL END END This_DefaultWebOptions; PROCEDURE Is_DefaultWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{416ED4F0-AB31-11D1-BF72-0060083E43CF}") END Is_DefaultWebOptions; PROCEDURE This_WebOptions* (v: CtlT.Any): _WebOptions; VAR new: _WebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{416ED4F6-AB31-11D1-BF72-0060083E43CF}"); RETURN new ELSE RETURN NIL END END This_WebOptions; PROCEDURE Is_WebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{416ED4F6-AB31-11D1-BF72-0060083E43CF}") END Is_WebOptions; (* ---------- DoCmd, dual, nonextensible ---------- *) PROCEDURE (this: DoCmd) AddMenu* (MenuName: CtlT.Any; MenuMacroName: CtlT.Any; StatusBarText: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(MenuName, arg[2]); CtlC.AnyVar(MenuMacroName, arg[1]); CtlC.AnyVar(StatusBarText, arg[0]); CtlC.CallParMethod(this, 1001, arg, NIL); END AddMenu; PROCEDURE (this: DoCmd) ApplyFilter* ((* optional *) FilterName: CtlT.Any; WhereCondition: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FilterName, arg[1]); CtlC.AnyVar(WhereCondition, arg[0]); CtlC.CallParMethod(this, 1002, arg, NIL); END ApplyFilter; PROCEDURE (this: DoCmd) Beep* (), NEW; BEGIN CtlC.CallMethod(this, 1003, NIL); END Beep; PROCEDURE (this: DoCmd) CancelEvent* (), NEW; BEGIN CtlC.CallMethod(this, 1004, NIL); END CancelEvent; PROCEDURE (this: DoCmd) Close* (ObjectType: AcObjectType; ObjectName: CtlT.Any; Save: AcCloseSave), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[2]); CtlC.AnyVar(ObjectName, arg[1]); CtlC.IntVar(Save, arg[0]); CtlC.CallParMethod(this, 1005, arg, NIL); END Close; PROCEDURE (this: DoCmd) CopyObject* (DestinationDatabase: CtlT.Any; NewName: CtlT.Any; SourceObjectType: AcObjectType; (* optional *) SourceObjectName: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(DestinationDatabase, arg[3]); CtlC.AnyVar(NewName, arg[2]); CtlC.IntVar(SourceObjectType, arg[1]); CtlC.AnyVar(SourceObjectName, arg[0]); CtlC.CallParMethod(this, 1006, arg, NIL); END CopyObject; PROCEDURE (this: DoCmd) DoMenuItem* (MenuBar: CtlT.Any; MenuName: CtlT.Any; Command: CtlT.Any; (* optional *) Subcommand: CtlT.Any; Version: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(MenuBar, arg[4]); CtlC.AnyVar(MenuName, arg[3]); CtlC.AnyVar(Command, arg[2]); CtlC.AnyVar(Subcommand, arg[1]); CtlC.AnyVar(Version, arg[0]); CtlC.CallParMethod(this, 1007, arg, NIL); END DoMenuItem; PROCEDURE (this: DoCmd) Echo* (EchoOn: CtlT.Any; (* optional *) StatusBarText: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(EchoOn, arg[1]); CtlC.AnyVar(StatusBarText, arg[0]); CtlC.CallParMethod(this, 1008, arg, NIL); END Echo; PROCEDURE (this: DoCmd) FindNext* (), NEW; BEGIN CtlC.CallMethod(this, 1009, NIL); END FindNext; PROCEDURE (this: DoCmd) FindRecord* (FindWhat: CtlT.Any; Match: AcFindMatch; MatchCase: CtlT.Any; Search: AcSearchDirection; SearchAsFormatted: CtlT.Any; OnlyCurrentField: AcFindField; (* optional *) FindFirst: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(FindWhat, arg[6]); CtlC.IntVar(Match, arg[5]); CtlC.AnyVar(MatchCase, arg[4]); CtlC.IntVar(Search, arg[3]); CtlC.AnyVar(SearchAsFormatted, arg[2]); CtlC.IntVar(OnlyCurrentField, arg[1]); CtlC.AnyVar(FindFirst, arg[0]); CtlC.CallParMethod(this, 1010, arg, NIL); END FindRecord; PROCEDURE (this: DoCmd) GoToControl* (ControlName: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ControlName, arg[0]); CtlC.CallParMethod(this, 1011, arg, NIL); END GoToControl; PROCEDURE (this: DoCmd) GoToPage* (PageNumber: CtlT.Any; (* optional *) Right: CtlT.Any; Down: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(PageNumber, arg[2]); CtlC.AnyVar(Right, arg[1]); CtlC.AnyVar(Down, arg[0]); CtlC.CallParMethod(this, 1012, arg, NIL); END GoToPage; PROCEDURE (this: DoCmd) GoToRecord* (ObjectType: AcDataObjectType; ObjectName: CtlT.Any; Record: AcRecord; (* optional *) Offset: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[3]); CtlC.AnyVar(ObjectName, arg[2]); CtlC.IntVar(Record, arg[1]); CtlC.AnyVar(Offset, arg[0]); CtlC.CallParMethod(this, 1013, arg, NIL); END GoToRecord; PROCEDURE (this: DoCmd) Hourglass* (HourglassOn: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(HourglassOn, arg[0]); CtlC.CallParMethod(this, 1014, arg, NIL); END Hourglass; PROCEDURE (this: DoCmd) Maximize* (), NEW; BEGIN CtlC.CallMethod(this, 1015, NIL); END Maximize; PROCEDURE (this: DoCmd) Minimize* (), NEW; BEGIN CtlC.CallMethod(this, 1016, NIL); END Minimize; PROCEDURE (this: DoCmd) MoveSize* ((* optional *) Right: CtlT.Any; Down: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Right, arg[3]); CtlC.AnyVar(Down, arg[2]); CtlC.AnyVar(Width, arg[1]); CtlC.AnyVar(Height, arg[0]); CtlC.CallParMethod(this, 1017, arg, NIL); END MoveSize; PROCEDURE (this: DoCmd) OpenForm* (FormName: CtlT.Any; View: AcFormView; FilterName: CtlT.Any; WhereCondition: CtlT.Any; DataMode: AcFormOpenDataMode; WindowMode: AcWindowMode; (* optional *) OpenArgs: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(FormName, arg[6]); CtlC.IntVar(View, arg[5]); CtlC.AnyVar(FilterName, arg[4]); CtlC.AnyVar(WhereCondition, arg[3]); CtlC.IntVar(DataMode, arg[2]); CtlC.IntVar(WindowMode, arg[1]); CtlC.AnyVar(OpenArgs, arg[0]); CtlC.CallParMethod(this, 1019, arg, NIL); END OpenForm; PROCEDURE (this: DoCmd) OpenQuery* (QueryName: CtlT.Any; View: AcView; DataMode: AcOpenDataMode), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(QueryName, arg[2]); CtlC.IntVar(View, arg[1]); CtlC.IntVar(DataMode, arg[0]); CtlC.CallParMethod(this, 1020, arg, NIL); END OpenQuery; PROCEDURE (this: DoCmd) OpenTable* (TableName: CtlT.Any; View: AcView; DataMode: AcOpenDataMode), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(TableName, arg[2]); CtlC.IntVar(View, arg[1]); CtlC.IntVar(DataMode, arg[0]); CtlC.CallParMethod(this, 1021, arg, NIL); END OpenTable; PROCEDURE (this: DoCmd) PrintOut* (PrintRange: AcPrintRange; PageFrom: CtlT.Any; PageTo: CtlT.Any; PrintQuality: AcPrintQuality; (* optional *) Copies: CtlT.Any; CollateCopies: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.IntVar(PrintRange, arg[5]); CtlC.AnyVar(PageFrom, arg[4]); CtlC.AnyVar(PageTo, arg[3]); CtlC.IntVar(PrintQuality, arg[2]); CtlC.AnyVar(Copies, arg[1]); CtlC.AnyVar(CollateCopies, arg[0]); CtlC.CallParMethod(this, 1022, arg, NIL); END PrintOut; PROCEDURE (this: DoCmd) Quit* (Options: AcQuitOption), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1023, arg, NIL); END Quit; PROCEDURE (this: DoCmd) Requery* ((* optional *) ControlName: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ControlName, arg[0]); CtlC.CallParMethod(this, 1024, arg, NIL); END Requery; PROCEDURE (this: DoCmd) RepaintObject* (ObjectType: AcObjectType; (* optional *) ObjectName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[1]); CtlC.AnyVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 1025, arg, NIL); END RepaintObject; PROCEDURE (this: DoCmd) Rename* (NewName: CtlT.Any; ObjectType: AcObjectType; (* optional *) OldName: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(NewName, arg[2]); CtlC.IntVar(ObjectType, arg[1]); CtlC.AnyVar(OldName, arg[0]); CtlC.CallParMethod(this, 1026, arg, NIL); END Rename; PROCEDURE (this: DoCmd) Restore* (), NEW; BEGIN CtlC.CallMethod(this, 1027, NIL); END Restore; PROCEDURE (this: DoCmd) RunMacro* (MacroName: CtlT.Any; (* optional *) RepeatCount: CtlT.Any; RepeatExpression: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(MacroName, arg[2]); CtlC.AnyVar(RepeatCount, arg[1]); CtlC.AnyVar(RepeatExpression, arg[0]); CtlC.CallParMethod(this, 1030, arg, NIL); END RunMacro; PROCEDURE (this: DoCmd) RunSQL* (SQLStatement: CtlT.Any; (* optional *) UseTransaction: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(SQLStatement, arg[1]); CtlC.AnyVar(UseTransaction, arg[0]); CtlC.CallParMethod(this, 1031, arg, NIL); END RunSQL; PROCEDURE (this: DoCmd) SelectObject* (ObjectType: AcObjectType; (* optional *) ObjectName: CtlT.Any; InDatabaseWindow: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[2]); CtlC.AnyVar(ObjectName, arg[1]); CtlC.AnyVar(InDatabaseWindow, arg[0]); CtlC.CallParMethod(this, 1032, arg, NIL); END SelectObject; PROCEDURE (this: DoCmd) SetWarnings* (WarningsOn: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(WarningsOn, arg[0]); CtlC.CallParMethod(this, 1035, arg, NIL); END SetWarnings; PROCEDURE (this: DoCmd) ShowAllRecords* (), NEW; BEGIN CtlC.CallMethod(this, 1036, NIL); END ShowAllRecords; PROCEDURE (this: DoCmd) OpenReport* (ReportName: CtlT.Any; View: AcView; (* optional *) FilterName: CtlT.Any; WhereCondition: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(ReportName, arg[3]); CtlC.IntVar(View, arg[2]); CtlC.AnyVar(FilterName, arg[1]); CtlC.AnyVar(WhereCondition, arg[0]); CtlC.CallParMethod(this, 1039, arg, NIL); END OpenReport; PROCEDURE (this: DoCmd) TransferDatabase* (TransferType: AcDataTransferType; DatabaseType: CtlT.Any; DatabaseName: CtlT.Any; ObjectType: AcObjectType; (* optional *) Source: CtlT.Any; Destination: CtlT.Any; StructureOnly: CtlT.Any; StoreLogin: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(TransferType, arg[7]); CtlC.AnyVar(DatabaseType, arg[6]); CtlC.AnyVar(DatabaseName, arg[5]); CtlC.IntVar(ObjectType, arg[4]); CtlC.AnyVar(Source, arg[3]); CtlC.AnyVar(Destination, arg[2]); CtlC.AnyVar(StructureOnly, arg[1]); CtlC.AnyVar(StoreLogin, arg[0]); CtlC.CallParMethod(this, 1040, arg, NIL); END TransferDatabase; PROCEDURE (this: DoCmd) TransferSpreadsheet* (TransferType: AcDataTransferType; SpreadsheetType: AcSpreadSheetType; (* optional *) TableName: CtlT.Any; FileName: CtlT.Any; HasFieldNames: CtlT.Any; Range: CtlT.Any; UseOA: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.IntVar(TransferType, arg[6]); CtlC.IntVar(SpreadsheetType, arg[5]); CtlC.AnyVar(TableName, arg[4]); CtlC.AnyVar(FileName, arg[3]); CtlC.AnyVar(HasFieldNames, arg[2]); CtlC.AnyVar(Range, arg[1]); CtlC.AnyVar(UseOA, arg[0]); CtlC.CallParMethod(this, 1041, arg, NIL); END TransferSpreadsheet; PROCEDURE (this: DoCmd) TransferText* (TransferType: AcTextTransferType; (* optional *) SpecificationName: CtlT.Any; TableName: CtlT.Any; FileName: CtlT.Any; HasFieldNames: CtlT.Any; HTMLTableName: CtlT.Any; CodePage: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.IntVar(TransferType, arg[6]); CtlC.AnyVar(SpecificationName, arg[5]); CtlC.AnyVar(TableName, arg[4]); CtlC.AnyVar(FileName, arg[3]); CtlC.AnyVar(HasFieldNames, arg[2]); CtlC.AnyVar(HTMLTableName, arg[1]); CtlC.AnyVar(CodePage, arg[0]); CtlC.CallParMethod(this, 1042, arg, NIL); END TransferText; PROCEDURE (this: DoCmd) OutputTo* (ObjectType: AcOutputObjectType; (* optional *) ObjectName: CtlT.Any; OutputFormat: CtlT.Any; OutputFile: CtlT.Any; AutoStart: CtlT.Any; TemplateFile: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[5]); CtlC.AnyVar(ObjectName, arg[4]); CtlC.AnyVar(OutputFormat, arg[3]); CtlC.AnyVar(OutputFile, arg[2]); CtlC.AnyVar(AutoStart, arg[1]); CtlC.AnyVar(TemplateFile, arg[0]); CtlC.CallParMethod(this, 1341, arg, NIL); END OutputTo; PROCEDURE (this: DoCmd) DeleteObject* (ObjectType: AcObjectType; (* optional *) ObjectName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[1]); CtlC.AnyVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 1372, arg, NIL); END DeleteObject; PROCEDURE (this: DoCmd) OpenModule* ((* optional *) ModuleName: CtlT.Any; ProcedureName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(ModuleName, arg[1]); CtlC.AnyVar(ProcedureName, arg[0]); CtlC.CallParMethod(this, 1374, arg, NIL); END OpenModule; PROCEDURE (this: DoCmd) SendObject* (ObjectType: AcSendObjectType; (* optional *) ObjectName: CtlT.Any; OutputFormat: CtlT.Any; To: CtlT.Any; Cc: CtlT.Any; Bcc: CtlT.Any; Subject: CtlT.Any; MessageText: CtlT.Any; EditMessage: CtlT.Any; TemplateFile: CtlT.Any), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[9]); CtlC.AnyVar(ObjectName, arg[8]); CtlC.AnyVar(OutputFormat, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Cc, arg[5]); CtlC.AnyVar(Bcc, arg[4]); CtlC.AnyVar(Subject, arg[3]); CtlC.AnyVar(MessageText, arg[2]); CtlC.AnyVar(EditMessage, arg[1]); CtlC.AnyVar(TemplateFile, arg[0]); CtlC.CallParMethod(this, 1377, arg, NIL); END SendObject; PROCEDURE (this: DoCmd) ShowToolbar* (ToolbarName: CtlT.Any; Show: AcShowToolbar), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(ToolbarName, arg[1]); CtlC.IntVar(Show, arg[0]); CtlC.CallParMethod(this, 1394, arg, NIL); END ShowToolbar; PROCEDURE (this: DoCmd) Save* (ObjectType: AcObjectType; (* optional *) ObjectName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[1]); CtlC.AnyVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 1453, arg, NIL); END Save; PROCEDURE (this: DoCmd) SetMenuItem* (MenuIndex: CtlT.Any; (* optional *) CommandIndex: CtlT.Any; SubcommandIndex: CtlT.Any; Flag: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(MenuIndex, arg[3]); CtlC.AnyVar(CommandIndex, arg[2]); CtlC.AnyVar(SubcommandIndex, arg[1]); CtlC.AnyVar(Flag, arg[0]); CtlC.CallParMethod(this, 1454, arg, NIL); END SetMenuItem; PROCEDURE (this: DoCmd) RunCommand* (Command: AcCommand), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Command, arg[0]); CtlC.CallParMethod(this, 1602, arg, NIL); END RunCommand; PROCEDURE (this: DoCmd) OpenDataAccessPage* (DataAccessPageName: CtlT.Any; View: AcDataAccessPageView), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(DataAccessPageName, arg[1]); CtlC.IntVar(View, arg[0]); CtlC.CallParMethod(this, 1771, arg, NIL); END OpenDataAccessPage; PROCEDURE (this: DoCmd) OpenView* (ViewName: CtlT.Any; View: AcView; DataMode: AcOpenDataMode), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(ViewName, arg[2]); CtlC.IntVar(View, arg[1]); CtlC.IntVar(DataMode, arg[0]); CtlC.CallParMethod(this, 1793, arg, NIL); END OpenView; PROCEDURE (this: DoCmd) OpenDiagram* (DiagramName: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(DiagramName, arg[0]); CtlC.CallParMethod(this, 1794, arg, NIL); END OpenDiagram; PROCEDURE (this: DoCmd) OpenStoredProcedure* (ProcedureName: CtlT.Any; View: AcView; DataMode: AcOpenDataMode), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(ProcedureName, arg[2]); CtlC.IntVar(View, arg[1]); CtlC.IntVar(DataMode, arg[0]); CtlC.CallParMethod(this, 1795, arg, NIL); END OpenStoredProcedure; (* ---------- _RecordsetEvents, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _RecordsetEvents) WillChangeField* (cFields: INTEGER; Fields: CtlT.Any; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(cFields, arg[3]); CtlC.AnyVar(Fields, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 9, arg, NIL); END WillChangeField; PROCEDURE (this: _RecordsetEvents) FieldChangeComplete* (cFields: INTEGER; Fields: CtlT.Any; pError: CtlT.IUnknown; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(cFields, arg[4]); CtlC.AnyVar(Fields, arg[3]); CtlC.IntfceVar(pError, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END FieldChangeComplete; PROCEDURE (this: _RecordsetEvents) WillChangeRecord* (adReason: CtlADODB.EventReasonEnum; cRecords: INTEGER; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[3]); CtlC.IntVar(cRecords, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END WillChangeRecord; PROCEDURE (this: _RecordsetEvents) RecordChangeComplete* (adReason: CtlADODB.EventReasonEnum; cRecords: INTEGER; pError: CtlT.IUnknown; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[4]); CtlC.IntVar(cRecords, arg[3]); CtlC.IntfceVar(pError, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END RecordChangeComplete; PROCEDURE (this: _RecordsetEvents) WillChangeRecordset* (adReason: CtlADODB.EventReasonEnum; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END WillChangeRecordset; PROCEDURE (this: _RecordsetEvents) RecordsetChangeComplete* (adReason: CtlADODB.EventReasonEnum; pError: CtlT.IUnknown; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[3]); CtlC.IntfceVar(pError, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END RecordsetChangeComplete; PROCEDURE (this: _RecordsetEvents) WillMove* (adReason: CtlADODB.EventReasonEnum; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END WillMove; PROCEDURE (this: _RecordsetEvents) MoveComplete* (adReason: CtlADODB.EventReasonEnum; pError: CtlT.IUnknown; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(adReason, arg[3]); CtlC.IntfceVar(pError, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END MoveComplete; PROCEDURE (this: _RecordsetEvents) EndOfRecordset* (VAR fMoreData: SHORTINT; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.RefSIntVar(fMoreData, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END EndOfRecordset; PROCEDURE (this: _RecordsetEvents) FetchProgress* (Progress: INTEGER; MaxProgress: INTEGER; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Progress, arg[3]); CtlC.IntVar(MaxProgress, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END FetchProgress; PROCEDURE (this: _RecordsetEvents) FetchComplete* (pError: CtlT.IUnknown; VAR adStatus: CtlADODB.EventStatusEnum; pRecordset: CtlT.IUnknown), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntfceVar(pError, arg[2]); CtlC.RefIntVar(adStatus, arg[1]); CtlC.IntfceVar(pRecordset, arg[0]); CtlC.CallParMethod(this, 19, arg, NIL); END FetchComplete; (* ---------- _AccessProperty, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _AccessProperty) Properties* (): CtlDAO.Properties, NEW; BEGIN RETURN CtlDAO.ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _AccessProperty) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _AccessProperty) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _AccessProperty) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Name; PROCEDURE (this: _AccessProperty) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTName; PROCEDURE (this: _AccessProperty) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809348) END Type; PROCEDURE (this: _AccessProperty) PUTType* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809348, p1) END PUTType; PROCEDURE (this: _AccessProperty) Inherited* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809350) END Inherited; PROCEDURE (this: _AccessProperty) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _AccessProperty) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _AccessProperty) Category* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 2096) END Category; (* ---------- Properties, dual, nonextensible ---------- *) PROCEDURE (this: Properties) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Properties) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Properties) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Properties) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Properties) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _FormatCondition, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _FormatCondition) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: _FormatCondition) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: _FormatCondition) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: _FormatCondition) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: _FormatCondition) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2127) END FontBold; PROCEDURE (this: _FormatCondition) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2127, p1) END PUTFontBold; PROCEDURE (this: _FormatCondition) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2128) END FontItalic; PROCEDURE (this: _FormatCondition) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2128, p1) END PUTFontItalic; PROCEDURE (this: _FormatCondition) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2131) END FontUnderline; PROCEDURE (this: _FormatCondition) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2131, p1) END PUTFontUnderline; PROCEDURE (this: _FormatCondition) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: _FormatCondition) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: _FormatCondition) Type* (): AcFormatConditionType, NEW; BEGIN RETURN CtlC.GetInt(this, 2095) END Type; PROCEDURE (this: _FormatCondition) Operator* (): AcFormatConditionOperator, NEW; BEGIN RETURN CtlC.GetInt(this, 2199) END Operator; PROCEDURE (this: _FormatCondition) Expression1* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2200) END Expression1; PROCEDURE (this: _FormatCondition) Expression2* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2201) END Expression2; PROCEDURE (this: _FormatCondition) Modify* (Type: AcFormatConditionType; Operator: AcFormatConditionOperator; (* optional *) Expression1: CtlT.Any; Expression2: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Operator, arg[2]); CtlC.AnyVar(Expression1, arg[1]); CtlC.AnyVar(Expression2, arg[0]); CtlC.CallParMethod(this, 2202, arg, NIL); END Modify; PROCEDURE (this: _FormatCondition) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2063, NIL); END Delete; (* ---------- FormatConditions, dual, nonextensible ---------- *) PROCEDURE (this: FormatConditions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: FormatConditions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: FormatConditions) Item* (Index: CtlT.Any): _FormatCondition, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_FormatCondition(CtlC.VarAny(ret)) END Item; PROCEDURE (this: FormatConditions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: FormatConditions) Add* (Type: AcFormatConditionType; Operator: AcFormatConditionOperator; (* optional *) Expression1: CtlT.Any; Expression2: CtlT.Any): _FormatCondition, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Operator, arg[2]); CtlC.AnyVar(Expression1, arg[1]); CtlC.AnyVar(Expression2, arg[0]); CtlC.CallParMethod(this, 2191, arg, ret); RETURN This_FormatCondition(CtlC.VarAny(ret)) END Add; PROCEDURE (this: FormatConditions) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2063, NIL); END Delete; PROCEDURE (this: FormatConditions) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _ItemsSelected, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _ItemsSelected) Item* (Index: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarInt(ret) END Item; PROCEDURE (this: _ItemsSelected) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: _ItemsSelected) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Children, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Children) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Children) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Children) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _AccessField, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _AccessField) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _AccessField) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; (* ---------- _Hyperlink, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Hyperlink) SubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2182) END SubAddress; PROCEDURE (this: _Hyperlink) PUTSubAddress* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 2182, p1) END PUTSubAddress; PROCEDURE (this: _Hyperlink) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2183) END Address; PROCEDURE (this: _Hyperlink) PUTAddress* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 2183, p1) END PUTAddress; PROCEDURE (this: _Hyperlink) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 2184, NIL); END AddToFavorites; PROCEDURE (this: _Hyperlink) Follow* (NewWindow: BOOLEAN; AddHistory: BOOLEAN; ExtraInfo: CtlT.Any; Method: CtlOffice.MsoExtraInfoMethod; HeaderInfo: ARRAY OF CHAR), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.BoolVar(NewWindow, arg[4]); CtlC.BoolVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.IntVar(Method, arg[1]); CtlC.StrVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 2185, arg, NIL); END Follow; PROCEDURE (this: _Hyperlink) EmailSubject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2209) END EmailSubject; PROCEDURE (this: _Hyperlink) PUTEmailSubject* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 2209, p1) END PUTEmailSubject; PROCEDURE (this: _Hyperlink) ScreenTip* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2211) END ScreenTip; PROCEDURE (this: _Hyperlink) PUTScreenTip* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 2211, p1) END PUTScreenTip; PROCEDURE (this: _Hyperlink) TextToDisplay* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2231) END TextToDisplay; PROCEDURE (this: _Hyperlink) PUTTextToDisplay* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 2231, p1) END PUTTextToDisplay; PROCEDURE (this: _Hyperlink) CreateNewDocument* (FileName: ARRAY OF CHAR; EditNow: BOOLEAN; Overwrite: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.BoolVar(EditNow, arg[1]); CtlC.BoolVar(Overwrite, arg[0]); CtlC.CallParMethod(this, 2232, arg, NIL); END CreateNewDocument; (* ---------- Pages, dual, nonextensible ---------- *) PROCEDURE (this: Pages) Item* (Index: CtlT.Any): Page, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Page(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Pages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Pages) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Pages) Add* ((* optional *) Before: CtlT.Any): Page, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 2191, arg, ret); RETURN This_Page(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Pages) Remove* ((* optional *) Item: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallParMethod(this, 2192, arg, NIL); END Remove; (* ---------- _Control, hidden, dual ---------- *) PROCEDURE (this: _Control) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Control) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Control) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _Control) Dropdown* (), NEW; BEGIN CtlC.CallMethod(this, 2143, NIL); END Dropdown; PROCEDURE (this: _Control) Column* (Index: INTEGER; (* optional *) Row: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Row, arg[0]); CtlC.CallGetMethod(this, 2101, arg, ret); RETURN CtlC.VarAny(ret) END Column; PROCEDURE (this: _Control) Selected* (lRow: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lRow, arg[0]); CtlC.CallGetMethod(this, 2113, arg, ret); RETURN CtlC.VarInt(ret) END Selected; PROCEDURE (this: _Control) PUTSelected* (lRow: INTEGER; p2: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(lRow, arg[1]); CtlC.IntVar(p2, arg[0]); CtlC.CallPutMethod(this, 2113, arg, NIL); END PUTSelected; PROCEDURE (this: _Control) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _Control) Form* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2089)) END Form; PROCEDURE (this: _Control) Report* (): Report, NEW; BEGIN RETURN This_Report(CtlC.GetAny(this, 2097)) END Report; PROCEDURE (this: _Control) ItemData* (Index: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2103, arg, ret); RETURN CtlC.VarAny(ret) END ItemData; PROCEDURE (this: _Control) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2104) END Object; PROCEDURE (this: _Control) ObjectVerbs* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2105, arg, ret); RETURN CtlC.VarStr(ret) END ObjectVerbs; PROCEDURE (this: _Control) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Control) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Control) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Control) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Control) ItemsSelected* (): _ItemsSelected, NEW; BEGIN RETURN This_ItemsSelected(CtlC.GetAny(this, 2137)) END ItemsSelected; PROCEDURE (this: _Control) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Control) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Control) Pages* (): Pages, NEW; BEGIN RETURN ThisPages(CtlC.GetAny(this, 2180)) END Pages; PROCEDURE (this: _Control) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Control) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; (* ---------- Controls, dual, nonextensible ---------- *) PROCEDURE (this: Controls) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Controls) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Controls) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Controls) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Controls) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _Label, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Label) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Label) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Label) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Label) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Label) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Label) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Label) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Label) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Label) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Label) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Label) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Label) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Label) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Label) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Label) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Label) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Label) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Label) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Label) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Label) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Label) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Label) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Label) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Label) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Label) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Label) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Label) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _Label) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Label) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Label) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Label) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Label) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Label) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Label) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _Label) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _Label) HyperlinkAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 343) END HyperlinkAddress; PROCEDURE (this: _Label) PUTHyperlinkAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 343, p1) END PUTHyperlinkAddress; PROCEDURE (this: _Label) HyperlinkSubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 347) END HyperlinkSubAddress; PROCEDURE (this: _Label) PUTHyperlinkSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 347, p1) END PUTHyperlinkSubAddress; PROCEDURE (this: _Label) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Label) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Label) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Label) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Label) Vertical* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 355) END Vertical; PROCEDURE (this: _Label) PUTVertical* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 355, p1) END PUTVertical; PROCEDURE (this: _Label) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Label) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Label) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Label) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Label) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Label) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Label) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Label) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Label) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _Label) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _Label) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Label) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Label) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Label) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Label) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Label) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Label) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Label) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Label) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Label) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Label) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Label) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Label) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Label) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Label) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _Label) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _Label) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _Label) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _Label) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _Label) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _Label) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _Label) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _Label) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _Label) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _Label) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _Label) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _Label) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _Label) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _Label) TextAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 136) END TextAlign; PROCEDURE (this: _Label) PUTTextAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 136, p1) END PUTTextAlign; PROCEDURE (this: _Label) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _Label) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _Label) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Label) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Label) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Label) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Label) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Label) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Label) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Label) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Label) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Label) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Label) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Label) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Label) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Label) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Label) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Label) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Label) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Label) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Label) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Label) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Label) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Label) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Label) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Label) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Label) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Label) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Label) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _Label) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _Label) NumeralShapes* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 372) END NumeralShapes; PROCEDURE (this: _Label) PUTNumeralShapes* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 372, p1) END PUTNumeralShapes; PROCEDURE (this: _Label) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Label) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _Label) LeftMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 384) END LeftMargin; PROCEDURE (this: _Label) PUTLeftMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 384, p1) END PUTLeftMargin; PROCEDURE (this: _Label) TopMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 385) END TopMargin; PROCEDURE (this: _Label) PUTTopMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 385, p1) END PUTTopMargin; PROCEDURE (this: _Label) LineSpacing* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 386) END LineSpacing; PROCEDURE (this: _Label) PUTLineSpacing* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 386, p1) END PUTLineSpacing; PROCEDURE (this: _Label) RightMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 388) END RightMargin; PROCEDURE (this: _Label) PUTRightMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 388, p1) END PUTRightMargin; PROCEDURE (this: _Label) BottomMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 389) END BottomMargin; PROCEDURE (this: _Label) PUTBottomMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 389, p1) END PUTBottomMargin; (* ---------- _Rectangle, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Rectangle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Rectangle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Rectangle) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Rectangle) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Rectangle) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Rectangle) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Rectangle) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Rectangle) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Rectangle) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Rectangle) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Rectangle) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Rectangle) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Rectangle) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Rectangle) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Rectangle) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Rectangle) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Rectangle) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Rectangle) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Rectangle) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Rectangle) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Rectangle) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Rectangle) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Rectangle) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Rectangle) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _Rectangle) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _Rectangle) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Rectangle) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Rectangle) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Rectangle) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Rectangle) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Rectangle) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Rectangle) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Rectangle) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Rectangle) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Rectangle) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Rectangle) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Rectangle) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Rectangle) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Rectangle) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Rectangle) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Rectangle) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Rectangle) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Rectangle) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Rectangle) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Rectangle) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Rectangle) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Rectangle) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Rectangle) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Rectangle) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Rectangle) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Rectangle) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Rectangle) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Rectangle) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Rectangle) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Rectangle) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Rectangle) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Rectangle) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Rectangle) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Rectangle) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Rectangle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Rectangle) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Line, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Line) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Line) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Line) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Line) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Line) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Line) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Line) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Line) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Line) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Line) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Line) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Line) LineSlant* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 55) END LineSlant; PROCEDURE (this: _Line) PUTLineSlant* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 55, p1) END PUTLineSlant; PROCEDURE (this: _Line) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Line) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Line) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Line) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Line) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Line) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Line) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Line) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Line) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Line) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Line) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Line) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Line) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Line) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Line) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Line) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Line) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Line) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Line) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Line) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Line) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Line) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Line) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Line) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Line) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Line) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Line) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Line) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Line) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Line) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Line) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Line) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Line) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Line) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Line) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Line) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Image, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Image) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Image) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Image) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _Image) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Image) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Image) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Image) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Image) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Image) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Image) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Image) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _Image) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Image) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Image) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Image) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Image) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Image) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Image) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _Image) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _Image) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _Image) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _Image) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _Image) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _Image) SizeMode* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 89) END SizeMode; PROCEDURE (this: _Image) PUTSizeMode* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 89, p1) END PUTSizeMode; PROCEDURE (this: _Image) PictureAlignment* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 309) END PictureAlignment; PROCEDURE (this: _Image) PUTPictureAlignment* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 309, p1) END PUTPictureAlignment; PROCEDURE (this: _Image) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 313) END PictureTiling; PROCEDURE (this: _Image) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 313, p1) END PUTPictureTiling; PROCEDURE (this: _Image) HyperlinkAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 343) END HyperlinkAddress; PROCEDURE (this: _Image) PUTHyperlinkAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 343, p1) END PUTHyperlinkAddress; PROCEDURE (this: _Image) HyperlinkSubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 347) END HyperlinkSubAddress; PROCEDURE (this: _Image) PUTHyperlinkSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 347, p1) END PUTHyperlinkSubAddress; PROCEDURE (this: _Image) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Image) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Image) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Image) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Image) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Image) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Image) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Image) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Image) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Image) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Image) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Image) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Image) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _Image) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _Image) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Image) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Image) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Image) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Image) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Image) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Image) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Image) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Image) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Image) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Image) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Image) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Image) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Image) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Image) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Image) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Image) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Image) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Image) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Image) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Image) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Image) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Image) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _Image) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _Image) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Image) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Image) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Image) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Image) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Image) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Image) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Image) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Image) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Image) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Image) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Image) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Image) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Image) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Image) ImageHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 307) END ImageHeight; PROCEDURE (this: _Image) PUTImageHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 307, p1) END PUTImageHeight; PROCEDURE (this: _Image) ImageWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 308) END ImageWidth; PROCEDURE (this: _Image) PUTImageWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 308, p1) END PUTImageWidth; PROCEDURE (this: _Image) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Image) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Image) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Image) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Image) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Image) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _CommandButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _CommandButton) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _CommandButton) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _CommandButton) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _CommandButton) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _CommandButton) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _CommandButton) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _CommandButton) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _CommandButton) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _CommandButton) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _CommandButton) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _CommandButton) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _CommandButton) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _CommandButton) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _CommandButton) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _CommandButton) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _CommandButton) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _CommandButton) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _CommandButton) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _CommandButton) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _CommandButton) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _CommandButton) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _CommandButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _CommandButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _CommandButton) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _CommandButton) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _CommandButton) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _CommandButton) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _CommandButton) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _CommandButton) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _CommandButton) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _CommandButton) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _CommandButton) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _CommandButton) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _CommandButton) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _CommandButton) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _CommandButton) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _CommandButton) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _CommandButton) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _CommandButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _CommandButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _CommandButton) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _CommandButton) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _CommandButton) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _CommandButton) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _CommandButton) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _CommandButton) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _CommandButton) Transparent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 46) END Transparent; PROCEDURE (this: _CommandButton) PUTTransparent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 46, p1) END PUTTransparent; PROCEDURE (this: _CommandButton) Default* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 220) END Default; PROCEDURE (this: _CommandButton) PUTDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 220, p1) END PUTDefault; PROCEDURE (this: _CommandButton) Cancel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 221) END Cancel; PROCEDURE (this: _CommandButton) PUTCancel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 221, p1) END PUTCancel; PROCEDURE (this: _CommandButton) AutoRepeat* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END AutoRepeat; PROCEDURE (this: _CommandButton) PUTAutoRepeat* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTAutoRepeat; PROCEDURE (this: _CommandButton) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _CommandButton) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _CommandButton) OnPush* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 155) END OnPush; PROCEDURE (this: _CommandButton) PUTOnPush* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 155, p1) END PUTOnPush; PROCEDURE (this: _CommandButton) HyperlinkAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 343) END HyperlinkAddress; PROCEDURE (this: _CommandButton) PUTHyperlinkAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 343, p1) END PUTHyperlinkAddress; PROCEDURE (this: _CommandButton) HyperlinkSubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 347) END HyperlinkSubAddress; PROCEDURE (this: _CommandButton) PUTHyperlinkSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 347, p1) END PUTHyperlinkSubAddress; PROCEDURE (this: _CommandButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _CommandButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _CommandButton) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _CommandButton) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _CommandButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _CommandButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _CommandButton) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _CommandButton) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _CommandButton) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _CommandButton) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _CommandButton) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _CommandButton) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _CommandButton) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _CommandButton) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _CommandButton) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _CommandButton) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _CommandButton) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _CommandButton) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _CommandButton) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _CommandButton) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _CommandButton) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _CommandButton) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _CommandButton) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _CommandButton) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _CommandButton) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _CommandButton) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _CommandButton) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _CommandButton) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _CommandButton) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _CommandButton) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _CommandButton) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _CommandButton) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _CommandButton) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _CommandButton) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _CommandButton) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _CommandButton) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _CommandButton) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _CommandButton) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _CommandButton) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _CommandButton) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _CommandButton) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _CommandButton) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _CommandButton) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _CommandButton) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _CommandButton) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _CommandButton) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _CommandButton) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _CommandButton) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _CommandButton) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _CommandButton) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _CommandButton) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _CommandButton) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _CommandButton) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _CommandButton) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _CommandButton) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _CommandButton) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _CommandButton) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _CommandButton) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _CommandButton) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _CommandButton) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _CommandButton) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _CommandButton) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _CommandButton) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _CommandButton) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _CommandButton) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _CommandButton) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _CommandButton) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _CommandButton) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _CommandButton) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _CommandButton) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _CommandButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _CommandButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _CommandButton) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _CommandButton) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _CommandButton) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _CommandButton) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _CommandButton) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _CommandButton) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _CommandButton) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _CommandButton) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _CommandButton) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _CommandButton) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _CommandButton) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _CommandButton) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _CommandButton) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _CommandButton) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _CommandButton) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _CommandButton) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _CommandButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _CommandButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _OptionButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _OptionButton) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _OptionButton) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _OptionButton) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _OptionButton) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _OptionButton) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _OptionButton) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _OptionButton) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _OptionButton) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _OptionButton) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _OptionButton) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _OptionButton) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _OptionButton) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _OptionButton) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _OptionButton) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _OptionButton) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _OptionButton) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _OptionButton) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _OptionButton) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _OptionButton) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _OptionButton) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _OptionButton) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _OptionButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _OptionButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _OptionButton) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _OptionButton) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _OptionButton) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _OptionButton) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _OptionButton) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _OptionButton) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _OptionButton) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _OptionButton) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _OptionButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _OptionButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _OptionButton) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _OptionButton) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _OptionButton) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _OptionButton) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _OptionButton) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _OptionButton) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _OptionButton) OptionValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 58) END OptionValue; PROCEDURE (this: _OptionButton) PUTOptionValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 58, p1) END PUTOptionValue; PROCEDURE (this: _OptionButton) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _OptionButton) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _OptionButton) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _OptionButton) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _OptionButton) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _OptionButton) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _OptionButton) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _OptionButton) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _OptionButton) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _OptionButton) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _OptionButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _OptionButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _OptionButton) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _OptionButton) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _OptionButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _OptionButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _OptionButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _OptionButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _OptionButton) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END TripleState; PROCEDURE (this: _OptionButton) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 294, p1) END PUTTripleState; PROCEDURE (this: _OptionButton) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _OptionButton) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _OptionButton) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _OptionButton) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _OptionButton) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _OptionButton) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _OptionButton) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _OptionButton) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _OptionButton) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _OptionButton) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _OptionButton) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _OptionButton) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _OptionButton) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _OptionButton) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _OptionButton) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _OptionButton) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _OptionButton) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _OptionButton) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _OptionButton) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _OptionButton) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _OptionButton) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _OptionButton) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _OptionButton) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _OptionButton) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _OptionButton) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _OptionButton) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _OptionButton) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _OptionButton) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _OptionButton) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _OptionButton) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _OptionButton) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _OptionButton) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _OptionButton) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _OptionButton) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _OptionButton) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _OptionButton) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _OptionButton) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _OptionButton) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _OptionButton) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _OptionButton) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _OptionButton) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _OptionButton) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _OptionButton) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _OptionButton) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _OptionButton) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _OptionButton) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _OptionButton) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _OptionButton) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _OptionButton) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _OptionButton) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _OptionButton) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _OptionButton) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _OptionButton) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _OptionButton) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _OptionButton) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _OptionButton) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _OptionButton) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _OptionButton) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _OptionButton) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _OptionButton) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _OptionButton) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _OptionButton) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _OptionButton) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _OptionButton) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _OptionButton) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _OptionButton) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _OptionButton) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _OptionButton) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _OptionButton) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _OptionButton) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _OptionButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _OptionButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _OptionButton) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _OptionButton) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _OptionButton) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _OptionButton) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _OptionButton) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _OptionButton) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _OptionButton) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _OptionButton) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _OptionButton) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _OptionButton) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _OptionButton) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _OptionButton) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _OptionButton) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _OptionButton) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _OptionButton) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _OptionButton) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _OptionButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _OptionButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Checkbox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Checkbox) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Checkbox) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Checkbox) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Checkbox) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Checkbox) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Checkbox) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Checkbox) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Checkbox) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Checkbox) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Checkbox) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Checkbox) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Checkbox) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Checkbox) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Checkbox) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Checkbox) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Checkbox) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Checkbox) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Checkbox) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Checkbox) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Checkbox) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Checkbox) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Checkbox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Checkbox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Checkbox) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _Checkbox) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _Checkbox) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Checkbox) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Checkbox) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Checkbox) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Checkbox) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Checkbox) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Checkbox) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Checkbox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _Checkbox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _Checkbox) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Checkbox) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Checkbox) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Checkbox) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Checkbox) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Checkbox) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Checkbox) OptionValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 58) END OptionValue; PROCEDURE (this: _Checkbox) PUTOptionValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 58, p1) END PUTOptionValue; PROCEDURE (this: _Checkbox) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _Checkbox) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _Checkbox) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _Checkbox) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _Checkbox) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _Checkbox) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _Checkbox) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _Checkbox) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _Checkbox) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _Checkbox) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _Checkbox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Checkbox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Checkbox) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Checkbox) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Checkbox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _Checkbox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _Checkbox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _Checkbox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _Checkbox) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END TripleState; PROCEDURE (this: _Checkbox) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 294, p1) END PUTTripleState; PROCEDURE (this: _Checkbox) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _Checkbox) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _Checkbox) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _Checkbox) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _Checkbox) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _Checkbox) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _Checkbox) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Checkbox) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Checkbox) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Checkbox) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Checkbox) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Checkbox) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Checkbox) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Checkbox) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Checkbox) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Checkbox) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Checkbox) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Checkbox) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Checkbox) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Checkbox) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Checkbox) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Checkbox) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Checkbox) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Checkbox) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Checkbox) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Checkbox) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Checkbox) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Checkbox) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Checkbox) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Checkbox) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Checkbox) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Checkbox) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Checkbox) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _Checkbox) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _Checkbox) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _Checkbox) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _Checkbox) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _Checkbox) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _Checkbox) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _Checkbox) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _Checkbox) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _Checkbox) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _Checkbox) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _Checkbox) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _Checkbox) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _Checkbox) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _Checkbox) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _Checkbox) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _Checkbox) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Checkbox) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Checkbox) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Checkbox) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Checkbox) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Checkbox) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Checkbox) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Checkbox) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Checkbox) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Checkbox) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Checkbox) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _Checkbox) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _Checkbox) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _Checkbox) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _Checkbox) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _Checkbox) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _Checkbox) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _Checkbox) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _Checkbox) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _Checkbox) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _Checkbox) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _Checkbox) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _Checkbox) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Checkbox) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Checkbox) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Checkbox) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Checkbox) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Checkbox) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Checkbox) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Checkbox) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Checkbox) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Checkbox) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Checkbox) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _Checkbox) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _Checkbox) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _Checkbox) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _Checkbox) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _Checkbox) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _Checkbox) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _Checkbox) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _Checkbox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Checkbox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _OptionGroup, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _OptionGroup) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _OptionGroup) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _OptionGroup) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _OptionGroup) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _OptionGroup) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _OptionGroup) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _OptionGroup) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _OptionGroup) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _OptionGroup) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _OptionGroup) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _OptionGroup) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _OptionGroup) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _OptionGroup) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _OptionGroup) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _OptionGroup) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _OptionGroup) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _OptionGroup) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _OptionGroup) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _OptionGroup) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _OptionGroup) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _OptionGroup) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _OptionGroup) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _OptionGroup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _OptionGroup) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _OptionGroup) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _OptionGroup) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _OptionGroup) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _OptionGroup) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _OptionGroup) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _OptionGroup) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _OptionGroup) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _OptionGroup) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _OptionGroup) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _OptionGroup) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _OptionGroup) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _OptionGroup) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _OptionGroup) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _OptionGroup) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _OptionGroup) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _OptionGroup) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _OptionGroup) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _OptionGroup) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _OptionGroup) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _OptionGroup) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _OptionGroup) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _OptionGroup) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _OptionGroup) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _OptionGroup) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _OptionGroup) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _OptionGroup) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _OptionGroup) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _OptionGroup) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _OptionGroup) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _OptionGroup) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _OptionGroup) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _OptionGroup) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _OptionGroup) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _OptionGroup) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _OptionGroup) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _OptionGroup) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _OptionGroup) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _OptionGroup) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _OptionGroup) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _OptionGroup) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _OptionGroup) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _OptionGroup) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _OptionGroup) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _OptionGroup) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _OptionGroup) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _OptionGroup) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _OptionGroup) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _OptionGroup) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _OptionGroup) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _OptionGroup) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _OptionGroup) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _OptionGroup) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _OptionGroup) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _OptionGroup) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _OptionGroup) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _OptionGroup) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _OptionGroup) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _OptionGroup) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _OptionGroup) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _OptionGroup) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _OptionGroup) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _OptionGroup) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _OptionGroup) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _OptionGroup) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _OptionGroup) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _OptionGroup) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _OptionGroup) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _OptionGroup) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _OptionGroup) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _OptionGroup) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _OptionGroup) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _OptionGroup) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _OptionGroup) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _OptionGroup) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _OptionGroup) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _OptionGroup) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _OptionGroup) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _OptionGroup) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _OptionGroup) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _OptionGroup) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _OptionGroup) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _OptionGroup) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _OptionGroup) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _OptionGroup) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _OptionGroup) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _OptionGroup) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _OptionGroup) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _OptionGroup) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _OptionGroup) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _OptionGroup) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _OptionGroup) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _OptionGroup) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _OptionGroup) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _OptionGroup) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _OptionGroup) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _OptionGroup) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _OptionGroup) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _OptionGroup) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _OptionGroup) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _OptionGroup) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _OptionGroup) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _OptionGroup) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _OptionGroup) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _OptionGroup) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _OptionGroup) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _OptionGroup) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _OptionGroup) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _OptionGroup) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _OptionGroup) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _OptionGroup) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _OptionGroup) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _OptionGroup) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _OptionGroup) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _OptionGroup) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _OptionGroup) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _OptionGroup) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _BoundObjectFrame, hidden, dual ---------- *) PROCEDURE (this: _BoundObjectFrame) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _BoundObjectFrame) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _BoundObjectFrame) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _BoundObjectFrame) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _BoundObjectFrame) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _BoundObjectFrame) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _BoundObjectFrame) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _BoundObjectFrame) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _BoundObjectFrame) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _BoundObjectFrame) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _BoundObjectFrame) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _BoundObjectFrame) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _BoundObjectFrame) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _BoundObjectFrame) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _BoundObjectFrame) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _BoundObjectFrame) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _BoundObjectFrame) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _BoundObjectFrame) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _BoundObjectFrame) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _BoundObjectFrame) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _BoundObjectFrame) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _BoundObjectFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _BoundObjectFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _BoundObjectFrame) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _BoundObjectFrame) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2104) END Object; PROCEDURE (this: _BoundObjectFrame) ObjectVerbs* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2105, arg, ret); RETURN CtlC.VarStr(ret) END ObjectVerbs; PROCEDURE (this: _BoundObjectFrame) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _BoundObjectFrame) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _BoundObjectFrame) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _BoundObjectFrame) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _BoundObjectFrame) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _BoundObjectFrame) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _BoundObjectFrame) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _BoundObjectFrame) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _BoundObjectFrame) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _BoundObjectFrame) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _BoundObjectFrame) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _BoundObjectFrame) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _BoundObjectFrame) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _BoundObjectFrame) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _BoundObjectFrame) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _BoundObjectFrame) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _BoundObjectFrame) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _BoundObjectFrame) SizeMode* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 89) END SizeMode; PROCEDURE (this: _BoundObjectFrame) PUTSizeMode* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 89, p1) END PUTSizeMode; PROCEDURE (this: _BoundObjectFrame) Class* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 274) END Class; PROCEDURE (this: _BoundObjectFrame) PUTClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 274, p1) END PUTClass; PROCEDURE (this: _BoundObjectFrame) SourceDoc* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 133) END SourceDoc; PROCEDURE (this: _BoundObjectFrame) PUTSourceDoc* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 133, p1) END PUTSourceDoc; PROCEDURE (this: _BoundObjectFrame) SourceItem* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 48) END SourceItem; PROCEDURE (this: _BoundObjectFrame) PUTSourceItem* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 48, p1) END PUTSourceItem; PROCEDURE (this: _BoundObjectFrame) AutoActivate* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 101) END AutoActivate; PROCEDURE (this: _BoundObjectFrame) PUTAutoActivate* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 101, p1) END PUTAutoActivate; PROCEDURE (this: _BoundObjectFrame) DisplayType* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 272) END DisplayType; PROCEDURE (this: _BoundObjectFrame) PUTDisplayType* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 272, p1) END PUTDisplayType; PROCEDURE (this: _BoundObjectFrame) UpdateOptions* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 103) END UpdateOptions; PROCEDURE (this: _BoundObjectFrame) PUTUpdateOptions* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 103, p1) END PUTUpdateOptions; PROCEDURE (this: _BoundObjectFrame) Verb* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END Verb; PROCEDURE (this: _BoundObjectFrame) PUTVerb* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTVerb; PROCEDURE (this: _BoundObjectFrame) OLETypeAllowed* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 275) END OLETypeAllowed; PROCEDURE (this: _BoundObjectFrame) PUTOLETypeAllowed* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 275, p1) END PUTOLETypeAllowed; PROCEDURE (this: _BoundObjectFrame) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _BoundObjectFrame) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _BoundObjectFrame) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _BoundObjectFrame) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _BoundObjectFrame) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _BoundObjectFrame) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _BoundObjectFrame) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _BoundObjectFrame) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _BoundObjectFrame) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _BoundObjectFrame) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _BoundObjectFrame) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _BoundObjectFrame) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _BoundObjectFrame) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _BoundObjectFrame) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _BoundObjectFrame) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _BoundObjectFrame) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _BoundObjectFrame) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _BoundObjectFrame) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _BoundObjectFrame) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _BoundObjectFrame) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _BoundObjectFrame) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _BoundObjectFrame) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _BoundObjectFrame) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _BoundObjectFrame) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _BoundObjectFrame) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _BoundObjectFrame) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _BoundObjectFrame) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _BoundObjectFrame) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _BoundObjectFrame) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _BoundObjectFrame) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _BoundObjectFrame) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _BoundObjectFrame) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _BoundObjectFrame) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _BoundObjectFrame) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _BoundObjectFrame) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _BoundObjectFrame) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _BoundObjectFrame) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _BoundObjectFrame) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _BoundObjectFrame) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _BoundObjectFrame) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _BoundObjectFrame) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _BoundObjectFrame) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _BoundObjectFrame) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _BoundObjectFrame) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _BoundObjectFrame) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _BoundObjectFrame) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _BoundObjectFrame) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _BoundObjectFrame) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _BoundObjectFrame) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _BoundObjectFrame) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _BoundObjectFrame) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _BoundObjectFrame) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _BoundObjectFrame) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _BoundObjectFrame) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _BoundObjectFrame) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _BoundObjectFrame) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _BoundObjectFrame) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _BoundObjectFrame) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _BoundObjectFrame) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _BoundObjectFrame) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _BoundObjectFrame) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _BoundObjectFrame) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _BoundObjectFrame) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _BoundObjectFrame) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _BoundObjectFrame) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _BoundObjectFrame) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _BoundObjectFrame) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _BoundObjectFrame) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _BoundObjectFrame) LpOleObject* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 172) END LpOleObject; PROCEDURE (this: _BoundObjectFrame) PUTLpOleObject* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 172, p1) END PUTLpOleObject; PROCEDURE (this: _BoundObjectFrame) ObjectVerbsCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 173) END ObjectVerbsCount; PROCEDURE (this: _BoundObjectFrame) PUTObjectVerbsCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 173, p1) END PUTObjectVerbsCount; PROCEDURE (this: _BoundObjectFrame) Action* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 273) END Action; PROCEDURE (this: _BoundObjectFrame) PUTAction* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 273, p1) END PUTAction; PROCEDURE (this: _BoundObjectFrame) Scaling* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 88) END Scaling; PROCEDURE (this: _BoundObjectFrame) PUTScaling* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 88, p1) END PUTScaling; PROCEDURE (this: _BoundObjectFrame) OLEType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 276) END OLEType; PROCEDURE (this: _BoundObjectFrame) PUTOLEType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 276, p1) END PUTOLEType; PROCEDURE (this: _BoundObjectFrame) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _BoundObjectFrame) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _BoundObjectFrame) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _BoundObjectFrame) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _BoundObjectFrame) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _BoundObjectFrame) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _BoundObjectFrame) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _BoundObjectFrame) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _BoundObjectFrame) OnUpdated* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 118) END OnUpdated; PROCEDURE (this: _BoundObjectFrame) PUTOnUpdated* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 118, p1) END PUTOnUpdated; PROCEDURE (this: _BoundObjectFrame) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _BoundObjectFrame) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _BoundObjectFrame) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _BoundObjectFrame) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _BoundObjectFrame) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _BoundObjectFrame) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _BoundObjectFrame) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _BoundObjectFrame) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _BoundObjectFrame) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _BoundObjectFrame) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _BoundObjectFrame) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _BoundObjectFrame) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _BoundObjectFrame) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _BoundObjectFrame) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _BoundObjectFrame) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _BoundObjectFrame) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _BoundObjectFrame) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _BoundObjectFrame) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _BoundObjectFrame) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _BoundObjectFrame) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _BoundObjectFrame) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _BoundObjectFrame) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _BoundObjectFrame) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _BoundObjectFrame) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _BoundObjectFrame) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _BoundObjectFrame) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Textbox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Textbox) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Textbox) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Textbox) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Textbox) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Textbox) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Textbox) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Textbox) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Textbox) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Textbox) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Textbox) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Textbox) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Textbox) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Textbox) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Textbox) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Textbox) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Textbox) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Textbox) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Textbox) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Textbox) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Textbox) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Textbox) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Textbox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Textbox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Textbox) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _Textbox) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _Textbox) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Textbox) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Textbox) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Textbox) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Textbox) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Textbox) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Textbox) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Textbox) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _Textbox) FormatConditions* (): FormatConditions, NEW; BEGIN RETURN ThisFormatConditions(CtlC.GetAny(this, 2203)) END FormatConditions; PROCEDURE (this: _Textbox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _Textbox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _Textbox) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Textbox) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Textbox) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Textbox) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Textbox) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Textbox) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Textbox) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _Textbox) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _Textbox) Format* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 38) END Format; PROCEDURE (this: _Textbox) PUTFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 38, p1) END PUTFormat; PROCEDURE (this: _Textbox) DecimalPlaces* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 71) END DecimalPlaces; PROCEDURE (this: _Textbox) PUTDecimalPlaces* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 71, p1) END PUTDecimalPlaces; PROCEDURE (this: _Textbox) InputMask* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 72) END InputMask; PROCEDURE (this: _Textbox) PUTInputMask* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 72, p1) END PUTInputMask; PROCEDURE (this: _Textbox) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _Textbox) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _Textbox) IMEHold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 357) END IMEHold; PROCEDURE (this: _Textbox) PUTIMEHold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 357, p1) END PUTIMEHold; PROCEDURE (this: _Textbox) FuriganaControl* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 359) END FuriganaControl; PROCEDURE (this: _Textbox) PUTFuriganaControl* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 359, p1) END PUTFuriganaControl; PROCEDURE (this: _Textbox) PostalAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 360) END PostalAddress; PROCEDURE (this: _Textbox) PUTPostalAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 360, p1) END PUTPostalAddress; PROCEDURE (this: _Textbox) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _Textbox) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _Textbox) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _Textbox) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _Textbox) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _Textbox) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _Textbox) EnterKeyBehavior* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 74) END EnterKeyBehavior; PROCEDURE (this: _Textbox) PUTEnterKeyBehavior* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 74, p1) END PUTEnterKeyBehavior; PROCEDURE (this: _Textbox) AllowAutoCorrect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 340) END AllowAutoCorrect; PROCEDURE (this: _Textbox) PUTAllowAutoCorrect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 340, p1) END PUTAllowAutoCorrect; PROCEDURE (this: _Textbox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Textbox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Textbox) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Textbox) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Textbox) Vertical* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 355) END Vertical; PROCEDURE (this: _Textbox) PUTVertical* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 355, p1) END PUTVertical; PROCEDURE (this: _Textbox) FELineBreak* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 358) END FELineBreak; PROCEDURE (this: _Textbox) PUTFELineBreak* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 358, p1) END PUTFELineBreak; PROCEDURE (this: _Textbox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _Textbox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _Textbox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _Textbox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _Textbox) FilterLookup* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 305) END FilterLookup; PROCEDURE (this: _Textbox) PUTFilterLookup* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 305, p1) END PUTFilterLookup; PROCEDURE (this: _Textbox) AutoTab* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 73) END AutoTab; PROCEDURE (this: _Textbox) PUTAutoTab* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 73, p1) END PUTAutoTab; PROCEDURE (this: _Textbox) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _Textbox) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _Textbox) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _Textbox) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _Textbox) ScrollBars* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 152) END ScrollBars; PROCEDURE (this: _Textbox) PUTScrollBars* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 152, p1) END PUTScrollBars; PROCEDURE (this: _Textbox) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _Textbox) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _Textbox) CanGrow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END CanGrow; PROCEDURE (this: _Textbox) PUTCanGrow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTCanGrow; PROCEDURE (this: _Textbox) CanShrink* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END CanShrink; PROCEDURE (this: _Textbox) PUTCanShrink* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTCanShrink; PROCEDURE (this: _Textbox) RunningSum* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 130) END RunningSum; PROCEDURE (this: _Textbox) PUTRunningSum* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 130, p1) END PUTRunningSum; PROCEDURE (this: _Textbox) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Textbox) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Textbox) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Textbox) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Textbox) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Textbox) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Textbox) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Textbox) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Textbox) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _Textbox) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _Textbox) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Textbox) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Textbox) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Textbox) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Textbox) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Textbox) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Textbox) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Textbox) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Textbox) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Textbox) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Textbox) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Textbox) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Textbox) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Textbox) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Textbox) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _Textbox) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _Textbox) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _Textbox) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _Textbox) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _Textbox) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _Textbox) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _Textbox) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _Textbox) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _Textbox) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _Textbox) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _Textbox) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _Textbox) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _Textbox) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _Textbox) TextAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 136) END TextAlign; PROCEDURE (this: _Textbox) PUTTextAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 136, p1) END PUTTextAlign; PROCEDURE (this: _Textbox) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _Textbox) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _Textbox) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Textbox) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Textbox) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Textbox) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Textbox) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Textbox) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Textbox) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _Textbox) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _Textbox) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _Textbox) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _Textbox) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _Textbox) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _Textbox) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _Textbox) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _Textbox) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _Textbox) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _Textbox) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _Textbox) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _Textbox) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _Textbox) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _Textbox) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _Textbox) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _Textbox) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Textbox) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Textbox) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Textbox) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Textbox) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Textbox) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Textbox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 267) END Text; PROCEDURE (this: _Textbox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 267, p1) END PUTText; PROCEDURE (this: _Textbox) SelText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 271) END SelText; PROCEDURE (this: _Textbox) PUTSelText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 271, p1) END PUTSelText; PROCEDURE (this: _Textbox) SelStart* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 270) END SelStart; PROCEDURE (this: _Textbox) PUTSelStart* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 270, p1) END PUTSelStart; PROCEDURE (this: _Textbox) SelLength* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 269) END SelLength; PROCEDURE (this: _Textbox) PUTSelLength* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 269, p1) END PUTSelLength; PROCEDURE (this: _Textbox) TextAlignGeneral* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 137) END TextAlignGeneral; PROCEDURE (this: _Textbox) PUTTextAlignGeneral* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 137, p1) END PUTTextAlignGeneral; PROCEDURE (this: _Textbox) Coltyp* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 139) END Coltyp; PROCEDURE (this: _Textbox) PUTColtyp* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 139, p1) END PUTColtyp; PROCEDURE (this: _Textbox) FormatPictureText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END FormatPictureText; PROCEDURE (this: _Textbox) PUTFormatPictureText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTFormatPictureText; PROCEDURE (this: _Textbox) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Textbox) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Textbox) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Textbox) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Textbox) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _Textbox) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _Textbox) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _Textbox) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _Textbox) OnChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 114) END OnChange; PROCEDURE (this: _Textbox) PUTOnChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 114, p1) END PUTOnChange; PROCEDURE (this: _Textbox) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _Textbox) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _Textbox) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _Textbox) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _Textbox) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _Textbox) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _Textbox) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _Textbox) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _Textbox) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Textbox) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Textbox) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Textbox) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Textbox) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Textbox) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Textbox) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Textbox) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Textbox) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Textbox) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Textbox) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _Textbox) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _Textbox) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _Textbox) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _Textbox) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _Textbox) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _Textbox) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _Textbox) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _Textbox) KeyboardLanguage* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 368) END KeyboardLanguage; PROCEDURE (this: _Textbox) PUTKeyboardLanguage* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 368, p1) END PUTKeyboardLanguage; PROCEDURE (this: _Textbox) AllowedText* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 369) END AllowedText; PROCEDURE (this: _Textbox) PUTAllowedText* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 369, p1) END PUTAllowedText; PROCEDURE (this: _Textbox) ScrollBarAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 371) END ScrollBarAlign; PROCEDURE (this: _Textbox) PUTScrollBarAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 371, p1) END PUTScrollBarAlign; PROCEDURE (this: _Textbox) NumeralShapes* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 372) END NumeralShapes; PROCEDURE (this: _Textbox) PUTNumeralShapes* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 372, p1) END PUTNumeralShapes; PROCEDURE (this: _Textbox) IMEMode* (): AcImeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 356) END IMEMode; PROCEDURE (this: _Textbox) PUTIMEMode* (p1: AcImeMode), NEW; BEGIN CtlC.PutInt(this, 356, p1) END PUTIMEMode; PROCEDURE (this: _Textbox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Textbox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _Textbox) IMESentenceMode* (): AcImeSentenceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 379) END IMESentenceMode; PROCEDURE (this: _Textbox) PUTIMESentenceMode* (p1: AcImeSentenceMode), NEW; BEGIN CtlC.PutInt(this, 379, p1) END PUTIMESentenceMode; PROCEDURE (this: _Textbox) LeftMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 384) END LeftMargin; PROCEDURE (this: _Textbox) PUTLeftMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 384, p1) END PUTLeftMargin; PROCEDURE (this: _Textbox) TopMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 385) END TopMargin; PROCEDURE (this: _Textbox) PUTTopMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 385, p1) END PUTTopMargin; PROCEDURE (this: _Textbox) LineSpacing* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 386) END LineSpacing; PROCEDURE (this: _Textbox) PUTLineSpacing* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 386, p1) END PUTLineSpacing; PROCEDURE (this: _Textbox) RightMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 388) END RightMargin; PROCEDURE (this: _Textbox) PUTRightMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 388, p1) END PUTRightMargin; PROCEDURE (this: _Textbox) BottomMargin* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 389) END BottomMargin; PROCEDURE (this: _Textbox) PUTBottomMargin* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 389, p1) END PUTBottomMargin; PROCEDURE (this: _Textbox) IsHyperlink* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 396) END IsHyperlink; PROCEDURE (this: _Textbox) PUTIsHyperlink* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 396, p1) END PUTIsHyperlink; (* ---------- _ListBox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _ListBox) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _ListBox) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _ListBox) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _ListBox) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _ListBox) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _ListBox) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _ListBox) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _ListBox) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _ListBox) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _ListBox) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _ListBox) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _ListBox) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _ListBox) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _ListBox) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _ListBox) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _ListBox) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _ListBox) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _ListBox) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _ListBox) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _ListBox) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _ListBox) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _ListBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _ListBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _ListBox) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _ListBox) Column* (Index: INTEGER; (* optional *) Row: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Row, arg[0]); CtlC.CallGetMethod(this, 2101, arg, ret); RETURN CtlC.VarAny(ret) END Column; PROCEDURE (this: _ListBox) Selected* (lRow: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lRow, arg[0]); CtlC.CallGetMethod(this, 2113, arg, ret); RETURN CtlC.VarInt(ret) END Selected; PROCEDURE (this: _ListBox) PUTSelected* (lRow: INTEGER; p2: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(lRow, arg[1]); CtlC.IntVar(p2, arg[0]); CtlC.CallPutMethod(this, 2113, arg, NIL); END PUTSelected; PROCEDURE (this: _ListBox) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _ListBox) ItemData* (Index: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2103, arg, ret); RETURN CtlC.VarAny(ret) END ItemData; PROCEDURE (this: _ListBox) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _ListBox) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _ListBox) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _ListBox) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _ListBox) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _ListBox) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _ListBox) ItemsSelected* (): _ItemsSelected, NEW; BEGIN RETURN This_ItemsSelected(CtlC.GetAny(this, 2137)) END ItemsSelected; PROCEDURE (this: _ListBox) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _ListBox) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _ListBox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _ListBox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _ListBox) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _ListBox) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _ListBox) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _ListBox) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _ListBox) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _ListBox) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _ListBox) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _ListBox) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _ListBox) RowSourceType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 93) END RowSourceType; PROCEDURE (this: _ListBox) PUTRowSourceType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 93, p1) END PUTRowSourceType; PROCEDURE (this: _ListBox) RowSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 91) END RowSource; PROCEDURE (this: _ListBox) PUTRowSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 91, p1) END PUTRowSource; PROCEDURE (this: _ListBox) ColumnCount* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 70) END ColumnCount; PROCEDURE (this: _ListBox) PUTColumnCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 70, p1) END PUTColumnCount; PROCEDURE (this: _ListBox) ColumnHeads* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 131) END ColumnHeads; PROCEDURE (this: _ListBox) PUTColumnHeads* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 131, p1) END PUTColumnHeads; PROCEDURE (this: _ListBox) ColumnWidths* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 18) END ColumnWidths; PROCEDURE (this: _ListBox) PUTColumnWidths* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 18, p1) END PUTColumnWidths; PROCEDURE (this: _ListBox) BoundColumn* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END BoundColumn; PROCEDURE (this: _ListBox) PUTBoundColumn* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTBoundColumn; PROCEDURE (this: _ListBox) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _ListBox) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _ListBox) IMEHold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 357) END IMEHold; PROCEDURE (this: _ListBox) PUTIMEHold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 357, p1) END PUTIMEHold; PROCEDURE (this: _ListBox) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _ListBox) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _ListBox) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _ListBox) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _ListBox) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _ListBox) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _ListBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _ListBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _ListBox) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _ListBox) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _ListBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _ListBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _ListBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _ListBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _ListBox) MultiSelect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 293) END MultiSelect; PROCEDURE (this: _ListBox) PUTMultiSelect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 293, p1) END PUTMultiSelect; PROCEDURE (this: _ListBox) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _ListBox) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _ListBox) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _ListBox) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _ListBox) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _ListBox) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _ListBox) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _ListBox) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _ListBox) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _ListBox) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _ListBox) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _ListBox) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _ListBox) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _ListBox) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _ListBox) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _ListBox) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _ListBox) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _ListBox) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _ListBox) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _ListBox) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _ListBox) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _ListBox) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _ListBox) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _ListBox) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _ListBox) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _ListBox) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _ListBox) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _ListBox) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _ListBox) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _ListBox) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _ListBox) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _ListBox) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _ListBox) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _ListBox) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _ListBox) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _ListBox) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _ListBox) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _ListBox) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _ListBox) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _ListBox) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _ListBox) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _ListBox) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _ListBox) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _ListBox) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _ListBox) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _ListBox) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _ListBox) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _ListBox) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _ListBox) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _ListBox) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _ListBox) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _ListBox) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _ListBox) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _ListBox) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _ListBox) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _ListBox) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _ListBox) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _ListBox) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _ListBox) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _ListBox) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _ListBox) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _ListBox) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _ListBox) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _ListBox) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _ListBox) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _ListBox) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _ListBox) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _ListBox) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _ListBox) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _ListBox) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _ListBox) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _ListBox) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _ListBox) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 238) END ListCount; PROCEDURE (this: _ListBox) PUTListCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 238, p1) END PUTListCount; PROCEDURE (this: _ListBox) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 239) END ListIndex; PROCEDURE (this: _ListBox) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 239, p1) END PUTListIndex; PROCEDURE (this: _ListBox) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _ListBox) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _ListBox) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _ListBox) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _ListBox) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _ListBox) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _ListBox) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _ListBox) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _ListBox) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _ListBox) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _ListBox) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _ListBox) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _ListBox) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _ListBox) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _ListBox) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _ListBox) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _ListBox) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _ListBox) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _ListBox) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _ListBox) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _ListBox) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _ListBox) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _ListBox) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _ListBox) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _ListBox) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _ListBox) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _ListBox) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _ListBox) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _ListBox) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _ListBox) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _ListBox) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _ListBox) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _ListBox) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _ListBox) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _ListBox) ScrollBarAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 371) END ScrollBarAlign; PROCEDURE (this: _ListBox) PUTScrollBarAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 371, p1) END PUTScrollBarAlign; PROCEDURE (this: _ListBox) TextAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 136) END TextAlign; PROCEDURE (this: _ListBox) PUTTextAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 136, p1) END PUTTextAlign; PROCEDURE (this: _ListBox) NumeralShapes* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 372) END NumeralShapes; PROCEDURE (this: _ListBox) PUTNumeralShapes* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 372, p1) END PUTNumeralShapes; PROCEDURE (this: _ListBox) IMEMode* (): AcImeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 356) END IMEMode; PROCEDURE (this: _ListBox) PUTIMEMode* (p1: AcImeMode), NEW; BEGIN CtlC.PutInt(this, 356, p1) END PUTIMEMode; PROCEDURE (this: _ListBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _ListBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _ListBox) IMESentenceMode* (): AcImeSentenceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 379) END IMESentenceMode; PROCEDURE (this: _ListBox) PUTIMESentenceMode* (p1: AcImeSentenceMode), NEW; BEGIN CtlC.PutInt(this, 379, p1) END PUTIMESentenceMode; (* ---------- _Combobox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Combobox) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Combobox) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Combobox) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Combobox) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Combobox) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Combobox) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Combobox) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Combobox) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Combobox) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Combobox) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Combobox) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Combobox) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Combobox) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Combobox) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Combobox) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Combobox) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Combobox) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Combobox) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Combobox) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Combobox) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Combobox) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Combobox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Combobox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Combobox) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _Combobox) Dropdown* (), NEW; BEGIN CtlC.CallMethod(this, 2143, NIL); END Dropdown; PROCEDURE (this: _Combobox) Column* (Index: INTEGER; (* optional *) Row: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Row, arg[0]); CtlC.CallGetMethod(this, 2101, arg, ret); RETURN CtlC.VarAny(ret) END Column; PROCEDURE (this: _Combobox) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _Combobox) ItemData* (Index: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2103, arg, ret); RETURN CtlC.VarAny(ret) END ItemData; PROCEDURE (this: _Combobox) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Combobox) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Combobox) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Combobox) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Combobox) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Combobox) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Combobox) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Combobox) Hyperlink* (): _Hyperlink, NEW; BEGIN RETURN This_Hyperlink(CtlC.GetAny(this, 2181)) END Hyperlink; PROCEDURE (this: _Combobox) FormatConditions* (): FormatConditions, NEW; BEGIN RETURN ThisFormatConditions(CtlC.GetAny(this, 2203)) END FormatConditions; PROCEDURE (this: _Combobox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _Combobox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _Combobox) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Combobox) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Combobox) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Combobox) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Combobox) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Combobox) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Combobox) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _Combobox) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _Combobox) Format* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 38) END Format; PROCEDURE (this: _Combobox) PUTFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 38, p1) END PUTFormat; PROCEDURE (this: _Combobox) DecimalPlaces* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 71) END DecimalPlaces; PROCEDURE (this: _Combobox) PUTDecimalPlaces* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 71, p1) END PUTDecimalPlaces; PROCEDURE (this: _Combobox) InputMask* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 72) END InputMask; PROCEDURE (this: _Combobox) PUTInputMask* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 72, p1) END PUTInputMask; PROCEDURE (this: _Combobox) RowSourceType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 93) END RowSourceType; PROCEDURE (this: _Combobox) PUTRowSourceType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 93, p1) END PUTRowSourceType; PROCEDURE (this: _Combobox) RowSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 91) END RowSource; PROCEDURE (this: _Combobox) PUTRowSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 91, p1) END PUTRowSource; PROCEDURE (this: _Combobox) ColumnCount* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 70) END ColumnCount; PROCEDURE (this: _Combobox) PUTColumnCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 70, p1) END PUTColumnCount; PROCEDURE (this: _Combobox) ColumnHeads* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 131) END ColumnHeads; PROCEDURE (this: _Combobox) PUTColumnHeads* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 131, p1) END PUTColumnHeads; PROCEDURE (this: _Combobox) ColumnWidths* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 18) END ColumnWidths; PROCEDURE (this: _Combobox) PUTColumnWidths* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 18, p1) END PUTColumnWidths; PROCEDURE (this: _Combobox) BoundColumn* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END BoundColumn; PROCEDURE (this: _Combobox) PUTBoundColumn* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTBoundColumn; PROCEDURE (this: _Combobox) ListRows* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 153) END ListRows; PROCEDURE (this: _Combobox) PUTListRows* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 153, p1) END PUTListRows; PROCEDURE (this: _Combobox) ListWidth* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 154) END ListWidth; PROCEDURE (this: _Combobox) PUTListWidth* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 154, p1) END PUTListWidth; PROCEDURE (this: _Combobox) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _Combobox) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _Combobox) LimitToList* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 67) END LimitToList; PROCEDURE (this: _Combobox) PUTLimitToList* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 67, p1) END PUTLimitToList; PROCEDURE (this: _Combobox) AutoExpand* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 68) END AutoExpand; PROCEDURE (this: _Combobox) PUTAutoExpand* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 68, p1) END PUTAutoExpand; PROCEDURE (this: _Combobox) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _Combobox) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _Combobox) IMEHold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 357) END IMEHold; PROCEDURE (this: _Combobox) PUTIMEHold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 357, p1) END PUTIMEHold; PROCEDURE (this: _Combobox) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _Combobox) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _Combobox) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _Combobox) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _Combobox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Combobox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Combobox) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Combobox) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Combobox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _Combobox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _Combobox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _Combobox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _Combobox) AllowAutoCorrect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 340) END AllowAutoCorrect; PROCEDURE (this: _Combobox) PUTAllowAutoCorrect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 340, p1) END PUTAllowAutoCorrect; PROCEDURE (this: _Combobox) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _Combobox) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _Combobox) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _Combobox) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _Combobox) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _Combobox) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _Combobox) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Combobox) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Combobox) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Combobox) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Combobox) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Combobox) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Combobox) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Combobox) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Combobox) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _Combobox) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _Combobox) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Combobox) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Combobox) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Combobox) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Combobox) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Combobox) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Combobox) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _Combobox) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _Combobox) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _Combobox) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _Combobox) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _Combobox) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _Combobox) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _Combobox) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _Combobox) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _Combobox) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _Combobox) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _Combobox) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _Combobox) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _Combobox) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _Combobox) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _Combobox) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _Combobox) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _Combobox) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _Combobox) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _Combobox) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _Combobox) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _Combobox) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _Combobox) TextAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 136) END TextAlign; PROCEDURE (this: _Combobox) PUTTextAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 136, p1) END PUTTextAlign; PROCEDURE (this: _Combobox) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _Combobox) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _Combobox) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Combobox) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Combobox) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Combobox) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Combobox) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Combobox) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Combobox) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _Combobox) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _Combobox) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _Combobox) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _Combobox) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _Combobox) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _Combobox) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _Combobox) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _Combobox) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _Combobox) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _Combobox) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _Combobox) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _Combobox) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _Combobox) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _Combobox) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _Combobox) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _Combobox) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Combobox) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Combobox) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Combobox) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Combobox) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Combobox) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Combobox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 267) END Text; PROCEDURE (this: _Combobox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 267, p1) END PUTText; PROCEDURE (this: _Combobox) SelText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 271) END SelText; PROCEDURE (this: _Combobox) PUTSelText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 271, p1) END PUTSelText; PROCEDURE (this: _Combobox) SelStart* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 270) END SelStart; PROCEDURE (this: _Combobox) PUTSelStart* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 270, p1) END PUTSelStart; PROCEDURE (this: _Combobox) SelLength* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 269) END SelLength; PROCEDURE (this: _Combobox) PUTSelLength* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 269, p1) END PUTSelLength; PROCEDURE (this: _Combobox) TextAlignGeneral* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 137) END TextAlignGeneral; PROCEDURE (this: _Combobox) PUTTextAlignGeneral* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 137, p1) END PUTTextAlignGeneral; PROCEDURE (this: _Combobox) FormatPictureText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END FormatPictureText; PROCEDURE (this: _Combobox) PUTFormatPictureText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTFormatPictureText; PROCEDURE (this: _Combobox) Coltyp* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 139) END Coltyp; PROCEDURE (this: _Combobox) PUTColtyp* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 139, p1) END PUTColtyp; PROCEDURE (this: _Combobox) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 238) END ListCount; PROCEDURE (this: _Combobox) PUTListCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 238, p1) END PUTListCount; PROCEDURE (this: _Combobox) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 239) END ListIndex; PROCEDURE (this: _Combobox) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 239, p1) END PUTListIndex; PROCEDURE (this: _Combobox) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Combobox) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Combobox) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Combobox) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Combobox) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _Combobox) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _Combobox) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _Combobox) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _Combobox) OnChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 114) END OnChange; PROCEDURE (this: _Combobox) PUTOnChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 114, p1) END PUTOnChange; PROCEDURE (this: _Combobox) OnNotInList* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 120) END OnNotInList; PROCEDURE (this: _Combobox) PUTOnNotInList* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 120, p1) END PUTOnNotInList; PROCEDURE (this: _Combobox) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _Combobox) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _Combobox) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _Combobox) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _Combobox) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _Combobox) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _Combobox) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _Combobox) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _Combobox) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Combobox) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Combobox) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Combobox) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Combobox) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Combobox) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Combobox) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Combobox) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Combobox) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Combobox) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Combobox) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _Combobox) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _Combobox) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _Combobox) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _Combobox) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _Combobox) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _Combobox) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _Combobox) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _Combobox) KeyboardLanguage* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 368) END KeyboardLanguage; PROCEDURE (this: _Combobox) PUTKeyboardLanguage* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 368, p1) END PUTKeyboardLanguage; PROCEDURE (this: _Combobox) AllowedText* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 369) END AllowedText; PROCEDURE (this: _Combobox) PUTAllowedText* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 369, p1) END PUTAllowedText; PROCEDURE (this: _Combobox) ScrollBarAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 371) END ScrollBarAlign; PROCEDURE (this: _Combobox) PUTScrollBarAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 371, p1) END PUTScrollBarAlign; PROCEDURE (this: _Combobox) NumeralShapes* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 372) END NumeralShapes; PROCEDURE (this: _Combobox) PUTNumeralShapes* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 372, p1) END PUTNumeralShapes; PROCEDURE (this: _Combobox) IMEMode* (): AcImeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 356) END IMEMode; PROCEDURE (this: _Combobox) PUTIMEMode* (p1: AcImeMode), NEW; BEGIN CtlC.PutInt(this, 356, p1) END PUTIMEMode; PROCEDURE (this: _Combobox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Combobox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _Combobox) IMESentenceMode* (): AcImeSentenceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 379) END IMESentenceMode; PROCEDURE (this: _Combobox) PUTIMESentenceMode* (p1: AcImeSentenceMode), NEW; BEGIN CtlC.PutInt(this, 379, p1) END PUTIMESentenceMode; PROCEDURE (this: _Combobox) IsHyperlink* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 396) END IsHyperlink; PROCEDURE (this: _Combobox) PUTIsHyperlink* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 396, p1) END PUTIsHyperlink; (* ---------- _ObjectFrame, hidden, dual ---------- *) PROCEDURE (this: _ObjectFrame) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _ObjectFrame) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _ObjectFrame) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _ObjectFrame) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _ObjectFrame) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _ObjectFrame) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _ObjectFrame) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _ObjectFrame) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _ObjectFrame) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _ObjectFrame) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _ObjectFrame) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _ObjectFrame) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _ObjectFrame) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _ObjectFrame) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _ObjectFrame) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _ObjectFrame) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _ObjectFrame) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _ObjectFrame) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _ObjectFrame) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _ObjectFrame) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _ObjectFrame) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _ObjectFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _ObjectFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _ObjectFrame) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _ObjectFrame) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2104) END Object; PROCEDURE (this: _ObjectFrame) ObjectVerbs* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2105, arg, ret); RETURN CtlC.VarStr(ret) END ObjectVerbs; PROCEDURE (this: _ObjectFrame) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _ObjectFrame) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _ObjectFrame) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _ObjectFrame) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _ObjectFrame) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _ObjectFrame) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _ObjectFrame) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _ObjectFrame) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _ObjectFrame) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _ObjectFrame) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _ObjectFrame) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _ObjectFrame) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _ObjectFrame) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _ObjectFrame) SizeMode* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 89) END SizeMode; PROCEDURE (this: _ObjectFrame) PUTSizeMode* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 89, p1) END PUTSizeMode; PROCEDURE (this: _ObjectFrame) OLEClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 76) END OLEClass; PROCEDURE (this: _ObjectFrame) PUTOLEClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 76, p1) END PUTOLEClass; PROCEDURE (this: _ObjectFrame) Item* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 47) END Item; PROCEDURE (this: _ObjectFrame) PUTItem* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 47, p1) END PUTItem; PROCEDURE (this: _ObjectFrame) RowSourceType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 93) END RowSourceType; PROCEDURE (this: _ObjectFrame) PUTRowSourceType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 93, p1) END PUTRowSourceType; PROCEDURE (this: _ObjectFrame) RowSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 91) END RowSource; PROCEDURE (this: _ObjectFrame) PUTRowSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 91, p1) END PUTRowSource; PROCEDURE (this: _ObjectFrame) LinkChildFields* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 49) END LinkChildFields; PROCEDURE (this: _ObjectFrame) PUTLinkChildFields* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 49, p1) END PUTLinkChildFields; PROCEDURE (this: _ObjectFrame) LinkMasterFields* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 50) END LinkMasterFields; PROCEDURE (this: _ObjectFrame) PUTLinkMasterFields* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 50, p1) END PUTLinkMasterFields; PROCEDURE (this: _ObjectFrame) AutoActivate* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 101) END AutoActivate; PROCEDURE (this: _ObjectFrame) PUTAutoActivate* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 101, p1) END PUTAutoActivate; PROCEDURE (this: _ObjectFrame) DisplayType* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 272) END DisplayType; PROCEDURE (this: _ObjectFrame) PUTDisplayType* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 272, p1) END PUTDisplayType; PROCEDURE (this: _ObjectFrame) UpdateOptions* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 103) END UpdateOptions; PROCEDURE (this: _ObjectFrame) PUTUpdateOptions* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 103, p1) END PUTUpdateOptions; PROCEDURE (this: _ObjectFrame) Verb* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END Verb; PROCEDURE (this: _ObjectFrame) PUTVerb* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTVerb; PROCEDURE (this: _ObjectFrame) OLEType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 276) END OLEType; PROCEDURE (this: _ObjectFrame) PUTOLEType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 276, p1) END PUTOLEType; PROCEDURE (this: _ObjectFrame) OLETypeAllowed* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 275) END OLETypeAllowed; PROCEDURE (this: _ObjectFrame) PUTOLETypeAllowed* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 275, p1) END PUTOLETypeAllowed; PROCEDURE (this: _ObjectFrame) SourceObject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 132) END SourceObject; PROCEDURE (this: _ObjectFrame) PUTSourceObject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 132, p1) END PUTSourceObject; PROCEDURE (this: _ObjectFrame) Class* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 274) END Class; PROCEDURE (this: _ObjectFrame) PUTClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 274, p1) END PUTClass; PROCEDURE (this: _ObjectFrame) SourceDoc* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 133) END SourceDoc; PROCEDURE (this: _ObjectFrame) PUTSourceDoc* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 133, p1) END PUTSourceDoc; PROCEDURE (this: _ObjectFrame) SourceItem* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 48) END SourceItem; PROCEDURE (this: _ObjectFrame) PUTSourceItem* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 48, p1) END PUTSourceItem; PROCEDURE (this: _ObjectFrame) ColumnCount* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 70) END ColumnCount; PROCEDURE (this: _ObjectFrame) PUTColumnCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 70, p1) END PUTColumnCount; PROCEDURE (this: _ObjectFrame) ColumnHeads* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 131) END ColumnHeads; PROCEDURE (this: _ObjectFrame) PUTColumnHeads* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 131, p1) END PUTColumnHeads; PROCEDURE (this: _ObjectFrame) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _ObjectFrame) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _ObjectFrame) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _ObjectFrame) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _ObjectFrame) OleData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 171) END OleData; PROCEDURE (this: _ObjectFrame) PUTOleData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 171, p1) END PUTOleData; PROCEDURE (this: _ObjectFrame) UpdateMethod* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 142) END UpdateMethod; PROCEDURE (this: _ObjectFrame) PUTUpdateMethod* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 142, p1) END PUTUpdateMethod; PROCEDURE (this: _ObjectFrame) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _ObjectFrame) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _ObjectFrame) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _ObjectFrame) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _ObjectFrame) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _ObjectFrame) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _ObjectFrame) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _ObjectFrame) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _ObjectFrame) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _ObjectFrame) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _ObjectFrame) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _ObjectFrame) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _ObjectFrame) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _ObjectFrame) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _ObjectFrame) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _ObjectFrame) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _ObjectFrame) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _ObjectFrame) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _ObjectFrame) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _ObjectFrame) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _ObjectFrame) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _ObjectFrame) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _ObjectFrame) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _ObjectFrame) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _ObjectFrame) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _ObjectFrame) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _ObjectFrame) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _ObjectFrame) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _ObjectFrame) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _ObjectFrame) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _ObjectFrame) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _ObjectFrame) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _ObjectFrame) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _ObjectFrame) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _ObjectFrame) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _ObjectFrame) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _ObjectFrame) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _ObjectFrame) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _ObjectFrame) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _ObjectFrame) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _ObjectFrame) Data* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 242) END Data; PROCEDURE (this: _ObjectFrame) PUTData* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 242, p1) END PUTData; PROCEDURE (this: _ObjectFrame) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _ObjectFrame) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _ObjectFrame) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _ObjectFrame) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _ObjectFrame) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _ObjectFrame) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _ObjectFrame) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _ObjectFrame) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _ObjectFrame) LpOleObject* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 172) END LpOleObject; PROCEDURE (this: _ObjectFrame) PUTLpOleObject* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 172, p1) END PUTLpOleObject; PROCEDURE (this: _ObjectFrame) ObjectVerbsCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 173) END ObjectVerbsCount; PROCEDURE (this: _ObjectFrame) PUTObjectVerbsCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 173, p1) END PUTObjectVerbsCount; PROCEDURE (this: _ObjectFrame) Action* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 273) END Action; PROCEDURE (this: _ObjectFrame) PUTAction* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 273, p1) END PUTAction; PROCEDURE (this: _ObjectFrame) Scaling* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 88) END Scaling; PROCEDURE (this: _ObjectFrame) PUTScaling* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 88, p1) END PUTScaling; PROCEDURE (this: _ObjectFrame) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _ObjectFrame) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _ObjectFrame) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _ObjectFrame) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _ObjectFrame) OnUpdated* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 118) END OnUpdated; PROCEDURE (this: _ObjectFrame) PUTOnUpdated* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 118, p1) END PUTOnUpdated; PROCEDURE (this: _ObjectFrame) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _ObjectFrame) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _ObjectFrame) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _ObjectFrame) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _ObjectFrame) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _ObjectFrame) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _ObjectFrame) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _ObjectFrame) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _ObjectFrame) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _ObjectFrame) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _ObjectFrame) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _ObjectFrame) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _ObjectFrame) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _ObjectFrame) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _ObjectFrame) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _ObjectFrame) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _ObjectFrame) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _ObjectFrame) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _ObjectFrame) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _ObjectFrame) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _PageBreak, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _PageBreak) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _PageBreak) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _PageBreak) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _PageBreak) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _PageBreak) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _PageBreak) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _PageBreak) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _PageBreak) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _PageBreak) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _PageBreak) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _PageBreak) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _PageBreak) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _PageBreak) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _PageBreak) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _PageBreak) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _PageBreak) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _PageBreak) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _PageBreak) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _PageBreak) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _PageBreak) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _PageBreak) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _PageBreak) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _PageBreak) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _PageBreak) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _PageBreak) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _PageBreak) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _PageBreak) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _PageBreak) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _PageBreak) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _ToggleButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _ToggleButton) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _ToggleButton) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _ToggleButton) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _ToggleButton) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _ToggleButton) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _ToggleButton) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _ToggleButton) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _ToggleButton) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _ToggleButton) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _ToggleButton) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _ToggleButton) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _ToggleButton) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _ToggleButton) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _ToggleButton) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _ToggleButton) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _ToggleButton) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _ToggleButton) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _ToggleButton) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _ToggleButton) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _ToggleButton) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _ToggleButton) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _ToggleButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _ToggleButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _ToggleButton) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2144, NIL); END Undo; PROCEDURE (this: _ToggleButton) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _ToggleButton) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _ToggleButton) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _ToggleButton) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _ToggleButton) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _ToggleButton) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _ToggleButton) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _ToggleButton) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _ToggleButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _ToggleButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _ToggleButton) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _ToggleButton) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _ToggleButton) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _ToggleButton) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _ToggleButton) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _ToggleButton) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _ToggleButton) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _ToggleButton) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _ToggleButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _ToggleButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _ToggleButton) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _ToggleButton) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _ToggleButton) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _ToggleButton) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _ToggleButton) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _ToggleButton) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _ToggleButton) OptionValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 58) END OptionValue; PROCEDURE (this: _ToggleButton) PUTOptionValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 58, p1) END PUTOptionValue; PROCEDURE (this: _ToggleButton) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _ToggleButton) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _ToggleButton) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _ToggleButton) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _ToggleButton) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _ToggleButton) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _ToggleButton) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _ToggleButton) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _ToggleButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _ToggleButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _ToggleButton) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _ToggleButton) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _ToggleButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _ToggleButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _ToggleButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _ToggleButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _ToggleButton) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END TripleState; PROCEDURE (this: _ToggleButton) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 294, p1) END PUTTripleState; PROCEDURE (this: _ToggleButton) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _ToggleButton) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _ToggleButton) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _ToggleButton) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _ToggleButton) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _ToggleButton) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _ToggleButton) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _ToggleButton) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _ToggleButton) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _ToggleButton) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _ToggleButton) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _ToggleButton) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _ToggleButton) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _ToggleButton) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _ToggleButton) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _ToggleButton) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _ToggleButton) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _ToggleButton) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _ToggleButton) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _ToggleButton) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _ToggleButton) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _ToggleButton) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _ToggleButton) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _ToggleButton) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _ToggleButton) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _ToggleButton) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _ToggleButton) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _ToggleButton) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _ToggleButton) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _ToggleButton) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _ToggleButton) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _ToggleButton) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _ToggleButton) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _ToggleButton) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _ToggleButton) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _ToggleButton) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _ToggleButton) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _ToggleButton) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _ToggleButton) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _ToggleButton) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _ToggleButton) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _ToggleButton) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _ToggleButton) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _ToggleButton) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _ToggleButton) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _ToggleButton) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _ToggleButton) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _ToggleButton) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _ToggleButton) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _ToggleButton) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _ToggleButton) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _ToggleButton) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _ToggleButton) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _ToggleButton) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _ToggleButton) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _ToggleButton) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _ToggleButton) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _ToggleButton) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _ToggleButton) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _ToggleButton) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _ToggleButton) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _ToggleButton) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _ToggleButton) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _ToggleButton) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _ToggleButton) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _ToggleButton) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _ToggleButton) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _ToggleButton) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _ToggleButton) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _ToggleButton) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _ToggleButton) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _ToggleButton) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _ToggleButton) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _ToggleButton) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _ToggleButton) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _ToggleButton) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _ToggleButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _ToggleButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _ToggleButton) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _ToggleButton) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _ToggleButton) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _ToggleButton) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _ToggleButton) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _ToggleButton) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _ToggleButton) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _ToggleButton) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _ToggleButton) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _ToggleButton) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _ToggleButton) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _ToggleButton) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _ToggleButton) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _ToggleButton) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _ToggleButton) ReadingOrder* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 367) END ReadingOrder; PROCEDURE (this: _ToggleButton) PUTReadingOrder* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 367, p1) END PUTReadingOrder; PROCEDURE (this: _ToggleButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _ToggleButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _PaletteButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _PaletteButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _PaletteButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _PaletteButton) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _PaletteButton) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _PaletteButton) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _PaletteButton) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _PaletteButton) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _PaletteButton) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _PaletteButton) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _PaletteButton) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _PaletteButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _PaletteButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _PaletteButton) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _PaletteButton) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _PaletteButton) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _PaletteButton) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _PaletteButton) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _PaletteButton) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _PaletteButton) OptionValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 58) END OptionValue; PROCEDURE (this: _PaletteButton) PUTOptionValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 58, p1) END PUTOptionValue; PROCEDURE (this: _PaletteButton) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _PaletteButton) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _PaletteButton) DefaultValue* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 23) END DefaultValue; PROCEDURE (this: _PaletteButton) PUTDefaultValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 23, p1) END PUTDefaultValue; PROCEDURE (this: _PaletteButton) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 145) END ValidationRule; PROCEDURE (this: _PaletteButton) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 145, p1) END PUTValidationRule; PROCEDURE (this: _PaletteButton) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END ValidationText; PROCEDURE (this: _PaletteButton) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTValidationText; PROCEDURE (this: _PaletteButton) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _PaletteButton) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _PaletteButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _PaletteButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _PaletteButton) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _PaletteButton) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _PaletteButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _PaletteButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _PaletteButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _PaletteButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _PaletteButton) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END TripleState; PROCEDURE (this: _PaletteButton) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 294, p1) END PUTTripleState; PROCEDURE (this: _PaletteButton) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _PaletteButton) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _PaletteButton) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _PaletteButton) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _PaletteButton) HideDuplicates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END HideDuplicates; PROCEDURE (this: _PaletteButton) PUTHideDuplicates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTHideDuplicates; PROCEDURE (this: _PaletteButton) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _PaletteButton) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _PaletteButton) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _PaletteButton) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _PaletteButton) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _PaletteButton) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _PaletteButton) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _PaletteButton) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _PaletteButton) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _PaletteButton) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _PaletteButton) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _PaletteButton) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _PaletteButton) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _PaletteButton) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _PaletteButton) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _PaletteButton) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _PaletteButton) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _PaletteButton) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _PaletteButton) ColumnWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 166) END ColumnWidth; PROCEDURE (this: _PaletteButton) PUTColumnWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 166, p1) END PUTColumnWidth; PROCEDURE (this: _PaletteButton) ColumnOrder* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END ColumnOrder; PROCEDURE (this: _PaletteButton) PUTColumnOrder* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 165, p1) END PUTColumnOrder; PROCEDURE (this: _PaletteButton) ColumnHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 167) END ColumnHidden; PROCEDURE (this: _PaletteButton) PUTColumnHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 167, p1) END PUTColumnHidden; PROCEDURE (this: _PaletteButton) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _PaletteButton) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _PaletteButton) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _PaletteButton) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _PaletteButton) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _PaletteButton) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _PaletteButton) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _PaletteButton) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _PaletteButton) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _PaletteButton) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _PaletteButton) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _PaletteButton) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _PaletteButton) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _PaletteButton) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _PaletteButton) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _PaletteButton) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _PaletteButton) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _PaletteButton) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _PaletteButton) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _PaletteButton) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _PaletteButton) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _PaletteButton) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _PaletteButton) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _PaletteButton) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _PaletteButton) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _PaletteButton) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _PaletteButton) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _PaletteButton) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _PaletteButton) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _PaletteButton) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _PaletteButton) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _PaletteButton) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _PaletteButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _PaletteButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _PaletteButton) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _PaletteButton) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _PaletteButton) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _PaletteButton) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _PaletteButton) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _PaletteButton) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _PaletteButton) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _PaletteButton) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _PaletteButton) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _PaletteButton) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _PaletteButton) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _PaletteButton) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _PaletteButton) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _PaletteButton) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _PaletteButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _PaletteButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _SubForm, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _SubForm) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _SubForm) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _SubForm) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _SubForm) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _SubForm) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _SubForm) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _SubForm) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _SubForm) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _SubForm) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _SubForm) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _SubForm) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _SubForm) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _SubForm) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _SubForm) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _SubForm) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _SubForm) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _SubForm) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _SubForm) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _SubForm) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _SubForm) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _SubForm) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _SubForm) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _SubForm) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _SubForm) Form* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2089)) END Form; PROCEDURE (this: _SubForm) Report* (): Report, NEW; BEGIN RETURN This_Report(CtlC.GetAny(this, 2097)) END Report; PROCEDURE (this: _SubForm) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _SubForm) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _SubForm) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _SubForm) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _SubForm) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _SubForm) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _SubForm) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: _SubForm) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _SubForm) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _SubForm) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _SubForm) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _SubForm) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _SubForm) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _SubForm) SourceObject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 132) END SourceObject; PROCEDURE (this: _SubForm) PUTSourceObject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 132, p1) END PUTSourceObject; PROCEDURE (this: _SubForm) LinkChildFields* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 49) END LinkChildFields; PROCEDURE (this: _SubForm) PUTLinkChildFields* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 49, p1) END PUTLinkChildFields; PROCEDURE (this: _SubForm) LinkMasterFields* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 50) END LinkMasterFields; PROCEDURE (this: _SubForm) PUTLinkMasterFields* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 50, p1) END PUTLinkMasterFields; PROCEDURE (this: _SubForm) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _SubForm) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _SubForm) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _SubForm) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _SubForm) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _SubForm) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _SubForm) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _SubForm) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _SubForm) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _SubForm) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _SubForm) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _SubForm) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _SubForm) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _SubForm) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _SubForm) CanGrow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END CanGrow; PROCEDURE (this: _SubForm) PUTCanGrow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTCanGrow; PROCEDURE (this: _SubForm) CanShrink* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END CanShrink; PROCEDURE (this: _SubForm) PUTCanShrink* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTCanShrink; PROCEDURE (this: _SubForm) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _SubForm) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _SubForm) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _SubForm) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _SubForm) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _SubForm) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _SubForm) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _SubForm) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _SubForm) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _SubForm) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _SubForm) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _SubForm) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _SubForm) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _SubForm) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _SubForm) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _SubForm) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _SubForm) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _SubForm) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _SubForm) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _SubForm) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _SubForm) AutoLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 57) END AutoLabel; PROCEDURE (this: _SubForm) PUTAutoLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 57, p1) END PUTAutoLabel; PROCEDURE (this: _SubForm) AddColon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END AddColon; PROCEDURE (this: _SubForm) PUTAddColon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTAddColon; PROCEDURE (this: _SubForm) LabelX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 52) END LabelX; PROCEDURE (this: _SubForm) PUTLabelX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 52, p1) END PUTLabelX; PROCEDURE (this: _SubForm) LabelY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 53) END LabelY; PROCEDURE (this: _SubForm) PUTLabelY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 53, p1) END PUTLabelY; PROCEDURE (this: _SubForm) LabelAlign* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 51) END LabelAlign; PROCEDURE (this: _SubForm) PUTLabelAlign* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 51, p1) END PUTLabelAlign; PROCEDURE (this: _SubForm) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _SubForm) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _SubForm) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _SubForm) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _SubForm) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _SubForm) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _SubForm) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _SubForm) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _SubForm) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _SubForm) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _SubForm) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _SubForm) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _SubForm) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _SubForm) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _SubForm) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _SubForm) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _SubReport, hidden, dual ---------- *) PROCEDURE (this: _SubReport) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _SubReport) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _SubReport) Form* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2089)) END Form; PROCEDURE (this: _SubReport) Report* (): Report, NEW; BEGIN RETURN This_Report(CtlC.GetAny(this, 2097)) END Report; (* ---------- _CustomControl, hidden, dual ---------- *) PROCEDURE (this: _CustomControl) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _CustomControl) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _CustomControl) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _CustomControl) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _CustomControl) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _CustomControl) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _CustomControl) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _CustomControl) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _CustomControl) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _CustomControl) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _CustomControl) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _CustomControl) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _CustomControl) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _CustomControl) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _CustomControl) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _CustomControl) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _CustomControl) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _CustomControl) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _CustomControl) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _CustomControl) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _CustomControl) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _CustomControl) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _CustomControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _CustomControl) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _CustomControl) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2104) END Object; PROCEDURE (this: _CustomControl) ObjectVerbs* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2105, arg, ret); RETURN CtlC.VarStr(ret) END ObjectVerbs; PROCEDURE (this: _CustomControl) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _CustomControl) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _CustomControl) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _CustomControl) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _CustomControl) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _CustomControl) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _CustomControl) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _CustomControl) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _CustomControl) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _CustomControl) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _CustomControl) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _CustomControl) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _CustomControl) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _CustomControl) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _CustomControl) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _CustomControl) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _CustomControl) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _CustomControl) OLEClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 76) END OLEClass; PROCEDURE (this: _CustomControl) PUTOLEClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 76, p1) END PUTOLEClass; PROCEDURE (this: _CustomControl) Verb* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END Verb; PROCEDURE (this: _CustomControl) PUTVerb* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTVerb; PROCEDURE (this: _CustomControl) Class* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 274) END Class; PROCEDURE (this: _CustomControl) PUTClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 274, p1) END PUTClass; PROCEDURE (this: _CustomControl) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _CustomControl) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _CustomControl) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _CustomControl) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _CustomControl) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _CustomControl) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _CustomControl) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END Locked; PROCEDURE (this: _CustomControl) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTLocked; PROCEDURE (this: _CustomControl) OleData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 171) END OleData; PROCEDURE (this: _CustomControl) PUTOleData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 171, p1) END PUTOleData; PROCEDURE (this: _CustomControl) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _CustomControl) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _CustomControl) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _CustomControl) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _CustomControl) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _CustomControl) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _CustomControl) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _CustomControl) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _CustomControl) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _CustomControl) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _CustomControl) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _CustomControl) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _CustomControl) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _CustomControl) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _CustomControl) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _CustomControl) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _CustomControl) OldBorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 329) END OldBorderStyle; PROCEDURE (this: _CustomControl) PUTOldBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 329, p1) END PUTOldBorderStyle; PROCEDURE (this: _CustomControl) BorderColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END BorderColor; PROCEDURE (this: _CustomControl) PUTBorderColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTBorderColor; PROCEDURE (this: _CustomControl) BorderWidth* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 10) END BorderWidth; PROCEDURE (this: _CustomControl) PUTBorderWidth* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 10, p1) END PUTBorderWidth; PROCEDURE (this: _CustomControl) BorderLineStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 11) END BorderLineStyle; PROCEDURE (this: _CustomControl) PUTBorderLineStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 11, p1) END PUTBorderLineStyle; PROCEDURE (this: _CustomControl) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _CustomControl) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _CustomControl) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _CustomControl) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _CustomControl) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _CustomControl) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _CustomControl) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _CustomControl) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _CustomControl) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _CustomControl) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _CustomControl) ObjectPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END ObjectPalette; PROCEDURE (this: _CustomControl) PUTObjectPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTObjectPalette; PROCEDURE (this: _CustomControl) LpOleObject* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 172) END LpOleObject; PROCEDURE (this: _CustomControl) PUTLpOleObject* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 172, p1) END PUTLpOleObject; PROCEDURE (this: _CustomControl) ObjectVerbsCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 173) END ObjectVerbsCount; PROCEDURE (this: _CustomControl) PUTObjectVerbsCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 173, p1) END PUTObjectVerbsCount; PROCEDURE (this: _CustomControl) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _CustomControl) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _CustomControl) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _CustomControl) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _CustomControl) OnUpdated* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 118) END OnUpdated; PROCEDURE (this: _CustomControl) PUTOnUpdated* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 118, p1) END PUTOnUpdated; PROCEDURE (this: _CustomControl) OnEnter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END OnEnter; PROCEDURE (this: _CustomControl) PUTOnEnter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 222, p1) END PUTOnEnter; PROCEDURE (this: _CustomControl) OnExit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 223) END OnExit; PROCEDURE (this: _CustomControl) PUTOnExit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 223, p1) END PUTOnExit; PROCEDURE (this: _CustomControl) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _CustomControl) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _CustomControl) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _CustomControl) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _CustomControl) Default* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 220) END Default; PROCEDURE (this: _CustomControl) PUTDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 220, p1) END PUTDefault; PROCEDURE (this: _CustomControl) Cancel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 221) END Cancel; PROCEDURE (this: _CustomControl) PUTCancel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 221, p1) END PUTCancel; PROCEDURE (this: _CustomControl) Custom* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 296) END Custom; PROCEDURE (this: _CustomControl) PUTCustom* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 296, p1) END PUTCustom; PROCEDURE (this: _CustomControl) About* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 297) END About; PROCEDURE (this: _CustomControl) PUTAbout* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 297, p1) END PUTAbout; PROCEDURE (this: _CustomControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _CustomControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _TabControl, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _TabControl) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _TabControl) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _TabControl) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _TabControl) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _TabControl) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _TabControl) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _TabControl) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _TabControl) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _TabControl) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _TabControl) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _TabControl) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _TabControl) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _TabControl) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _TabControl) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _TabControl) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _TabControl) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _TabControl) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _TabControl) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _TabControl) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _TabControl) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _TabControl) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _TabControl) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _TabControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _TabControl) OldValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2102) END OldValue; PROCEDURE (this: _TabControl) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _TabControl) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _TabControl) Pages* (): Pages, NEW; BEGIN RETURN ThisPages(CtlC.GetAny(this, 2180)) END Pages; PROCEDURE (this: _TabControl) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _TabControl) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _TabControl) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _TabControl) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _TabControl) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _TabControl) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _TabControl) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _TabControl) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _TabControl) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _TabControl) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _TabControl) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _TabControl) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _TabControl) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _TabControl) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _TabControl) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _TabControl) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _TabControl) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _TabControl) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END TabStop; PROCEDURE (this: _TabControl) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTTabStop; PROCEDURE (this: _TabControl) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 261) END TabIndex; PROCEDURE (this: _TabControl) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 261, p1) END PUTTabIndex; PROCEDURE (this: _TabControl) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _TabControl) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _TabControl) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _TabControl) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _TabControl) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _TabControl) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _TabControl) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _TabControl) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _TabControl) BackStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 29) END BackStyle; PROCEDURE (this: _TabControl) PUTBackStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 29, p1) END PUTBackStyle; PROCEDURE (this: _TabControl) MultiRow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 348) END MultiRow; PROCEDURE (this: _TabControl) PUTMultiRow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 348, p1) END PUTMultiRow; PROCEDURE (this: _TabControl) Style* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 349) END Style; PROCEDURE (this: _TabControl) PUTStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 349, p1) END PUTStyle; PROCEDURE (this: _TabControl) TabFixedHeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 350) END TabFixedHeight; PROCEDURE (this: _TabControl) PUTTabFixedHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 350, p1) END PUTTabFixedHeight; PROCEDURE (this: _TabControl) TabFixedWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 351) END TabFixedWidth; PROCEDURE (this: _TabControl) PUTTabFixedWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 351, p1) END PUTTabFixedWidth; PROCEDURE (this: _TabControl) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _TabControl) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _TabControl) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _TabControl) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _TabControl) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 37) END FontWeight; PROCEDURE (this: _TabControl) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 37, p1) END PUTFontWeight; PROCEDURE (this: _TabControl) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END FontItalic; PROCEDURE (this: _TabControl) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _TabControl) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END FontUnderline; PROCEDURE (this: _TabControl) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _TabControl) TextFontCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 193) END TextFontCharSet; PROCEDURE (this: _TabControl) PUTTextFontCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 193, p1) END PUTTextFontCharSet; PROCEDURE (this: _TabControl) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _TabControl) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _TabControl) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _TabControl) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _TabControl) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _TabControl) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _TabControl) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _TabControl) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _TabControl) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _TabControl) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _TabControl) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _TabControl) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _TabControl) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _TabControl) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _TabControl) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _TabControl) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _TabControl) OnChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 114) END OnChange; PROCEDURE (this: _TabControl) PUTOnChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 114, p1) END PUTOnChange; PROCEDURE (this: _TabControl) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _TabControl) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _TabControl) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _TabControl) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _TabControl) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _TabControl) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _TabControl) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _TabControl) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _TabControl) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _TabControl) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _TabControl) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _TabControl) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _TabControl) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _TabControl) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _TabControl) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _TabControl) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _TabControl) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _TabControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _TabControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Page, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Page) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Page) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Page) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Page) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Page) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Page) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Page) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Page) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Page) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Page) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Page) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Page) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Page) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Page) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Page) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Page) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Page) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Page) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Page) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Page) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Page) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Page) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Page) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Page) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Page) SizeToFit* (), NEW; BEGIN CtlC.CallMethod(this, 2151, NIL); END SizeToFit; PROCEDURE (this: _Page) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Page) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Page) Goto* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END Goto; PROCEDURE (this: _Page) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Page) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Page) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Page) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Page) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Page) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Page) ControlType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 21) END ControlType; PROCEDURE (this: _Page) PUTControlType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 21, p1) END PUTControlType; PROCEDURE (this: _Page) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _Page) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _Page) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _Page) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _Page) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _Page) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _Page) PageIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 352) END PageIndex; PROCEDURE (this: _Page) PUTPageIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 352, p1) END PUTPageIndex; PROCEDURE (this: _Page) StatusBarText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 135) END StatusBarText; PROCEDURE (this: _Page) PUTStatusBarText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 135, p1) END PUTStatusBarText; PROCEDURE (this: _Page) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Page) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Page) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END Enabled; PROCEDURE (this: _Page) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTEnabled; PROCEDURE (this: _Page) Left* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 54) END Left; PROCEDURE (this: _Page) PUTLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Page) Top* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 141) END Top; PROCEDURE (this: _Page) PUTTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Page) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Page) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Page) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Page) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Page) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Page) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Page) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 317) END ControlTipText; PROCEDURE (this: _Page) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 317, p1) END PUTControlTipText; PROCEDURE (this: _Page) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Page) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Page) Section* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 237) END Section; PROCEDURE (this: _Page) PUTSection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 237, p1) END PUTSection; PROCEDURE (this: _Page) ControlName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END ControlName; PROCEDURE (this: _Page) PUTControlName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTControlName; PROCEDURE (this: _Page) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Page) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Page) IsVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 140) END IsVisible; PROCEDURE (this: _Page) PUTIsVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 140, p1) END PUTIsVisible; PROCEDURE (this: _Page) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Page) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Page) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Page) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Page) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Page) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Page) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Page) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Page) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Page) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Page) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Page) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Page) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _Page) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _Page) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Page) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _Section, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Section) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Section) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Section) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Section) Controls* (): Children, NEW; BEGIN RETURN ThisChildren(CtlC.GetAny(this, 2190)) END Controls; PROCEDURE (this: _Section) EventProcPrefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END EventProcPrefix; PROCEDURE (this: _Section) PUTEventProcPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTEventProcPrefix; PROCEDURE (this: _Section) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Section) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Section) ForceNewPage* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 151) END ForceNewPage; PROCEDURE (this: _Section) PUTForceNewPage* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 151, p1) END PUTForceNewPage; PROCEDURE (this: _Section) NewRowOrCol* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 231) END NewRowOrCol; PROCEDURE (this: _Section) PUTNewRowOrCol* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 231, p1) END PUTNewRowOrCol; PROCEDURE (this: _Section) KeepTogether* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 75) END KeepTogether; PROCEDURE (this: _Section) PUTKeepTogether* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 75, p1) END PUTKeepTogether; PROCEDURE (this: _Section) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Section) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Section) DisplayWhen* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 149) END DisplayWhen; PROCEDURE (this: _Section) PUTDisplayWhen* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 149, p1) END PUTDisplayWhen; PROCEDURE (this: _Section) CanGrow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END CanGrow; PROCEDURE (this: _Section) PUTCanGrow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTCanGrow; PROCEDURE (this: _Section) CanShrink* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END CanShrink; PROCEDURE (this: _Section) PUTCanShrink* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTCanShrink; PROCEDURE (this: _Section) RepeatSection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 15) END RepeatSection; PROCEDURE (this: _Section) PUTRepeatSection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 15, p1) END PUTRepeatSection; PROCEDURE (this: _Section) Height* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 44) END Height; PROCEDURE (this: _Section) PUTHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Section) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END BackColor; PROCEDURE (this: _Section) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTBackColor; PROCEDURE (this: _Section) SpecialEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 4) END SpecialEffect; PROCEDURE (this: _Section) PUTSpecialEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 4, p1) END PUTSpecialEffect; PROCEDURE (this: _Section) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Section) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Section) OnFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 80) END OnFormat; PROCEDURE (this: _Section) PUTOnFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 80, p1) END PUTOnFormat; PROCEDURE (this: _Section) OnPrint* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 82) END OnPrint; PROCEDURE (this: _Section) PUTOnPrint* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 82, p1) END PUTOnPrint; PROCEDURE (this: _Section) OnRetreat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 84) END OnRetreat; PROCEDURE (this: _Section) PUTOnRetreat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 84, p1) END PUTOnRetreat; PROCEDURE (this: _Section) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Section) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Section) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Section) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Section) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Section) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Section) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Section) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Section) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Section) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Section) HasContinued* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 200) END HasContinued; PROCEDURE (this: _Section) PUTHasContinued* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 200, p1) END PUTHasContinued; PROCEDURE (this: _Section) WillContinue* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 201) END WillContinue; PROCEDURE (this: _Section) PUTWillContinue* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 201, p1) END PUTWillContinue; PROCEDURE (this: _Section) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END InSelection; PROCEDURE (this: _Section) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTInSelection; PROCEDURE (this: _Section) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Section) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- _GroupLevel, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _GroupLevel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _GroupLevel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _GroupLevel) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _GroupLevel) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 27) END ControlSource; PROCEDURE (this: _GroupLevel) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 27, p1) END PUTControlSource; PROCEDURE (this: _GroupLevel) SortOrder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 174) END SortOrder; PROCEDURE (this: _GroupLevel) PUTSortOrder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 174, p1) END PUTSortOrder; PROCEDURE (this: _GroupLevel) GroupHeader* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 175) END GroupHeader; PROCEDURE (this: _GroupLevel) PUTGroupHeader* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 175, p1) END PUTGroupHeader; PROCEDURE (this: _GroupLevel) GroupFooter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 176) END GroupFooter; PROCEDURE (this: _GroupLevel) PUTGroupFooter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 176, p1) END PUTGroupFooter; PROCEDURE (this: _GroupLevel) GroupOn* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 177) END GroupOn; PROCEDURE (this: _GroupLevel) PUTGroupOn* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 177, p1) END PUTGroupOn; PROCEDURE (this: _GroupLevel) GroupInterval* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 178) END GroupInterval; PROCEDURE (this: _GroupLevel) PUTGroupInterval* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 178, p1) END PUTGroupInterval; PROCEDURE (this: _GroupLevel) KeepTogether* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 75) END KeepTogether; PROCEDURE (this: _GroupLevel) PUTKeepTogether* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 75, p1) END PUTKeepTogether; (* ---------- Module, dual, nonextensible ---------- *) PROCEDURE (this: Module) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Module) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Module) InsertText* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 2093, arg, NIL); END InsertText; PROCEDURE (this: Module) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Module) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: Module) AddFromString* (String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743813, arg, NIL); END AddFromString; PROCEDURE (this: Module) AddFromFile* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, NIL); END AddFromFile; PROCEDURE (this: Module) Lines* (Line: INTEGER; NumLines: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.IntVar(NumLines, arg[0]); CtlC.CallGetMethod(this, 1610743815, arg, ret); RETURN CtlC.VarStr(ret) END Lines; PROCEDURE (this: Module) CountOfLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743816) END CountOfLines; PROCEDURE (this: Module) InsertLines* (Line: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743817, arg, NIL); END InsertLines; PROCEDURE (this: Module) DeleteLines* (StartLine: INTEGER; Count: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(StartLine, arg[1]); CtlC.IntVar(Count, arg[0]); CtlC.CallParMethod(this, 1610743818, arg, NIL); END DeleteLines; PROCEDURE (this: Module) ReplaceLine* (Line: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743819, arg, NIL); END ReplaceLine; PROCEDURE (this: Module) ProcStartLine* (ProcName: ARRAY OF CHAR; ProcKind: CtlVBIDE.vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743820, arg, ret); RETURN CtlC.VarInt(ret) END ProcStartLine; PROCEDURE (this: Module) ProcCountLines* (ProcName: ARRAY OF CHAR; ProcKind: CtlVBIDE.vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743821, arg, ret); RETURN CtlC.VarInt(ret) END ProcCountLines; PROCEDURE (this: Module) ProcBodyLine* (ProcName: ARRAY OF CHAR; ProcKind: CtlVBIDE.vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743822, arg, ret); RETURN CtlC.VarInt(ret) END ProcBodyLine; PROCEDURE (this: Module) ProcOfLine* (Line: INTEGER; OUT pprockind: CtlVBIDE.vbext_ProcKind): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.RefIntVar(pprockind, arg[0]); CtlC.CallGetMethod(this, 1610743823, arg, ret); RETURN CtlC.VarStr(ret) END ProcOfLine; PROCEDURE (this: Module) CountOfDeclarationLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743824) END CountOfDeclarationLines; PROCEDURE (this: Module) CreateEventProc* (EventName: ARRAY OF CHAR; ObjectName: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(EventName, arg[1]); CtlC.StrVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 1610743825, arg, ret); RETURN CtlC.VarInt(ret) END CreateEventProc; PROCEDURE (this: Module) Find* (Target: ARRAY OF CHAR; VAR StartLine: INTEGER; VAR StartColumn: INTEGER; VAR EndLine: INTEGER; VAR EndColumn: INTEGER; WholeWord: BOOLEAN; MatchCase: BOOLEAN; PatternSearch: BOOLEAN): BOOLEAN, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Target, arg[7]); CtlC.RefIntVar(StartLine, arg[6]); CtlC.RefIntVar(StartColumn, arg[5]); CtlC.RefIntVar(EndLine, arg[4]); CtlC.RefIntVar(EndColumn, arg[3]); CtlC.BoolVar(WholeWord, arg[2]); CtlC.BoolVar(MatchCase, arg[1]); CtlC.BoolVar(PatternSearch, arg[0]); CtlC.CallParMethod(this, 1610743826, arg, ret); RETURN CtlC.VarBool(ret) END Find; PROCEDURE (this: Module) Type* (): AcModuleType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743827) END Type; (* ---------- Modules, dual ---------- *) PROCEDURE (this: Modules) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Modules) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Modules) Item* (Index: CtlT.Any): Module, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisModule(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Modules) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Modules) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _Form, hidden, dual ---------- *) PROCEDURE (this: _Form) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _Form) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _Form) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _Form) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _Form) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _Form) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _Form) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _Form) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _Form) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _Form) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _Form) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _Form) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _Form) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _Form) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _Form) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _Form) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _Form) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _Form) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _Form) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _Form) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _Form) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _Form) FormName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 39) END FormName; PROCEDURE (this: _Form) PUTFormName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 39, p1) END PUTFormName; PROCEDURE (this: _Form) RecordSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 156) END RecordSource; PROCEDURE (this: _Form) PUTRecordSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 156, p1) END PUTRecordSource; PROCEDURE (this: _Form) Filter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 245) END Filter; PROCEDURE (this: _Form) PUTFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 245, p1) END PUTFilter; PROCEDURE (this: _Form) FilterOn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 332) END FilterOn; PROCEDURE (this: _Form) PUTFilterOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 332, p1) END PUTFilterOn; PROCEDURE (this: _Form) OrderBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 331) END OrderBy; PROCEDURE (this: _Form) PUTOrderBy* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 331, p1) END PUTOrderBy; PROCEDURE (this: _Form) OrderByOn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 336) END OrderByOn; PROCEDURE (this: _Form) PUTOrderByOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 336, p1) END PUTOrderByOn; PROCEDURE (this: _Form) AllowFilters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 30) END AllowFilters; PROCEDURE (this: _Form) PUTAllowFilters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 30, p1) END PUTAllowFilters; PROCEDURE (this: _Form) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _Form) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _Form) DefaultView* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 147) END DefaultView; PROCEDURE (this: _Form) PUTDefaultView* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 147, p1) END PUTDefaultView; PROCEDURE (this: _Form) ViewsAllowed* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 146) END ViewsAllowed; PROCEDURE (this: _Form) PUTViewsAllowed* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 146, p1) END PUTViewsAllowed; PROCEDURE (this: _Form) AllowEditing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END AllowEditing; PROCEDURE (this: _Form) PUTAllowEditing* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTAllowEditing; PROCEDURE (this: _Form) DefaultEditing* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 134) END DefaultEditing; PROCEDURE (this: _Form) PUTDefaultEditing* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 134, p1) END PUTDefaultEditing; PROCEDURE (this: _Form) AllowEdits* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 339) END AllowEdits; PROCEDURE (this: _Form) PUTAllowEdits* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 339, p1) END PUTAllowEdits; PROCEDURE (this: _Form) AllowDeletions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 292) END AllowDeletions; PROCEDURE (this: _Form) PUTAllowDeletions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 292, p1) END PUTAllowDeletions; PROCEDURE (this: _Form) AllowAdditions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 326) END AllowAdditions; PROCEDURE (this: _Form) PUTAllowAdditions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 326, p1) END PUTAllowAdditions; PROCEDURE (this: _Form) DataEntry* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 338) END DataEntry; PROCEDURE (this: _Form) PUTDataEntry* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 338, p1) END PUTDataEntry; PROCEDURE (this: _Form) AllowUpdating* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 45) END AllowUpdating; PROCEDURE (this: _Form) PUTAllowUpdating* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 45, p1) END PUTAllowUpdating; PROCEDURE (this: _Form) RecordsetType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 337) END RecordsetType; PROCEDURE (this: _Form) PUTRecordsetType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 337, p1) END PUTRecordsetType; PROCEDURE (this: _Form) RecordLocks* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 26) END RecordLocks; PROCEDURE (this: _Form) PUTRecordLocks* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 26, p1) END PUTRecordLocks; PROCEDURE (this: _Form) ScrollBars* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 152) END ScrollBars; PROCEDURE (this: _Form) PUTScrollBars* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 152, p1) END PUTScrollBars; PROCEDURE (this: _Form) RecordSelectors* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 19) END RecordSelectors; PROCEDURE (this: _Form) PUTRecordSelectors* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 19, p1) END PUTRecordSelectors; PROCEDURE (this: _Form) NavigationButtons* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 279) END NavigationButtons; PROCEDURE (this: _Form) PUTNavigationButtons* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 279, p1) END PUTNavigationButtons; PROCEDURE (this: _Form) DividingLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 314) END DividingLines; PROCEDURE (this: _Form) PUTDividingLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 314, p1) END PUTDividingLines; PROCEDURE (this: _Form) AutoResize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END AutoResize; PROCEDURE (this: _Form) PUTAutoResize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTAutoResize; PROCEDURE (this: _Form) AutoCenter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 278) END AutoCenter; PROCEDURE (this: _Form) PUTAutoCenter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 278, p1) END PUTAutoCenter; PROCEDURE (this: _Form) PopUp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 90) END PopUp; PROCEDURE (this: _Form) PUTPopUp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 90, p1) END PUTPopUp; PROCEDURE (this: _Form) Modal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62) END Modal; PROCEDURE (this: _Form) PUTModal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 62, p1) END PUTModal; PROCEDURE (this: _Form) BorderStyle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 9) END BorderStyle; PROCEDURE (this: _Form) PUTBorderStyle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 9, p1) END PUTBorderStyle; PROCEDURE (this: _Form) ControlBox* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 97) END ControlBox; PROCEDURE (this: _Form) PUTControlBox* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 97, p1) END PUTControlBox; PROCEDURE (this: _Form) MinButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 95) END MinButton; PROCEDURE (this: _Form) PUTMinButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 95, p1) END PUTMinButton; PROCEDURE (this: _Form) MaxButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 94) END MaxButton; PROCEDURE (this: _Form) PUTMaxButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 94, p1) END PUTMaxButton; PROCEDURE (this: _Form) MinMaxButtons* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 328) END MinMaxButtons; PROCEDURE (this: _Form) PUTMinMaxButtons* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 328, p1) END PUTMinMaxButtons; PROCEDURE (this: _Form) CloseButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 303) END CloseButton; PROCEDURE (this: _Form) PUTCloseButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 303, p1) END PUTCloseButton; PROCEDURE (this: _Form) WhatsThisButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 96) END WhatsThisButton; PROCEDURE (this: _Form) PUTWhatsThisButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 96, p1) END PUTWhatsThisButton; PROCEDURE (this: _Form) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Form) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Form) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _Form) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _Form) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _Form) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _Form) PictureSizeMode* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 312) END PictureSizeMode; PROCEDURE (this: _Form) PUTPictureSizeMode* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 312, p1) END PUTPictureSizeMode; PROCEDURE (this: _Form) PictureAlignment* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 309) END PictureAlignment; PROCEDURE (this: _Form) PUTPictureAlignment* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 309, p1) END PUTPictureAlignment; PROCEDURE (this: _Form) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 313) END PictureTiling; PROCEDURE (this: _Form) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 313, p1) END PUTPictureTiling; PROCEDURE (this: _Form) Cycle* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 330) END Cycle; PROCEDURE (this: _Form) PUTCycle* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 330, p1) END PUTCycle; PROCEDURE (this: _Form) MenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 240) END MenuBar; PROCEDURE (this: _Form) PUTMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 240, p1) END PUTMenuBar; PROCEDURE (this: _Form) Toolbar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 353) END Toolbar; PROCEDURE (this: _Form) PUTToolbar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 353, p1) END PUTToolbar; PROCEDURE (this: _Form) ShortcutMenu* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 31) END ShortcutMenu; PROCEDURE (this: _Form) PUTShortcutMenu* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 31, p1) END PUTShortcutMenu; PROCEDURE (this: _Form) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Form) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Form) GridX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 41) END GridX; PROCEDURE (this: _Form) PUTGridX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 41, p1) END PUTGridX; PROCEDURE (this: _Form) GridY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 42) END GridY; PROCEDURE (this: _Form) PUTGridY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 42, p1) END PUTGridY; PROCEDURE (this: _Form) LayoutForPrint* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 143) END LayoutForPrint; PROCEDURE (this: _Form) PUTLayoutForPrint* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 143, p1) END PUTLayoutForPrint; PROCEDURE (this: _Form) FastLaserPrinting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 144) END FastLaserPrinting; PROCEDURE (this: _Form) PUTFastLaserPrinting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 144, p1) END PUTFastLaserPrinting; PROCEDURE (this: _Form) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 218) END HelpFile; PROCEDURE (this: _Form) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 218, p1) END PUTHelpFile; PROCEDURE (this: _Form) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Form) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Form) RowHeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 168) END RowHeight; PROCEDURE (this: _Form) PUTRowHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 168, p1) END PUTRowHeight; PROCEDURE (this: _Form) DatasheetFontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 160) END DatasheetFontName; PROCEDURE (this: _Form) PUTDatasheetFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 160, p1) END PUTDatasheetFontName; PROCEDURE (this: _Form) DatasheetFontHeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 161) END DatasheetFontHeight; PROCEDURE (this: _Form) PUTDatasheetFontHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 161, p1) END PUTDatasheetFontHeight; PROCEDURE (this: _Form) DatasheetFontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 162) END DatasheetFontWeight; PROCEDURE (this: _Form) PUTDatasheetFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 162, p1) END PUTDatasheetFontWeight; PROCEDURE (this: _Form) DatasheetFontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 163) END DatasheetFontItalic; PROCEDURE (this: _Form) PUTDatasheetFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 163, p1) END PUTDatasheetFontItalic; PROCEDURE (this: _Form) DatasheetFontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 164) END DatasheetFontUnderline; PROCEDURE (this: _Form) PUTDatasheetFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 164, p1) END PUTDatasheetFontUnderline; PROCEDURE (this: _Form) TabularCharSet* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 194) END TabularCharSet; PROCEDURE (this: _Form) PUTTabularCharSet* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 194, p1) END PUTTabularCharSet; PROCEDURE (this: _Form) DatasheetGridlinesBehavior* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 318) END DatasheetGridlinesBehavior; PROCEDURE (this: _Form) PUTDatasheetGridlinesBehavior* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 318, p1) END PUTDatasheetGridlinesBehavior; PROCEDURE (this: _Form) DatasheetGridlinesColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 319) END DatasheetGridlinesColor; PROCEDURE (this: _Form) PUTDatasheetGridlinesColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 319, p1) END PUTDatasheetGridlinesColor; PROCEDURE (this: _Form) DatasheetCellsEffect* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 320) END DatasheetCellsEffect; PROCEDURE (this: _Form) PUTDatasheetCellsEffect* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 320, p1) END PUTDatasheetCellsEffect; PROCEDURE (this: _Form) DatasheetForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 306) END DatasheetForeColor; PROCEDURE (this: _Form) PUTDatasheetForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 306, p1) END PUTDatasheetForeColor; PROCEDURE (this: _Form) ShowGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 169) END ShowGrid; PROCEDURE (this: _Form) PUTShowGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 169, p1) END PUTShowGrid; PROCEDURE (this: _Form) DatasheetBackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 321) END DatasheetBackColor; PROCEDURE (this: _Form) PUTDatasheetBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 321, p1) END PUTDatasheetBackColor; PROCEDURE (this: _Form) Hwnd* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 192) END Hwnd; PROCEDURE (this: _Form) PUTHwnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 192, p1) END PUTHwnd; PROCEDURE (this: _Form) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 195) END Count; PROCEDURE (this: _Form) PUTCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 195, p1) END PUTCount; PROCEDURE (this: _Form) Page* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 196) END Page; PROCEDURE (this: _Form) PUTPage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 196, p1) END PUTPage; PROCEDURE (this: _Form) Pages* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 197) END Pages; PROCEDURE (this: _Form) PUTPages* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 197, p1) END PUTPages; PROCEDURE (this: _Form) LogicalPageWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 198) END LogicalPageWidth; PROCEDURE (this: _Form) PUTLogicalPageWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 198, p1) END PUTLogicalPageWidth; PROCEDURE (this: _Form) LogicalPageHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 199) END LogicalPageHeight; PROCEDURE (this: _Form) PUTLogicalPageHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 199, p1) END PUTLogicalPageHeight; PROCEDURE (this: _Form) ZoomControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 217) END ZoomControl; PROCEDURE (this: _Form) PUTZoomControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 217, p1) END PUTZoomControl; PROCEDURE (this: _Form) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Form) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Form) Painting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 241) END Painting; PROCEDURE (this: _Form) PUTPainting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 241, p1) END PUTPainting; PROCEDURE (this: _Form) PrtMip* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 189) END PrtMip; PROCEDURE (this: _Form) PUTPrtMip* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 189, p1) END PUTPrtMip; PROCEDURE (this: _Form) PrtDevMode* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 190) END PrtDevMode; PROCEDURE (this: _Form) PUTPrtDevMode* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 190, p1) END PUTPrtDevMode; PROCEDURE (this: _Form) PrtDevNames* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 191) END PrtDevNames; PROCEDURE (this: _Form) PUTPrtDevNames* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 191, p1) END PUTPrtDevNames; PROCEDURE (this: _Form) FrozenColumns* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 170) END FrozenColumns; PROCEDURE (this: _Form) PUTFrozenColumns* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 170, p1) END PUTFrozenColumns; PROCEDURE (this: _Form) Bookmark* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 230) END Bookmark; PROCEDURE (this: _Form) PUTBookmark* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 230, p1) END PUTBookmark; PROCEDURE (this: _Form) TabularFamily* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 244) END TabularFamily; PROCEDURE (this: _Form) PUTTabularFamily* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 244, p1) END PUTTabularFamily; PROCEDURE (this: _Form) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Form) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Form) PaletteSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 98) END PaletteSource; PROCEDURE (this: _Form) PUTPaletteSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 98, p1) END PUTPaletteSource; PROCEDURE (this: _Form) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Form) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Form) PaintPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END PaintPalette; PROCEDURE (this: _Form) PUTPaintPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTPaintPalette; PROCEDURE (this: _Form) OnMenu* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 60) END OnMenu; PROCEDURE (this: _Form) PUTOnMenu* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 60, p1) END PUTOnMenu; PROCEDURE (this: _Form) OpenArgs* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 284) END OpenArgs; PROCEDURE (this: _Form) PUTOpenArgs* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 284, p1) END PUTOpenArgs; PROCEDURE (this: _Form) ConnectSynch* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 285) END ConnectSynch; PROCEDURE (this: _Form) PUTConnectSynch* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 285, p1) END PUTConnectSynch; PROCEDURE (this: _Form) OnCurrent* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 87) END OnCurrent; PROCEDURE (this: _Form) PUTOnCurrent* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 87, p1) END PUTOnCurrent; PROCEDURE (this: _Form) OnInsert* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 81) END OnInsert; PROCEDURE (this: _Form) PUTOnInsert* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 81, p1) END PUTOnInsert; PROCEDURE (this: _Form) BeforeInsert* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 122) END BeforeInsert; PROCEDURE (this: _Form) PUTBeforeInsert* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 122, p1) END PUTBeforeInsert; PROCEDURE (this: _Form) AfterInsert* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 123) END AfterInsert; PROCEDURE (this: _Form) PUTAfterInsert* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 123, p1) END PUTAfterInsert; PROCEDURE (this: _Form) BeforeUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 85) END BeforeUpdate; PROCEDURE (this: _Form) PUTBeforeUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTBeforeUpdate; PROCEDURE (this: _Form) AfterUpdate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 86) END AfterUpdate; PROCEDURE (this: _Form) PUTAfterUpdate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTAfterUpdate; PROCEDURE (this: _Form) OnDirty* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 375) END OnDirty; PROCEDURE (this: _Form) PUTOnDirty* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 375, p1) END PUTOnDirty; PROCEDURE (this: _Form) OnDelete* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 79) END OnDelete; PROCEDURE (this: _Form) PUTOnDelete* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 79, p1) END PUTOnDelete; PROCEDURE (this: _Form) BeforeDelConfirm* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 124) END BeforeDelConfirm; PROCEDURE (this: _Form) PUTBeforeDelConfirm* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 124, p1) END PUTBeforeDelConfirm; PROCEDURE (this: _Form) AfterDelConfirm* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 125) END AfterDelConfirm; PROCEDURE (this: _Form) PUTAfterDelConfirm* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 125, p1) END PUTAfterDelConfirm; PROCEDURE (this: _Form) OnOpen* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 77) END OnOpen; PROCEDURE (this: _Form) PUTOnOpen* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 77, p1) END PUTOnOpen; PROCEDURE (this: _Form) OnLoad* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 127) END OnLoad; PROCEDURE (this: _Form) PUTOnLoad* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 127, p1) END PUTOnLoad; PROCEDURE (this: _Form) OnResize* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 117) END OnResize; PROCEDURE (this: _Form) PUTOnResize* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 117, p1) END PUTOnResize; PROCEDURE (this: _Form) OnUnload* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 128) END OnUnload; PROCEDURE (this: _Form) PUTOnUnload* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 128, p1) END PUTOnUnload; PROCEDURE (this: _Form) OnClose* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 78) END OnClose; PROCEDURE (this: _Form) PUTOnClose* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 78, p1) END PUTOnClose; PROCEDURE (this: _Form) OnActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END OnActivate; PROCEDURE (this: _Form) PUTOnActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 112, p1) END PUTOnActivate; PROCEDURE (this: _Form) OnDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END OnDeactivate; PROCEDURE (this: _Form) PUTOnDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 113, p1) END PUTOnDeactivate; PROCEDURE (this: _Form) OnGotFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END OnGotFocus; PROCEDURE (this: _Form) PUTOnGotFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTOnGotFocus; PROCEDURE (this: _Form) OnLostFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END OnLostFocus; PROCEDURE (this: _Form) PUTOnLostFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTOnLostFocus; PROCEDURE (this: _Form) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END OnClick; PROCEDURE (this: _Form) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTOnClick; PROCEDURE (this: _Form) OnDblClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 224) END OnDblClick; PROCEDURE (this: _Form) PUTOnDblClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 224, p1) END PUTOnDblClick; PROCEDURE (this: _Form) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END OnMouseDown; PROCEDURE (this: _Form) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTOnMouseDown; PROCEDURE (this: _Form) OnMouseMove* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END OnMouseMove; PROCEDURE (this: _Form) PUTOnMouseMove* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTOnMouseMove; PROCEDURE (this: _Form) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END OnMouseUp; PROCEDURE (this: _Form) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTOnMouseUp; PROCEDURE (this: _Form) OnKeyDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END OnKeyDown; PROCEDURE (this: _Form) PUTOnKeyDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTOnKeyDown; PROCEDURE (this: _Form) OnKeyUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END OnKeyUp; PROCEDURE (this: _Form) PUTOnKeyUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTOnKeyUp; PROCEDURE (this: _Form) OnKeyPress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END OnKeyPress; PROCEDURE (this: _Form) PUTOnKeyPress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTOnKeyPress; PROCEDURE (this: _Form) KeyPreview* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 327) END KeyPreview; PROCEDURE (this: _Form) PUTKeyPreview* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 327, p1) END PUTKeyPreview; PROCEDURE (this: _Form) OnError* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 119) END OnError; PROCEDURE (this: _Form) PUTOnError* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 119, p1) END PUTOnError; PROCEDURE (this: _Form) OnFilter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 333) END OnFilter; PROCEDURE (this: _Form) PUTOnFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 333, p1) END PUTOnFilter; PROCEDURE (this: _Form) OnApplyFilter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 334) END OnApplyFilter; PROCEDURE (this: _Form) PUTOnApplyFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 334, p1) END PUTOnApplyFilter; PROCEDURE (this: _Form) OnTimer* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END OnTimer; PROCEDURE (this: _Form) PUTOnTimer* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTOnTimer; PROCEDURE (this: _Form) TimerInterval* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END TimerInterval; PROCEDURE (this: _Form) PUTTimerInterval* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTTimerInterval; PROCEDURE (this: _Form) Dirty* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 286) END Dirty; PROCEDURE (this: _Form) PUTDirty* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 286, p1) END PUTDirty; PROCEDURE (this: _Form) WindowWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 287) END WindowWidth; PROCEDURE (this: _Form) PUTWindowWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 287, p1) END PUTWindowWidth; PROCEDURE (this: _Form) WindowHeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 288) END WindowHeight; PROCEDURE (this: _Form) PUTWindowHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 288, p1) END PUTWindowHeight; PROCEDURE (this: _Form) CurrentView* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 289) END CurrentView; PROCEDURE (this: _Form) PUTCurrentView* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 289, p1) END PUTCurrentView; PROCEDURE (this: _Form) CurrentSectionTop* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 291) END CurrentSectionTop; PROCEDURE (this: _Form) PUTCurrentSectionTop* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 291, p1) END PUTCurrentSectionTop; PROCEDURE (this: _Form) CurrentSectionLeft* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 290) END CurrentSectionLeft; PROCEDURE (this: _Form) PUTCurrentSectionLeft* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 290, p1) END PUTCurrentSectionLeft; PROCEDURE (this: _Form) SelLeft* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 298) END SelLeft; PROCEDURE (this: _Form) PUTSelLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 298, p1) END PUTSelLeft; PROCEDURE (this: _Form) SelTop* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 299) END SelTop; PROCEDURE (this: _Form) PUTSelTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 299, p1) END PUTSelTop; PROCEDURE (this: _Form) SelWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 300) END SelWidth; PROCEDURE (this: _Form) PUTSelWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 300, p1) END PUTSelWidth; PROCEDURE (this: _Form) SelHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 301) END SelHeight; PROCEDURE (this: _Form) PUTSelHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 301, p1) END PUTSelHeight; PROCEDURE (this: _Form) CurrentRecord* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 302) END CurrentRecord; PROCEDURE (this: _Form) PUTCurrentRecord* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 302, p1) END PUTCurrentRecord; PROCEDURE (this: _Form) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _Form) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _Form) InsideHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 315) END InsideHeight; PROCEDURE (this: _Form) PUTInsideHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 315, p1) END PUTInsideHeight; PROCEDURE (this: _Form) InsideWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 316) END InsideWidth; PROCEDURE (this: _Form) PUTInsideWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 316, p1) END PUTInsideWidth; PROCEDURE (this: _Form) PicturePalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 311) END PicturePalette; PROCEDURE (this: _Form) PUTPicturePalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 311, p1) END PUTPicturePalette; PROCEDURE (this: _Form) HasModule* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 342) END HasModule; PROCEDURE (this: _Form) PUTHasModule* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 342, p1) END PUTHasModule; PROCEDURE (this: _Form) acHiddenCurrentPage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 365) END acHiddenCurrentPage; PROCEDURE (this: _Form) PUTacHiddenCurrentPage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 365, p1) END PUTacHiddenCurrentPage; PROCEDURE (this: _Form) Orientation* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 370) END Orientation; PROCEDURE (this: _Form) PUTOrientation* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 370, p1) END PUTOrientation; PROCEDURE (this: _Form) AllowDesignChanges* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 373) END AllowDesignChanges; PROCEDURE (this: _Form) PUTAllowDesignChanges* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 373, p1) END PUTAllowDesignChanges; PROCEDURE (this: _Form) ServerFilter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 246) END ServerFilter; PROCEDURE (this: _Form) PUTServerFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 246, p1) END PUTServerFilter; PROCEDURE (this: _Form) ServerFilterByForm* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 247) END ServerFilterByForm; PROCEDURE (this: _Form) PUTServerFilterByForm* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 247, p1) END PUTServerFilterByForm; PROCEDURE (this: _Form) MaxRecords* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 361) END MaxRecords; PROCEDURE (this: _Form) PUTMaxRecords* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 361, p1) END PUTMaxRecords; PROCEDURE (this: _Form) UniqueTable* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 65) END UniqueTable; PROCEDURE (this: _Form) PUTUniqueTable* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 65, p1) END PUTUniqueTable; PROCEDURE (this: _Form) ResyncCommand* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 64) END ResyncCommand; PROCEDURE (this: _Form) PUTResyncCommand* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 64, p1) END PUTResyncCommand; PROCEDURE (this: _Form) InputParameters* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END InputParameters; PROCEDURE (this: _Form) PUTInputParameters* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 66, p1) END PUTInputParameters; PROCEDURE (this: _Form) MaxRecButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 63) END MaxRecButton; PROCEDURE (this: _Form) PUTMaxRecButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 63, p1) END PUTMaxRecButton; PROCEDURE (this: _Form) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Form) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Form) NewRecord* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 2147) END NewRecord; PROCEDURE (this: _Form) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 2145, NIL); END Undo; PROCEDURE (this: _Form) ActiveControl* (): Control, NEW; BEGIN RETURN This_Control(CtlC.GetAny(this, 2006)) END ActiveControl; PROCEDURE (this: _Form) DefaultControl* (ControlType: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ControlType, arg[0]); CtlC.CallGetMethod(this, 2150, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END DefaultControl; PROCEDURE (this: _Form) Dynaset* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2085) END Dynaset; PROCEDURE (this: _Form) RecordsetClone* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2086) END RecordsetClone; PROCEDURE (this: _Form) Recordset* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2196) END Recordset; PROCEDURE (this: _Form) PUTREFRecordset* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 2196, arg, NIL); END PUTREFRecordset; PROCEDURE (this: _Form) Section* (Index: CtlT.Any): Section, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 2088, arg, ret); RETURN This_Section(CtlC.VarAny(ret)) END Section; PROCEDURE (this: _Form) Form* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2089)) END Form; PROCEDURE (this: _Form) Module* (): Module, NEW; BEGIN RETURN ThisModule(CtlC.GetAny(this, 2090)) END Module; PROCEDURE (this: _Form) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Form) ConnectControl* (): Control, NEW; BEGIN RETURN This_Control(CtlC.GetAny(this, 2092)) END ConnectControl; PROCEDURE (this: _Form) Recalc* (), NEW; BEGIN CtlC.CallMethod(this, 2017, NIL); END Recalc; PROCEDURE (this: _Form) Requery* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Requery; PROCEDURE (this: _Form) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, -550, NIL); END Refresh; PROCEDURE (this: _Form) Repaint* (), NEW; BEGIN CtlC.CallMethod(this, 2020, NIL); END Repaint; PROCEDURE (this: _Form) GoToPage* (PageNumber: INTEGER; Right: INTEGER; Down: INTEGER), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(PageNumber, arg[2]); CtlC.IntVar(Right, arg[1]); CtlC.IntVar(Down, arg[0]); CtlC.CallParMethod(this, 2021, arg, NIL); END GoToPage; PROCEDURE (this: _Form) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 2022, NIL); END SetFocus; PROCEDURE (this: _Form) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: _Form) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Form) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Form) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Form) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _Form) SubdatasheetHeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 387) END SubdatasheetHeight; PROCEDURE (this: _Form) PUTSubdatasheetHeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 387, p1) END PUTSubdatasheetHeight; PROCEDURE (this: _Form) SubdatasheetExpanded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 390) END SubdatasheetExpanded; PROCEDURE (this: _Form) PUTSubdatasheetExpanded* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 390, p1) END PUTSubdatasheetExpanded; (* ---------- Forms, dual ---------- *) PROCEDURE (this: Forms) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Forms) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Forms) Item* (Index: CtlT.Any): Form, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Form(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Forms) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Forms) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _Report, hidden, dual ---------- *) PROCEDURE (this: _Report) FormName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 39) END FormName; PROCEDURE (this: _Report) PUTFormName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 39, p1) END PUTFormName; PROCEDURE (this: _Report) RecordSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 156) END RecordSource; PROCEDURE (this: _Report) PUTRecordSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 156, p1) END PUTRecordSource; PROCEDURE (this: _Report) Filter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 245) END Filter; PROCEDURE (this: _Report) PUTFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 245, p1) END PUTFilter; PROCEDURE (this: _Report) FilterOn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 332) END FilterOn; PROCEDURE (this: _Report) PUTFilterOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 332, p1) END PUTFilterOn; PROCEDURE (this: _Report) OrderBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 331) END OrderBy; PROCEDURE (this: _Report) PUTOrderBy* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 331, p1) END PUTOrderBy; PROCEDURE (this: _Report) OrderByOn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 336) END OrderByOn; PROCEDURE (this: _Report) PUTOrderByOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 336, p1) END PUTOrderByOn; PROCEDURE (this: _Report) ServerFilter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 246) END ServerFilter; PROCEDURE (this: _Report) PUTServerFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 246, p1) END PUTServerFilter; PROCEDURE (this: _Report) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Caption; PROCEDURE (this: _Report) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTCaption; PROCEDURE (this: _Report) RecordLocks* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 26) END RecordLocks; PROCEDURE (this: _Report) PUTRecordLocks* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 26, p1) END PUTRecordLocks; PROCEDURE (this: _Report) PageHeader* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 43) END PageHeader; PROCEDURE (this: _Report) PUTPageHeader* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 43, p1) END PUTPageHeader; PROCEDURE (this: _Report) PageFooter* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 40) END PageFooter; PROCEDURE (this: _Report) PUTPageFooter* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 40, p1) END PUTPageFooter; PROCEDURE (this: _Report) DateGrouping* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 282) END DateGrouping; PROCEDURE (this: _Report) PUTDateGrouping* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 282, p1) END PUTDateGrouping; PROCEDURE (this: _Report) GrpKeepTogether* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 283) END GrpKeepTogether; PROCEDURE (this: _Report) PUTGrpKeepTogether* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 283, p1) END PUTGrpKeepTogether; PROCEDURE (this: _Report) MinButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 95) END MinButton; PROCEDURE (this: _Report) PUTMinButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 95, p1) END PUTMinButton; PROCEDURE (this: _Report) MaxButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 94) END MaxButton; PROCEDURE (this: _Report) PUTMaxButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 94, p1) END PUTMaxButton; PROCEDURE (this: _Report) Width* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 150) END Width; PROCEDURE (this: _Report) PUTWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 150, p1) END PUTWidth; PROCEDURE (this: _Report) Picture* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Picture; PROCEDURE (this: _Report) PUTPicture* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTPicture; PROCEDURE (this: _Report) PictureType* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 341) END PictureType; PROCEDURE (this: _Report) PUTPictureType* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 341, p1) END PUTPictureType; PROCEDURE (this: _Report) PictureSizeMode* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 312) END PictureSizeMode; PROCEDURE (this: _Report) PUTPictureSizeMode* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 312, p1) END PUTPictureSizeMode; PROCEDURE (this: _Report) PictureAlignment* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 309) END PictureAlignment; PROCEDURE (this: _Report) PUTPictureAlignment* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 309, p1) END PUTPictureAlignment; PROCEDURE (this: _Report) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 313) END PictureTiling; PROCEDURE (this: _Report) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 313, p1) END PUTPictureTiling; PROCEDURE (this: _Report) PicturePages* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 310) END PicturePages; PROCEDURE (this: _Report) PUTPicturePages* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 310, p1) END PUTPicturePages; PROCEDURE (this: _Report) MenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 240) END MenuBar; PROCEDURE (this: _Report) PUTMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 240, p1) END PUTMenuBar; PROCEDURE (this: _Report) Toolbar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 353) END Toolbar; PROCEDURE (this: _Report) PUTToolbar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 353, p1) END PUTToolbar; PROCEDURE (this: _Report) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 304) END ShortcutMenuBar; PROCEDURE (this: _Report) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 304, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Report) GridX* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 41) END GridX; PROCEDURE (this: _Report) PUTGridX* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 41, p1) END PUTGridX; PROCEDURE (this: _Report) GridY* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 42) END GridY; PROCEDURE (this: _Report) PUTGridY* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 42, p1) END PUTGridY; PROCEDURE (this: _Report) LayoutForPrint* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 143) END LayoutForPrint; PROCEDURE (this: _Report) PUTLayoutForPrint* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 143, p1) END PUTLayoutForPrint; PROCEDURE (this: _Report) FastLaserPrinting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 144) END FastLaserPrinting; PROCEDURE (this: _Report) PUTFastLaserPrinting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 144, p1) END PUTFastLaserPrinting; PROCEDURE (this: _Report) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 218) END HelpFile; PROCEDURE (this: _Report) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 218, p1) END PUTHelpFile; PROCEDURE (this: _Report) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 219) END HelpContextId; PROCEDURE (this: _Report) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 219, p1) END PUTHelpContextId; PROCEDURE (this: _Report) Hwnd* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 192) END Hwnd; PROCEDURE (this: _Report) PUTHwnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 192, p1) END PUTHwnd; PROCEDURE (this: _Report) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 195) END Count; PROCEDURE (this: _Report) PUTCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 195, p1) END PUTCount; PROCEDURE (this: _Report) Page* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 196) END Page; PROCEDURE (this: _Report) PUTPage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 196, p1) END PUTPage; PROCEDURE (this: _Report) Pages* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 197) END Pages; PROCEDURE (this: _Report) PUTPages* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 197, p1) END PUTPages; PROCEDURE (this: _Report) LogicalPageWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 198) END LogicalPageWidth; PROCEDURE (this: _Report) PUTLogicalPageWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 198, p1) END PUTLogicalPageWidth; PROCEDURE (this: _Report) LogicalPageHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 199) END LogicalPageHeight; PROCEDURE (this: _Report) PUTLogicalPageHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 199, p1) END PUTLogicalPageHeight; PROCEDURE (this: _Report) ZoomControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 217) END ZoomControl; PROCEDURE (this: _Report) PUTZoomControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 217, p1) END PUTZoomControl; PROCEDURE (this: _Report) HasData* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END HasData; PROCEDURE (this: _Report) PUTHasData* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTHasData; PROCEDURE (this: _Report) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Left; PROCEDURE (this: _Report) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTLeft; PROCEDURE (this: _Report) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 141) END Top; PROCEDURE (this: _Report) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 141, p1) END PUTTop; PROCEDURE (this: _Report) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 44) END Height; PROCEDURE (this: _Report) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 44, p1) END PUTHeight; PROCEDURE (this: _Report) PrintSection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 225) END PrintSection; PROCEDURE (this: _Report) PUTPrintSection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 225, p1) END PUTPrintSection; PROCEDURE (this: _Report) NextRecord* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 226) END NextRecord; PROCEDURE (this: _Report) PUTNextRecord* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 226, p1) END PUTNextRecord; PROCEDURE (this: _Report) MoveLayout* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 227) END MoveLayout; PROCEDURE (this: _Report) PUTMoveLayout* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 227, p1) END PUTMoveLayout; PROCEDURE (this: _Report) FormatCount* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 228) END FormatCount; PROCEDURE (this: _Report) PUTFormatCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 228, p1) END PUTFormatCount; PROCEDURE (this: _Report) PrintCount* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 229) END PrintCount; PROCEDURE (this: _Report) PUTPrintCount* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 229, p1) END PUTPrintCount; PROCEDURE (this: _Report) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _Report) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _Report) Painting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 241) END Painting; PROCEDURE (this: _Report) PUTPainting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 241, p1) END PUTPainting; PROCEDURE (this: _Report) PrtMip* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 189) END PrtMip; PROCEDURE (this: _Report) PUTPrtMip* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 189, p1) END PUTPrtMip; PROCEDURE (this: _Report) PrtDevMode* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 190) END PrtDevMode; PROCEDURE (this: _Report) PUTPrtDevMode* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 190, p1) END PUTPrtDevMode; PROCEDURE (this: _Report) PrtDevNames* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 191) END PrtDevNames; PROCEDURE (this: _Report) PUTPrtDevNames* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 191, p1) END PUTPrtDevNames; PROCEDURE (this: _Report) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 204) END ForeColor; PROCEDURE (this: _Report) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 204, p1) END PUTForeColor; PROCEDURE (this: _Report) CurrentX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 205) END CurrentX; PROCEDURE (this: _Report) PUTCurrentX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 205, p1) END PUTCurrentX; PROCEDURE (this: _Report) CurrentY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 206) END CurrentY; PROCEDURE (this: _Report) PUTCurrentY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 206, p1) END PUTCurrentY; PROCEDURE (this: _Report) ScaleHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 207) END ScaleHeight; PROCEDURE (this: _Report) PUTScaleHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 207, p1) END PUTScaleHeight; PROCEDURE (this: _Report) ScaleLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 208) END ScaleLeft; PROCEDURE (this: _Report) PUTScaleLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 208, p1) END PUTScaleLeft; PROCEDURE (this: _Report) ScaleMode* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 209) END ScaleMode; PROCEDURE (this: _Report) PUTScaleMode* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 209, p1) END PUTScaleMode; PROCEDURE (this: _Report) ScaleTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 210) END ScaleTop; PROCEDURE (this: _Report) PUTScaleTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 210, p1) END PUTScaleTop; PROCEDURE (this: _Report) ScaleWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 211) END ScaleWidth; PROCEDURE (this: _Report) PUTScaleWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 211, p1) END PUTScaleWidth; PROCEDURE (this: _Report) FontBold* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 32) END FontBold; PROCEDURE (this: _Report) PUTFontBold* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 32, p1) END PUTFontBold; PROCEDURE (this: _Report) FontItalic* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 33) END FontItalic; PROCEDURE (this: _Report) PUTFontItalic* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 33, p1) END PUTFontItalic; PROCEDURE (this: _Report) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FontName; PROCEDURE (this: _Report) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFontName; PROCEDURE (this: _Report) FontSize* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 35) END FontSize; PROCEDURE (this: _Report) PUTFontSize* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 35, p1) END PUTFontSize; PROCEDURE (this: _Report) FontUnderline* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 36) END FontUnderline; PROCEDURE (this: _Report) PUTFontUnderline* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 36, p1) END PUTFontUnderline; PROCEDURE (this: _Report) DrawMode* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 212) END DrawMode; PROCEDURE (this: _Report) PUTDrawMode* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 212, p1) END PUTDrawMode; PROCEDURE (this: _Report) DrawStyle* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 213) END DrawStyle; PROCEDURE (this: _Report) PUTDrawStyle* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 213, p1) END PUTDrawStyle; PROCEDURE (this: _Report) DrawWidth* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 214) END DrawWidth; PROCEDURE (this: _Report) PUTDrawWidth* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 214, p1) END PUTDrawWidth; PROCEDURE (this: _Report) FillColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 216) END FillColor; PROCEDURE (this: _Report) PUTFillColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 216, p1) END PUTFillColor; PROCEDURE (this: _Report) FillStyle* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 215) END FillStyle; PROCEDURE (this: _Report) PUTFillStyle* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 215, p1) END PUTFillStyle; PROCEDURE (this: _Report) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _Report) PUT_Name* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 20, p1) END PUT_Name; PROCEDURE (this: _Report) PaletteSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 98) END PaletteSource; PROCEDURE (this: _Report) PUTPaletteSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 98, p1) END PUTPaletteSource; PROCEDURE (this: _Report) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _Report) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _Report) PaintPalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END PaintPalette; PROCEDURE (this: _Report) PUTPaintPalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTPaintPalette; PROCEDURE (this: _Report) OnMenu* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 60) END OnMenu; PROCEDURE (this: _Report) PUTOnMenu* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 60, p1) END PUTOnMenu; PROCEDURE (this: _Report) OnOpen* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 77) END OnOpen; PROCEDURE (this: _Report) PUTOnOpen* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 77, p1) END PUTOnOpen; PROCEDURE (this: _Report) OnClose* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 78) END OnClose; PROCEDURE (this: _Report) PUTOnClose* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 78, p1) END PUTOnClose; PROCEDURE (this: _Report) OnActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END OnActivate; PROCEDURE (this: _Report) PUTOnActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 112, p1) END PUTOnActivate; PROCEDURE (this: _Report) OnDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END OnDeactivate; PROCEDURE (this: _Report) PUTOnDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 113, p1) END PUTOnDeactivate; PROCEDURE (this: _Report) OnNoData* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 121) END OnNoData; PROCEDURE (this: _Report) PUTOnNoData* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 121, p1) END PUTOnNoData; PROCEDURE (this: _Report) OnPage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 83) END OnPage; PROCEDURE (this: _Report) PUTOnPage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 83, p1) END PUTOnPage; PROCEDURE (this: _Report) OnError* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 119) END OnError; PROCEDURE (this: _Report) PUTOnError* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 119, p1) END PUTOnError; PROCEDURE (this: _Report) Dirty* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 286) END Dirty; PROCEDURE (this: _Report) PUTDirty* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 286, p1) END PUTDirty; PROCEDURE (this: _Report) CurrentRecord* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 302) END CurrentRecord; PROCEDURE (this: _Report) PUTCurrentRecord* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 302, p1) END PUTCurrentRecord; PROCEDURE (this: _Report) PictureData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 188) END PictureData; PROCEDURE (this: _Report) PUTPictureData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 188, p1) END PUTPictureData; PROCEDURE (this: _Report) PicturePalette* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 311) END PicturePalette; PROCEDURE (this: _Report) PUTPicturePalette* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 311, p1) END PUTPicturePalette; PROCEDURE (this: _Report) HasModule* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 342) END HasModule; PROCEDURE (this: _Report) PUTHasModule* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 342, p1) END PUTHasModule; PROCEDURE (this: _Report) acHiddenCurrentPage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 365) END acHiddenCurrentPage; PROCEDURE (this: _Report) PUTacHiddenCurrentPage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 365, p1) END PUTacHiddenCurrentPage; PROCEDURE (this: _Report) Orientation* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 370) END Orientation; PROCEDURE (this: _Report) PUTOrientation* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 370, p1) END PUTOrientation; PROCEDURE (this: _Report) InputParameters* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END InputParameters; PROCEDURE (this: _Report) PUTInputParameters* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 66, p1) END PUTInputParameters; PROCEDURE (this: _Report) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Report) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Report) ActiveControl* (): Control, NEW; BEGIN RETURN This_Control(CtlC.GetAny(this, 2006)) END ActiveControl; PROCEDURE (this: _Report) DefaultControl* (ControlType: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ControlType, arg[0]); CtlC.CallGetMethod(this, 2150, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END DefaultControl; PROCEDURE (this: _Report) Circle* (flags: SHORTINT; X: SHORTREAL; Y: SHORTREAL; radius: SHORTREAL; color: INTEGER; start: SHORTREAL; end: SHORTREAL; aspect: SHORTREAL), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.SIntVar(flags, arg[7]); CtlC.SRealVar(X, arg[6]); CtlC.SRealVar(Y, arg[5]); CtlC.SRealVar(radius, arg[4]); CtlC.IntVar(color, arg[3]); CtlC.SRealVar(start, arg[2]); CtlC.SRealVar(end, arg[1]); CtlC.SRealVar(aspect, arg[0]); CtlC.CallParMethod(this, 2118, arg, NIL); END Circle; PROCEDURE (this: _Report) Line* (flags: SHORTINT; x1: SHORTREAL; y1: SHORTREAL; x2: SHORTREAL; y2: SHORTREAL; color: INTEGER), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.SIntVar(flags, arg[5]); CtlC.SRealVar(x1, arg[4]); CtlC.SRealVar(y1, arg[3]); CtlC.SRealVar(x2, arg[2]); CtlC.SRealVar(y2, arg[1]); CtlC.IntVar(color, arg[0]); CtlC.CallParMethod(this, 2152, arg, NIL); END Line; PROCEDURE (this: _Report) PSet* (flags: SHORTINT; X: SHORTREAL; Y: SHORTREAL; color: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.SIntVar(flags, arg[3]); CtlC.SRealVar(X, arg[2]); CtlC.SRealVar(Y, arg[1]); CtlC.IntVar(color, arg[0]); CtlC.CallParMethod(this, 2117, arg, NIL); END PSet; PROCEDURE (this: _Report) Scale* (flags: SHORTINT; x1: SHORTREAL; y1: SHORTREAL; x2: SHORTREAL; y2: SHORTREAL), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.SIntVar(flags, arg[4]); CtlC.SRealVar(x1, arg[3]); CtlC.SRealVar(y1, arg[2]); CtlC.SRealVar(x2, arg[1]); CtlC.SRealVar(y2, arg[0]); CtlC.CallParMethod(this, 2116, arg, NIL); END Scale; PROCEDURE (this: _Report) TextWidth* (Expr: ARRAY OF CHAR): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[0]); CtlC.CallParMethod(this, 2114, arg, ret); RETURN CtlC.VarSReal(ret) END TextWidth; PROCEDURE (this: _Report) TextHeight* (Expr: ARRAY OF CHAR): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[0]); CtlC.CallParMethod(this, 2115, arg, ret); RETURN CtlC.VarSReal(ret) END TextHeight; PROCEDURE (this: _Report) Print* (Expr: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[0]); CtlC.CallParMethod(this, 2153, arg, NIL); END Print; PROCEDURE (this: _Report) Section* (Index: CtlT.Any): Section, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 2088, arg, ret); RETURN This_Section(CtlC.VarAny(ret)) END Section; PROCEDURE (this: _Report) GroupLevel* (Index: INTEGER): GroupLevel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 2098, arg, ret); RETURN This_GroupLevel(CtlC.VarAny(ret)) END GroupLevel; PROCEDURE (this: _Report) Report* (): Report, NEW; BEGIN RETURN This_Report(CtlC.GetAny(this, 2097)) END Report; PROCEDURE (this: _Report) Module* (): Module, NEW; BEGIN RETURN ThisModule(CtlC.GetAny(this, 2090)) END Module; PROCEDURE (this: _Report) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _Report) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: _Report) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Report) _Evaluate* (bstrExpr: ARRAY OF CHAR; (* optional *) ppsa: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrExpr, arg[1]); CtlC.AnyVar(ppsa, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Report) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _Report) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; (* ---------- Reports, dual ---------- *) PROCEDURE (this: Reports) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Reports) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Reports) Item* (Index: CtlT.Any): Report, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Report(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Reports) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: Reports) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Screen, dual, nonextensible ---------- *) PROCEDURE (this: Screen) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: Screen) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: Screen) ActiveDatasheet* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2146)) END ActiveDatasheet; PROCEDURE (this: Screen) ActiveControl* (): Control, NEW; BEGIN RETURN This_Control(CtlC.GetAny(this, 2006)) END ActiveControl; PROCEDURE (this: Screen) PreviousControl* (): Control, NEW; BEGIN RETURN This_Control(CtlC.GetAny(this, 2007)) END PreviousControl; PROCEDURE (this: Screen) ActiveForm* (): Form, NEW; BEGIN RETURN This_Form(CtlC.GetAny(this, 2008)) END ActiveForm; PROCEDURE (this: Screen) ActiveReport* (): Report, NEW; BEGIN RETURN This_Report(CtlC.GetAny(this, 2009)) END ActiveReport; PROCEDURE (this: Screen) MousePointer* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 2106) END MousePointer; PROCEDURE (this: Screen) PUTMousePointer* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 2106, p1) END PUTMousePointer; PROCEDURE (this: Screen) ActiveDataAccessPage* (): DataAccessPage, NEW; BEGIN RETURN This_DataAccessPage(CtlC.GetAny(this, 2214)) END ActiveDataAccessPage; (* ---------- _Application, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Application) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _Application) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _Application) CodeContextObject* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2082) END CodeContextObject; PROCEDURE (this: _Application) NewCurrentDatabase* (filepath: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(filepath, arg[0]); CtlC.CallParMethod(this, 2142, arg, NIL); END NewCurrentDatabase; PROCEDURE (this: _Application) OpenCurrentDatabase* (filepath: ARRAY OF CHAR; Exclusive: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(filepath, arg[1]); CtlC.BoolVar(Exclusive, arg[0]); CtlC.CallParMethod(this, 2140, arg, NIL); END OpenCurrentDatabase; PROCEDURE (this: _Application) MenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2010) END MenuBar; PROCEDURE (this: _Application) PUTMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2010, p1) END PUTMenuBar; PROCEDURE (this: _Application) CurrentObjectType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END CurrentObjectType; PROCEDURE (this: _Application) CurrentObjectName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2012) END CurrentObjectName; PROCEDURE (this: _Application) GetOption* (OptionName: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(OptionName, arg[0]); CtlC.CallParMethod(this, 2013, arg, ret); RETURN CtlC.VarAny(ret) END GetOption; PROCEDURE (this: _Application) SetOption* (OptionName: ARRAY OF CHAR; Setting: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(OptionName, arg[1]); CtlC.AnyVar(Setting, arg[0]); CtlC.CallParMethod(this, 2014, arg, NIL); END SetOption; PROCEDURE (this: _Application) Echo* (EchoOn: SHORTINT; bstrStatusBarText: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SIntVar(EchoOn, arg[1]); CtlC.StrVar(bstrStatusBarText, arg[0]); CtlC.CallParMethod(this, 2015, arg, NIL); END Echo; PROCEDURE (this: _Application) CloseCurrentDatabase* (), NEW; BEGIN CtlC.CallMethod(this, 2141, NIL); END CloseCurrentDatabase; PROCEDURE (this: _Application) Quit* (Option: AcQuitOption), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Option, arg[0]); CtlC.CallParMethod(this, 2016, arg, NIL); END Quit; PROCEDURE (this: _Application) Forms* (): Forms, NEW; BEGIN RETURN ThisForms(CtlC.GetAny(this, 2002)) END Forms; PROCEDURE (this: _Application) Reports* (): Reports, NEW; BEGIN RETURN ThisReports(CtlC.GetAny(this, 2003)) END Reports; PROCEDURE (this: _Application) Screen* (): Screen, NEW; BEGIN RETURN ThisScreen(CtlC.GetAny(this, 2004)) END Screen; PROCEDURE (this: _Application) DoCmd* (): DoCmd, NEW; BEGIN RETURN ThisDoCmd(CtlC.GetAny(this, 2025)) END DoCmd; PROCEDURE (this: _Application) ShortcutMenuBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2107) END ShortcutMenuBar; PROCEDURE (this: _Application) PUTShortcutMenuBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2107, p1) END PUTShortcutMenuBar; PROCEDURE (this: _Application) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2148) END Visible; PROCEDURE (this: _Application) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2148, p1) END PUTVisible; PROCEDURE (this: _Application) UserControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2149) END UserControl; PROCEDURE (this: _Application) PUTUserControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2149, p1) END PUTUserControl; PROCEDURE (this: _Application) SysCmd* (Action: AcSysCmdAction; (* optional *) Argument2: CtlT.Any; Argument3: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Action, arg[2]); CtlC.AnyVar(Argument2, arg[1]); CtlC.AnyVar(Argument3, arg[0]); CtlC.CallParMethod(this, 2028, arg, ret); RETURN CtlC.VarAny(ret) END SysCmd; PROCEDURE (this: _Application) CreateForm* ((* optional *) Database: CtlT.Any; FormTemplate: CtlT.Any): Form, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Database, arg[1]); CtlC.AnyVar(FormTemplate, arg[0]); CtlC.CallParMethod(this, 2029, arg, ret); RETURN This_Form(CtlC.VarAny(ret)) END CreateForm; PROCEDURE (this: _Application) CreateReport* ((* optional *) Database: CtlT.Any; ReportTemplate: CtlT.Any): Report, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Database, arg[1]); CtlC.AnyVar(ReportTemplate, arg[0]); CtlC.CallParMethod(this, 2030, arg, ret); RETURN This_Report(CtlC.VarAny(ret)) END CreateReport; PROCEDURE (this: _Application) CreateControl* (FormName: ARRAY OF CHAR; ControlType: AcControlType; Section: AcSection; (* optional *) Parent: CtlT.Any; ColumnName: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any): Control, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FormName, arg[8]); CtlC.IntVar(ControlType, arg[7]); CtlC.IntVar(Section, arg[6]); CtlC.AnyVar(Parent, arg[5]); CtlC.AnyVar(ColumnName, arg[4]); CtlC.AnyVar(Left, arg[3]); CtlC.AnyVar(Top, arg[2]); CtlC.AnyVar(Width, arg[1]); CtlC.AnyVar(Height, arg[0]); CtlC.CallParMethod(this, 2031, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END CreateControl; PROCEDURE (this: _Application) CreateReportControl* (ReportName: ARRAY OF CHAR; ControlType: AcControlType; Section: AcSection; (* optional *) Parent: CtlT.Any; ColumnName: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any): Control, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ReportName, arg[8]); CtlC.IntVar(ControlType, arg[7]); CtlC.IntVar(Section, arg[6]); CtlC.AnyVar(Parent, arg[5]); CtlC.AnyVar(ColumnName, arg[4]); CtlC.AnyVar(Left, arg[3]); CtlC.AnyVar(Top, arg[2]); CtlC.AnyVar(Width, arg[1]); CtlC.AnyVar(Height, arg[0]); CtlC.CallParMethod(this, 2032, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END CreateReportControl; PROCEDURE (this: _Application) CreateControlEx* (FormName: ARRAY OF CHAR; ControlType: AcControlType; Section: AcSection; Parent: ARRAY OF CHAR; ControlSource: ARRAY OF CHAR; Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER): Control, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FormName, arg[8]); CtlC.IntVar(ControlType, arg[7]); CtlC.IntVar(Section, arg[6]); CtlC.StrVar(Parent, arg[5]); CtlC.StrVar(ControlSource, arg[4]); CtlC.IntVar(Left, arg[3]); CtlC.IntVar(Top, arg[2]); CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 2164, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END CreateControlEx; PROCEDURE (this: _Application) CreateReportControlEx* (ReportName: ARRAY OF CHAR; ControlType: AcControlType; Section: AcSection; Parent: ARRAY OF CHAR; ControlName: ARRAY OF CHAR; Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER): Control, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ReportName, arg[8]); CtlC.IntVar(ControlType, arg[7]); CtlC.IntVar(Section, arg[6]); CtlC.StrVar(Parent, arg[5]); CtlC.StrVar(ControlName, arg[4]); CtlC.IntVar(Left, arg[3]); CtlC.IntVar(Top, arg[2]); CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 2165, arg, ret); RETURN This_Control(CtlC.VarAny(ret)) END CreateReportControlEx; PROCEDURE (this: _Application) DeleteControl* (FormName: ARRAY OF CHAR; ControlName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(FormName, arg[1]); CtlC.StrVar(ControlName, arg[0]); CtlC.CallParMethod(this, 2033, arg, NIL); END DeleteControl; PROCEDURE (this: _Application) DeleteReportControl* (ReportName: ARRAY OF CHAR; ControlName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(ReportName, arg[1]); CtlC.StrVar(ControlName, arg[0]); CtlC.CallParMethod(this, 2034, arg, NIL); END DeleteReportControl; PROCEDURE (this: _Application) CreateGroupLevel* (ReportName: ARRAY OF CHAR; Expression: ARRAY OF CHAR; Header: SHORTINT; Footer: SHORTINT): INTEGER, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ReportName, arg[3]); CtlC.StrVar(Expression, arg[2]); CtlC.SIntVar(Header, arg[1]); CtlC.SIntVar(Footer, arg[0]); CtlC.CallParMethod(this, 2051, arg, ret); RETURN CtlC.VarInt(ret) END CreateGroupLevel; PROCEDURE (this: _Application) DMin* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2035, arg, ret); RETURN CtlC.VarAny(ret) END DMin; PROCEDURE (this: _Application) DMax* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2036, arg, ret); RETURN CtlC.VarAny(ret) END DMax; PROCEDURE (this: _Application) DSum* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2037, arg, ret); RETURN CtlC.VarAny(ret) END DSum; PROCEDURE (this: _Application) DAvg* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2038, arg, ret); RETURN CtlC.VarAny(ret) END DAvg; PROCEDURE (this: _Application) DLookup* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2039, arg, ret); RETURN CtlC.VarAny(ret) END DLookup; PROCEDURE (this: _Application) DLast* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2040, arg, ret); RETURN CtlC.VarAny(ret) END DLast; PROCEDURE (this: _Application) DVar* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2041, arg, ret); RETURN CtlC.VarAny(ret) END DVar; PROCEDURE (this: _Application) DVarP* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2042, arg, ret); RETURN CtlC.VarAny(ret) END DVarP; PROCEDURE (this: _Application) DStDev* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2043, arg, ret); RETURN CtlC.VarAny(ret) END DStDev; PROCEDURE (this: _Application) DStDevP* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2044, arg, ret); RETURN CtlC.VarAny(ret) END DStDevP; PROCEDURE (this: _Application) DFirst* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2045, arg, ret); RETURN CtlC.VarAny(ret) END DFirst; PROCEDURE (this: _Application) DCount* (Expr: ARRAY OF CHAR; Domain: ARRAY OF CHAR; (* optional *) Criteria: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Expr, arg[2]); CtlC.StrVar(Domain, arg[1]); CtlC.AnyVar(Criteria, arg[0]); CtlC.CallParMethod(this, 2046, arg, ret); RETURN CtlC.VarAny(ret) END DCount; PROCEDURE (this: _Application) Eval* (StringExpr: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(StringExpr, arg[0]); CtlC.CallParMethod(this, 2047, arg, ret); RETURN CtlC.VarAny(ret) END Eval; PROCEDURE (this: _Application) CurrentUser* (): CtlT.Strg, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2048, ret); RETURN CtlC.VarStr(ret) END CurrentUser; PROCEDURE (this: _Application) DDEInitiate* (Application: ARRAY OF CHAR; Topic: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Application, arg[1]); CtlC.StrVar(Topic, arg[0]); CtlC.CallParMethod(this, 2052, arg, ret); RETURN CtlC.VarAny(ret) END DDEInitiate; PROCEDURE (this: _Application) DDEExecute* (ChanNum: CtlT.Any; Command: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(ChanNum, arg[1]); CtlC.StrVar(Command, arg[0]); CtlC.CallParMethod(this, 2053, arg, NIL); END DDEExecute; PROCEDURE (this: _Application) DDEPoke* (ChanNum: CtlT.Any; Item: ARRAY OF CHAR; Data: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(ChanNum, arg[2]); CtlC.StrVar(Item, arg[1]); CtlC.StrVar(Data, arg[0]); CtlC.CallParMethod(this, 2054, arg, NIL); END DDEPoke; PROCEDURE (this: _Application) DDERequest* (ChanNum: CtlT.Any; Item: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ChanNum, arg[1]); CtlC.StrVar(Item, arg[0]); CtlC.CallParMethod(this, 2055, arg, ret); RETURN CtlC.VarStr(ret) END DDERequest; PROCEDURE (this: _Application) DDETerminate* (ChanNum: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ChanNum, arg[0]); CtlC.CallParMethod(this, 2056, arg, NIL); END DDETerminate; PROCEDURE (this: _Application) DDETerminateAll* (), NEW; BEGIN CtlC.CallMethod(this, 2057, NIL); END DDETerminateAll; PROCEDURE (this: _Application) DBEngine* (): CtlDAO.DBEngine, NEW; BEGIN RETURN CtlDAO.This_DBEngine(CtlC.GetAny(this, 2110)) END DBEngine; PROCEDURE (this: _Application) CurrentDb* (): CtlDAO.Database, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2049, ret); RETURN CtlDAO.ThisDatabase(CtlC.VarAny(ret)) END CurrentDb; PROCEDURE (this: _Application) CodeDb* (): CtlDAO.Database, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2050, ret); RETURN CtlDAO.ThisDatabase(CtlC.VarAny(ret)) END CodeDb; PROCEDURE (this: _Application) BeginUndoable* (Hwnd: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Hwnd, arg[0]); CtlC.CallParMethod(this, 2099, arg, NIL); END BeginUndoable; PROCEDURE (this: _Application) SetUndoRecording* (yesno: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(yesno, arg[0]); CtlC.CallParMethod(this, 2100, arg, NIL); END SetUndoRecording; PROCEDURE (this: _Application) BuildCriteria* (Field: ARRAY OF CHAR; FieldType: SHORTINT; Expression: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Field, arg[2]); CtlC.SIntVar(FieldType, arg[1]); CtlC.StrVar(Expression, arg[0]); CtlC.CallParMethod(this, 2138, arg, ret); RETURN CtlC.VarStr(ret) END BuildCriteria; PROCEDURE (this: _Application) InsertText* (Text: ARRAY OF CHAR; ModuleName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.StrVar(ModuleName, arg[0]); CtlC.CallParMethod(this, 2093, arg, NIL); END InsertText; PROCEDURE (this: _Application) ReloadAddIns* (), NEW; BEGIN CtlC.CallMethod(this, 2154, NIL); END ReloadAddIns; PROCEDURE (this: _Application) DefaultWorkspaceClone* (): CtlDAO.Workspace, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2157, ret); RETURN CtlDAO.ThisWorkspace(CtlC.VarAny(ret)) END DefaultWorkspaceClone; PROCEDURE (this: _Application) RefreshTitleBar* (), NEW; BEGIN CtlC.CallMethod(this, 2158, NIL); END RefreshTitleBar; PROCEDURE (this: _Application) AddAutoCorrect* (ChangeFrom: ARRAY OF CHAR; ChangeTo: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(ChangeFrom, arg[1]); CtlC.StrVar(ChangeTo, arg[0]); CtlC.CallParMethod(this, 2159, arg, NIL); END AddAutoCorrect; PROCEDURE (this: _Application) DelAutoCorrect* (ChangeFrom: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(ChangeFrom, arg[0]); CtlC.CallParMethod(this, 2160, arg, NIL); END DelAutoCorrect; PROCEDURE (this: _Application) hWndAccessApp* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2163, ret); RETURN CtlC.VarInt(ret) END hWndAccessApp; PROCEDURE (this: _Application) Run* (Procedure: ARRAY OF CHAR; (* optional *) Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Procedure, arg[30]); CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 2134, arg, ret); RETURN CtlC.VarAny(ret) END Run; PROCEDURE (this: _Application) Nz* (Value: CtlT.Any; (* optional *) ValueIfNull: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(ValueIfNull, arg[0]); CtlC.CallParMethod(this, 2135, arg, ret); RETURN CtlC.VarAny(ret) END Nz; PROCEDURE (this: _Application) LoadPicture* (FileName: ARRAY OF CHAR): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2166, arg, ret); RETURN CtlC.VarObj(ret) END LoadPicture; PROCEDURE (this: _Application) ReplaceModule* (objtyp: INTEGER; ModuleName: ARRAY OF CHAR; FileName: ARRAY OF CHAR; token: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(objtyp, arg[3]); CtlC.StrVar(ModuleName, arg[2]); CtlC.StrVar(FileName, arg[1]); CtlC.IntVar(token, arg[0]); CtlC.CallParMethod(this, 2168, arg, NIL); END ReplaceModule; PROCEDURE (this: _Application) AccessError* (ErrorNumber: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ErrorNumber, arg[0]); CtlC.CallParMethod(this, 2169, arg, ret); RETURN CtlC.VarAny(ret) END AccessError; PROCEDURE (this: _Application) BuilderString* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2170, ret); RETURN CtlC.VarAny(ret) END BuilderString; PROCEDURE (this: _Application) StringFromGUID* (Guid: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Guid, arg[0]); CtlC.CallParMethod(this, 2171, arg, ret); RETURN CtlC.VarAny(ret) END StringFromGUID; PROCEDURE (this: _Application) GUIDFromString* (String: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(String, arg[0]); CtlC.CallParMethod(this, 2172, arg, ret); RETURN CtlC.VarAny(ret) END GUIDFromString; PROCEDURE (this: _Application) AppLoadString* (id: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(id, arg[0]); CtlC.CallParMethod(this, 2173, arg, ret); RETURN CtlC.VarAny(ret) END AppLoadString; PROCEDURE (this: _Application) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 2174)) END CommandBars; PROCEDURE (this: _Application) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 2175)) END Assistant; PROCEDURE (this: _Application) FollowHyperlink* (Address: ARRAY OF CHAR; SubAddress: ARRAY OF CHAR; NewWindow: BOOLEAN; AddHistory: BOOLEAN; ExtraInfo: CtlT.Any; Method: CtlOffice.MsoExtraInfoMethod; HeaderInfo: ARRAY OF CHAR), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.StrVar(Address, arg[6]); CtlC.StrVar(SubAddress, arg[5]); CtlC.BoolVar(NewWindow, arg[4]); CtlC.BoolVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.IntVar(Method, arg[1]); CtlC.StrVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 2176, arg, NIL); END FollowHyperlink; PROCEDURE (this: _Application) SaveAsText* (ObjectType: AcObjectType; ObjectName: ARRAY OF CHAR; FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[2]); CtlC.StrVar(ObjectName, arg[1]); CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2178, arg, NIL); END SaveAsText; PROCEDURE (this: _Application) LoadFromText* (ObjectType: AcObjectType; ObjectName: ARRAY OF CHAR; FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[2]); CtlC.StrVar(ObjectName, arg[1]); CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2179, arg, NIL); END LoadFromText; PROCEDURE (this: _Application) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 2184, NIL); END AddToFavorites; PROCEDURE (this: _Application) RefreshDatabaseWindow* (), NEW; BEGIN CtlC.CallMethod(this, 2186, NIL); END RefreshDatabaseWindow; PROCEDURE (this: _Application) References* (): References, NEW; BEGIN RETURN This_References(CtlC.GetAny(this, 2187)) END References; PROCEDURE (this: _Application) Modules* (): Modules, NEW; BEGIN RETURN ThisModules(CtlC.GetAny(this, 2188)) END Modules; PROCEDURE (this: _Application) FileSearch* (): CtlOffice.FileSearch, NEW; BEGIN RETURN CtlOffice.ThisFileSearch(CtlC.GetAny(this, 2189)) END FileSearch; PROCEDURE (this: _Application) IsCompiled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2193) END IsCompiled; PROCEDURE (this: _Application) RunCommand* (Command: AcCommand), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Command, arg[0]); CtlC.CallParMethod(this, 2194, arg, NIL); END RunCommand; PROCEDURE (this: _Application) HyperlinkPart* (Hyperlink: CtlT.Any; Part: AcHyperlinkPart): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Hyperlink, arg[1]); CtlC.IntVar(Part, arg[0]); CtlC.CallParMethod(this, 2195, arg, ret); RETURN CtlC.VarStr(ret) END HyperlinkPart; PROCEDURE (this: _Application) GetHiddenAttribute* (ObjectType: AcObjectType; ObjectName: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[1]); CtlC.StrVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 2197, arg, ret); RETURN CtlC.VarBool(ret) END GetHiddenAttribute; PROCEDURE (this: _Application) SetHiddenAttribute* (ObjectType: AcObjectType; ObjectName: ARRAY OF CHAR; fHidden: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(ObjectType, arg[2]); CtlC.StrVar(ObjectName, arg[1]); CtlC.BoolVar(fHidden, arg[0]); CtlC.CallParMethod(this, 2198, arg, NIL); END SetHiddenAttribute; PROCEDURE (this: _Application) VBE* (): CtlVBIDE.VBE, NEW; BEGIN RETURN CtlVBIDE.ThisVBE(CtlC.GetAny(this, 2210)) END VBE; PROCEDURE (this: _Application) DataAccessPages* (): DataAccessPages, NEW; BEGIN RETURN ThisDataAccessPages(CtlC.GetAny(this, 2212)) END DataAccessPages; PROCEDURE (this: _Application) CreateDataAccessPage* (FileName: CtlT.Any; CreateNewFile: BOOLEAN): DataAccessPage, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[1]); CtlC.BoolVar(CreateNewFile, arg[0]); CtlC.CallParMethod(this, 2213, arg, ret); RETURN This_DataAccessPage(CtlC.VarAny(ret)) END CreateDataAccessPage; PROCEDURE (this: _Application) ADOConnectString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2233) END ADOConnectString; PROCEDURE (this: _Application) CurrentProject* (): CurrentProject, NEW; BEGIN RETURN This_CurrentProject(CtlC.GetAny(this, 2215)) END CurrentProject; PROCEDURE (this: _Application) CurrentData* (): CurrentData, NEW; BEGIN RETURN This_CurrentData(CtlC.GetAny(this, 2216)) END CurrentData; PROCEDURE (this: _Application) CodeProject* (): CodeProject, NEW; BEGIN RETURN This_CurrentProject(CtlC.GetAny(this, 2217)) END CodeProject; PROCEDURE (this: _Application) CodeData* (): CodeData, NEW; BEGIN RETURN This_CurrentData(CtlC.GetAny(this, 2218)) END CodeData; PROCEDURE (this: _Application) NewAccessProject* (filepath: ARRAY OF CHAR; (* optional *) Connect: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(filepath, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 2262, arg, NIL); END NewAccessProject; PROCEDURE (this: _Application) OpenAccessProject* (filepath: ARRAY OF CHAR; Exclusive: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(filepath, arg[1]); CtlC.BoolVar(Exclusive, arg[0]); CtlC.CallParMethod(this, 2263, arg, NIL); END OpenAccessProject; PROCEDURE (this: _Application) CreateAccessProject* (filepath: ARRAY OF CHAR; (* optional *) Connect: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(filepath, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 2264, arg, NIL); END CreateAccessProject; PROCEDURE (this: _Application) WizHook* (): WizHook, NEW; BEGIN RETURN This_WizHook(CtlC.GetAny(this, 2235)) END WizHook; PROCEDURE (this: _Application) ProductCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2266) END ProductCode; PROCEDURE (this: _Application) COMAddIns* (): CtlOffice.COMAddIns, NEW; BEGIN RETURN CtlOffice.ThisCOMAddIns(CtlC.GetAny(this, 2277)) END COMAddIns; PROCEDURE (this: _Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2094) END Name; PROCEDURE (this: _Application) DefaultWebOptions* (): DefaultWebOptions, NEW; BEGIN RETURN This_DefaultWebOptions(CtlC.GetAny(this, 2278)) END DefaultWebOptions; PROCEDURE (this: _Application) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 2301)) END LanguageSettings; PROCEDURE (this: _Application) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 2304)) END AnswerWizard; PROCEDURE (this: _Application) FeatureInstall* (): CtlOffice.MsoFeatureInstall, NEW; BEGIN RETURN CtlC.GetInt(this, 2322) END FeatureInstall; PROCEDURE (this: _Application) PUTFeatureInstall* (p1: CtlOffice.MsoFeatureInstall), NEW; BEGIN CtlC.PutInt(this, 2322, p1) END PUTFeatureInstall; PROCEDURE (this: _Application) EuroConvert* (Number: REAL; SourceCurrency: ARRAY OF CHAR; TargetCurrency: ARRAY OF CHAR; (* optional *) FullPrecision: CtlT.Any; TriangulationPrecision: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Number, arg[4]); CtlC.StrVar(SourceCurrency, arg[3]); CtlC.StrVar(TargetCurrency, arg[2]); CtlC.AnyVar(FullPrecision, arg[1]); CtlC.AnyVar(TriangulationPrecision, arg[0]); CtlC.CallParMethod(this, 2325, arg, ret); RETURN CtlC.VarReal(ret) END EuroConvert; PROCEDURE (this: _Application) VGXFrameInterval* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2326) END VGXFrameInterval; (* ---------- Reference, dual, nonextensible ---------- *) PROCEDURE (this: Reference) Collection* (): References, NEW; BEGIN RETURN This_References(CtlC.GetAny(this, 1610743808)) END Collection; PROCEDURE (this: Reference) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Name; PROCEDURE (this: Reference) Guid* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743810) END Guid; PROCEDURE (this: Reference) Major* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Major; PROCEDURE (this: Reference) Minor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743812) END Minor; PROCEDURE (this: Reference) FullPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743813) END FullPath; PROCEDURE (this: Reference) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743814) END BuiltIn; PROCEDURE (this: Reference) IsBroken* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743815) END IsBroken; PROCEDURE (this: Reference) Kind* (): CtlVBIDE.vbext_RefKind, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743816) END Kind; (* ---------- _References, dual, nonextensible ---------- *) PROCEDURE (this: _References) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Parent; PROCEDURE (this: _References) Item* (var: CtlT.Any): Reference, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(var, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _References) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743810) END Count; PROCEDURE (this: _References) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _References) AddFromGuid* (Guid: ARRAY OF CHAR; Major: INTEGER; Minor: INTEGER): Reference, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Guid, arg[2]); CtlC.IntVar(Major, arg[1]); CtlC.IntVar(Minor, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END AddFromGuid; PROCEDURE (this: _References) AddFromFile* (FileName: ARRAY OF CHAR): Reference, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743813, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END AddFromFile; PROCEDURE (this: _References) Remove* (reference: Reference), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(reference, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, NIL); END Remove; (* ---------- _References_Events, hidden, nonextensible ---------- *) PROCEDURE (this: _References_Events) ItemAdded* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _References_Events) ItemRemoved* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _References_Events) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 0: ASSERT(n = 1, 11); this.ItemAdded(ThisReference(CtlC.VarAny(par[0]))) | 1: ASSERT(n = 1, 11); this.ItemRemoved(ThisReference(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: _References_Events) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{F163F201-ADA2-11CF-89A9-00A0C9054129}" END GetIID; (* ---------- _Dummy, hidden, dual, nonextensible ---------- *) (* ---------- _DataAccessPage, hidden, dual ---------- *) PROCEDURE (this: _DataAccessPage) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: _DataAccessPage) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _DataAccessPage) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 148) END Visible; PROCEDURE (this: _DataAccessPage) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 148, p1) END PUTVisible; PROCEDURE (this: _DataAccessPage) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 266) END Tag; PROCEDURE (this: _DataAccessPage) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 266, p1) END PUTTag; PROCEDURE (this: _DataAccessPage) WindowWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 287) END WindowWidth; PROCEDURE (this: _DataAccessPage) WindowHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 288) END WindowHeight; PROCEDURE (this: _DataAccessPage) CurrentView* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 289) END CurrentView; PROCEDURE (this: _DataAccessPage) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _DataAccessPage) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _DataAccessPage) Document* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 0) END Document; PROCEDURE (this: _DataAccessPage) ApplyTheme* (ThemeName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(ThemeName, arg[0]); CtlC.CallParMethod(this, 2258, arg, NIL); END ApplyTheme; PROCEDURE (this: _DataAccessPage) WebOptions* (): WebOptions, NEW; BEGIN RETURN This_WebOptions(CtlC.GetAny(this, 2293)) END WebOptions; PROCEDURE (this: _DataAccessPage) ConnectionString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2268) END ConnectionString; PROCEDURE (this: _DataAccessPage) PUTConnectionString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2268, p1) END PUTConnectionString; PROCEDURE (this: _DataAccessPage) FieldListConnection* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2298) END FieldListConnection; (* ---------- DataAccessPages, dual ---------- *) PROCEDURE (this: DataAccessPages) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: DataAccessPages) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: DataAccessPages) Item* (var: CtlT.Any): DataAccessPage, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(var, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_DataAccessPage(CtlC.VarAny(ret)) END Item; PROCEDURE (this: DataAccessPages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: DataAccessPages) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- AllObjects, dual ---------- *) PROCEDURE (this: AllObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: AllObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: AllObjects) Item* (var: CtlT.Any): AccessObject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(var, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisAccessObject(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AllObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: AllObjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- AccessObjectProperty, dual, nonextensible ---------- *) PROCEDURE (this: AccessObjectProperty) _Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2103) END _Value; PROCEDURE (this: AccessObjectProperty) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: AccessObjectProperty) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: AccessObjectProperty) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; (* ---------- AccessObjectProperties, dual, nonextensible ---------- *) PROCEDURE (this: AccessObjectProperties) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: AccessObjectProperties) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: AccessObjectProperties) Item* (Index: CtlT.Any): AccessObjectProperty, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisAccessObjectProperty(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AccessObjectProperties) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Count; PROCEDURE (this: AccessObjectProperties) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: AccessObjectProperties) Add* (PropertyName: ARRAY OF CHAR; Value: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(PropertyName, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 2191, arg, NIL); END Add; PROCEDURE (this: AccessObjectProperties) Remove* (Item: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallParMethod(this, 2192, arg, NIL); END Remove; (* ---------- _CurrentProject, hidden, dual ---------- *) PROCEDURE (this: _CurrentProject) AllForms* (): AllForms, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2219)) END AllForms; PROCEDURE (this: _CurrentProject) AllReports* (): AllReports, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2220)) END AllReports; PROCEDURE (this: _CurrentProject) AllMacros* (): AllMacros, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2221)) END AllMacros; PROCEDURE (this: _CurrentProject) AllModules* (): AllModules, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2222)) END AllModules; PROCEDURE (this: _CurrentProject) AllDataAccessPages* (): AllDataAccessPages, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2224)) END AllDataAccessPages; PROCEDURE (this: _CurrentProject) ProjectType* (): AcProjectType, NEW; BEGIN RETURN CtlC.GetInt(this, 2271) END ProjectType; PROCEDURE (this: _CurrentProject) BaseConnectionString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2267) END BaseConnectionString; PROCEDURE (this: _CurrentProject) IsConnected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2269) END IsConnected; PROCEDURE (this: _CurrentProject) OpenConnection* ((* optional *) BaseConnectionString: CtlT.Any; UserID: CtlT.Any; Password: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(BaseConnectionString, arg[2]); CtlC.AnyVar(UserID, arg[1]); CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 2272, arg, NIL); END OpenConnection; PROCEDURE (this: _CurrentProject) CloseConnection* (), NEW; BEGIN CtlC.CallMethod(this, 2270, NIL); END CloseConnection; PROCEDURE (this: _CurrentProject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2094) END Name; PROCEDURE (this: _CurrentProject) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2275) END Path; PROCEDURE (this: _CurrentProject) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2260) END FullName; PROCEDURE (this: _CurrentProject) Connection* (): CtlADODB.Connection, NEW; BEGIN RETURN CtlADODB.This_Connection(CtlC.GetAny(this, 2274)) END Connection; PROCEDURE (this: _CurrentProject) Properties* (): AccessObjectProperties, NEW; BEGIN RETURN ThisAccessObjectProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: _CurrentProject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _CurrentProject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; (* ---------- _CurrentData, hidden, dual ---------- *) PROCEDURE (this: _CurrentData) AllTables* (): AllTables, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2225)) END AllTables; PROCEDURE (this: _CurrentData) AllQueries* (): AllQueries, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2226)) END AllQueries; PROCEDURE (this: _CurrentData) AllViews* (): AllViews, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2228)) END AllViews; PROCEDURE (this: _CurrentData) AllStoredProcedures* (): AllStoredProcedures, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2229)) END AllStoredProcedures; PROCEDURE (this: _CurrentData) AllDatabaseDiagrams* (): AllDatabaseDiagrams, NEW; BEGIN RETURN ThisAllObjects(CtlC.GetAny(this, 2230)) END AllDatabaseDiagrams; (* ---------- AccessObject, dual ---------- *) PROCEDURE (this: AccessObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: AccessObject) _Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 20) END _Name; PROCEDURE (this: AccessObject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: AccessObject) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2095) END Type; PROCEDURE (this: AccessObject) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2257) END Attributes; PROCEDURE (this: AccessObject) Properties* (): AccessObjectProperties, NEW; BEGIN RETURN ThisAccessObjectProperties(CtlC.GetAny(this, 2091)) END Properties; PROCEDURE (this: AccessObject) IsLoaded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2276) END IsLoaded; PROCEDURE (this: AccessObject) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2260) END FullName; (* ---------- _WizHook, hidden, dual ---------- *) PROCEDURE (this: _WizHook) PUTKey* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2237, p1) END PUTKey; PROCEDURE (this: _WizHook) NameFromActid* (Actid: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Actid, arg[0]); CtlC.CallParMethod(this, 2234, arg, ret); RETURN CtlC.VarStr(ret) END NameFromActid; PROCEDURE (this: _WizHook) ArgsOfActid* (Actid: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Actid, arg[0]); CtlC.CallParMethod(this, 2236, arg, ret); RETURN CtlC.VarInt(ret) END ArgsOfActid; PROCEDURE (this: _WizHook) OpenScript* (Script: ARRAY OF CHAR; Label: ARRAY OF CHAR; OpenMode: INTEGER; VAR Extra: INTEGER; VAR Version: INTEGER): INTEGER, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Script, arg[4]); CtlC.StrVar(Label, arg[3]); CtlC.IntVar(OpenMode, arg[2]); CtlC.RefIntVar(Extra, arg[1]); CtlC.RefIntVar(Version, arg[0]); CtlC.CallParMethod(this, 2238, arg, ret); RETURN CtlC.VarInt(ret) END OpenScript; PROCEDURE (this: _WizHook) GetScriptString* (HScr: INTEGER; ScriptColumn: INTEGER; VAR Value: CtlT.Strg): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; Value_TEMP: CtlT.Variant; BEGIN CtlC.IntVar(HScr, arg[2]); CtlC.IntVar(ScriptColumn, arg[1]); CtlC.StrVar(Value, Value_TEMP); CtlC.RefStrVar(Value_TEMP, arg[0]); CtlC.CallParMethod(this, 2239, arg, ret); Value := CtlC.VarStr(Value_TEMP); RETURN CtlC.VarBool(ret) END GetScriptString; PROCEDURE (this: _WizHook) SaveScriptString* (HScr: INTEGER; ScriptColumn: INTEGER; Value: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(HScr, arg[2]); CtlC.IntVar(ScriptColumn, arg[1]); CtlC.StrVar(Value, arg[0]); CtlC.CallParMethod(this, 2240, arg, ret); RETURN CtlC.VarBool(ret) END SaveScriptString; PROCEDURE (this: _WizHook) GlobalProcExists* (Name: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 2241, arg, ret); RETURN CtlC.VarBool(ret) END GlobalProcExists; PROCEDURE (this: _WizHook) TableFieldHasUniqueIndex* (Table: ARRAY OF CHAR; Columns: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Table, arg[1]); CtlC.StrVar(Columns, arg[0]); CtlC.CallParMethod(this, 2242, arg, ret); RETURN CtlC.VarBool(ret) END TableFieldHasUniqueIndex; PROCEDURE (this: _WizHook) BracketString* (VAR String: CtlT.Strg; flags: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; String_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(String, String_TEMP); CtlC.RefStrVar(String_TEMP, arg[1]); CtlC.IntVar(flags, arg[0]); CtlC.CallParMethod(this, 2243, arg, ret); String := CtlC.VarStr(String_TEMP); RETURN CtlC.VarBool(ret) END BracketString; PROCEDURE (this: _WizHook) WizHelp* (HelpFile: ARRAY OF CHAR; wCmd: INTEGER; ContextID: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(HelpFile, arg[2]); CtlC.IntVar(wCmd, arg[1]); CtlC.IntVar(ContextID, arg[0]); CtlC.CallParMethod(this, 2244, arg, ret); RETURN CtlC.VarBool(ret) END WizHelp; PROCEDURE (this: _WizHook) OpenPictureFile* (VAR File: CtlT.Strg; VAR Cancelled: BOOLEAN): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; File_TEMP: CtlT.Variant; Cancelled_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(File, File_TEMP); CtlC.RefStrVar(File_TEMP, arg[1]); CtlC.BoolVar(Cancelled, Cancelled_TEMP); CtlC.RefBoolVar(Cancelled_TEMP, arg[0]); CtlC.CallParMethod(this, 2245, arg, ret); File := CtlC.VarStr(File_TEMP); Cancelled := CtlC.VarBool(Cancelled_TEMP); RETURN CtlC.VarBool(ret) END OpenPictureFile; PROCEDURE (this: _WizHook) EnglishPictToLocal* (In: ARRAY OF CHAR; VAR Out: CtlT.Strg): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; Out_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(In, arg[1]); CtlC.StrVar(Out, Out_TEMP); CtlC.RefStrVar(Out_TEMP, arg[0]); CtlC.CallParMethod(this, 2246, arg, ret); Out := CtlC.VarStr(Out_TEMP); RETURN CtlC.VarBool(ret) END EnglishPictToLocal; PROCEDURE (this: _WizHook) TranslateExpression* (In: ARRAY OF CHAR; VAR Out: CtlT.Strg; ParseFlags: INTEGER; TranslateFlags: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; Out_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(In, arg[3]); CtlC.StrVar(Out, Out_TEMP); CtlC.RefStrVar(Out_TEMP, arg[2]); CtlC.IntVar(ParseFlags, arg[1]); CtlC.IntVar(TranslateFlags, arg[0]); CtlC.CallParMethod(this, 2247, arg, ret); Out := CtlC.VarStr(Out_TEMP); RETURN CtlC.VarBool(ret) END TranslateExpression; PROCEDURE (this: _WizHook) FileExists* (File: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(File, arg[0]); CtlC.CallParMethod(this, 2248, arg, ret); RETURN CtlC.VarBool(ret) END FileExists; PROCEDURE (this: _WizHook) FullPath* (RelativePath: ARRAY OF CHAR; VAR FullPath: CtlT.Strg): SHORTINT, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; FullPath_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(RelativePath, arg[1]); CtlC.StrVar(FullPath, FullPath_TEMP); CtlC.RefStrVar(FullPath_TEMP, arg[0]); CtlC.CallParMethod(this, 2249, arg, ret); FullPath := CtlC.VarStr(FullPath_TEMP); RETURN CtlC.VarSInt(ret) END FullPath; PROCEDURE (this: _WizHook) SplitPath* (Path: ARRAY OF CHAR; VAR Drive: CtlT.Strg; VAR Dir: CtlT.Strg; VAR File: CtlT.Strg; VAR Ext: CtlT.Strg), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; Drive_TEMP: CtlT.Variant; Dir_TEMP: CtlT.Variant; File_TEMP: CtlT.Variant; Ext_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[4]); CtlC.StrVar(Drive, Drive_TEMP); CtlC.RefStrVar(Drive_TEMP, arg[3]); CtlC.StrVar(Dir, Dir_TEMP); CtlC.RefStrVar(Dir_TEMP, arg[2]); CtlC.StrVar(File, File_TEMP); CtlC.RefStrVar(File_TEMP, arg[1]); CtlC.StrVar(Ext, Ext_TEMP); CtlC.RefStrVar(Ext_TEMP, arg[0]); CtlC.CallParMethod(this, 2250, arg, NIL); Drive := CtlC.VarStr(Drive_TEMP); Dir := CtlC.VarStr(Dir_TEMP); File := CtlC.VarStr(File_TEMP); Ext := CtlC.VarStr(Ext_TEMP); END SplitPath; PROCEDURE (this: _WizHook) TwipsFromFont* (FontName: ARRAY OF CHAR; Size: INTEGER; Weight: INTEGER; Italic: BOOLEAN; Underline: BOOLEAN; Cch: INTEGER; Caption: ARRAY OF CHAR; MaxWidthCch: INTEGER; VAR dx: INTEGER; VAR dy: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 10 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FontName, arg[9]); CtlC.IntVar(Size, arg[8]); CtlC.IntVar(Weight, arg[7]); CtlC.BoolVar(Italic, arg[6]); CtlC.BoolVar(Underline, arg[5]); CtlC.IntVar(Cch, arg[4]); CtlC.StrVar(Caption, arg[3]); CtlC.IntVar(MaxWidthCch, arg[2]); CtlC.RefIntVar(dx, arg[1]); CtlC.RefIntVar(dy, arg[0]); CtlC.CallParMethod(this, 2251, arg, ret); RETURN CtlC.VarBool(ret) END TwipsFromFont; PROCEDURE (this: _WizHook) ObjTypOfRecordSource* (RecordSource: ARRAY OF CHAR): SHORTINT, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(RecordSource, arg[0]); CtlC.CallParMethod(this, 2252, arg, ret); RETURN CtlC.VarSInt(ret) END ObjTypOfRecordSource; PROCEDURE (this: _WizHook) IsValidIdent* (Identifier: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Identifier, arg[0]); CtlC.CallParMethod(this, 2253, arg, ret); RETURN CtlC.VarBool(ret) END IsValidIdent; PROCEDURE (this: _WizHook) SortStringArray* (Array: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Array, arg[0]); CtlC.CallParMethod(this, 2254, arg, NIL); END SortStringArray; PROCEDURE (this: _WizHook) AnalyzeTable* (Workspace: CtlDAO.Workspace; Database: CtlDAO.Database; Table: ARRAY OF CHAR; ReturnDebugInfo: BOOLEAN; VAR Results: CtlT.Strg): INTEGER, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; Results_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Workspace, arg[4]); CtlC.ObjVar(Database, arg[3]); CtlC.StrVar(Table, arg[2]); CtlC.BoolVar(ReturnDebugInfo, arg[1]); CtlC.StrVar(Results, Results_TEMP); CtlC.RefStrVar(Results_TEMP, arg[0]); CtlC.CallParMethod(this, 2255, arg, ret); Results := CtlC.VarStr(Results_TEMP); RETURN CtlC.VarInt(ret) END AnalyzeTable; PROCEDURE (this: _WizHook) AnalyzeQuery* (Workspace: CtlDAO.Workspace; Database: CtlDAO.Database; Query: ARRAY OF CHAR; VAR Results: CtlT.Strg): INTEGER, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; Results_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Workspace, arg[3]); CtlC.ObjVar(Database, arg[2]); CtlC.StrVar(Query, arg[1]); CtlC.StrVar(Results, Results_TEMP); CtlC.RefStrVar(Results_TEMP, arg[0]); CtlC.CallParMethod(this, 2256, arg, ret); Results := CtlC.VarStr(Results_TEMP); RETURN CtlC.VarInt(ret) END AnalyzeQuery; PROCEDURE (this: _WizHook) GetFileName* (hwndOwner: INTEGER; AppName: ARRAY OF CHAR; DlgTitle: ARRAY OF CHAR; OpenTitle: ARRAY OF CHAR; VAR File: CtlT.Strg; InitialDir: ARRAY OF CHAR; Filter: ARRAY OF CHAR; FilterIndex: INTEGER; View: INTEGER; flags: INTEGER; fOpen: BOOLEAN): INTEGER, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; File_TEMP: CtlT.Variant; BEGIN CtlC.IntVar(hwndOwner, arg[10]); CtlC.StrVar(AppName, arg[9]); CtlC.StrVar(DlgTitle, arg[8]); CtlC.StrVar(OpenTitle, arg[7]); CtlC.StrVar(File, File_TEMP); CtlC.RefStrVar(File_TEMP, arg[6]); CtlC.StrVar(InitialDir, arg[5]); CtlC.StrVar(Filter, arg[4]); CtlC.IntVar(FilterIndex, arg[3]); CtlC.IntVar(View, arg[2]); CtlC.IntVar(flags, arg[1]); CtlC.BoolVar(fOpen, arg[0]); CtlC.CallParMethod(this, 2261, arg, ret); File := CtlC.VarStr(File_TEMP); RETURN CtlC.VarInt(ret) END GetFileName; PROCEDURE (this: _WizHook) CreateDataPageControl* (DpName: ARRAY OF CHAR; CtlName: ARRAY OF CHAR; Typ: INTEGER; Section: ARRAY OF CHAR; SectionType: INTEGER; AppletCode: ARRAY OF CHAR; X: INTEGER; Y: INTEGER; dx: INTEGER; dy: INTEGER), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.StrVar(DpName, arg[9]); CtlC.StrVar(CtlName, arg[8]); CtlC.IntVar(Typ, arg[7]); CtlC.StrVar(Section, arg[6]); CtlC.IntVar(SectionType, arg[5]); CtlC.StrVar(AppletCode, arg[4]); CtlC.IntVar(X, arg[3]); CtlC.IntVar(Y, arg[2]); CtlC.IntVar(dx, arg[1]); CtlC.IntVar(dy, arg[0]); CtlC.CallParMethod(this, 2265, arg, NIL); END CreateDataPageControl; PROCEDURE (this: _WizHook) KnownWizLeaks* (fStart: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(fStart, arg[0]); CtlC.CallParMethod(this, 2273, arg, NIL); END KnownWizLeaks; PROCEDURE (this: _WizHook) SetVbaPassword* (bstrDbName: ARRAY OF CHAR; bstrConnect: ARRAY OF CHAR; bstrPasswd: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrDbName, arg[2]); CtlC.StrVar(bstrConnect, arg[1]); CtlC.StrVar(bstrPasswd, arg[0]); CtlC.CallParMethod(this, 2294, arg, ret); RETURN CtlC.VarBool(ret) END SetVbaPassword; PROCEDURE (this: _WizHook) LocalFont* (): CtlT.Strg, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2295, ret); RETURN CtlC.VarStr(ret) END LocalFont; PROCEDURE (this: _WizHook) SaveObject* (bstrName: ARRAY OF CHAR; objtyp: SHORTINT), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrName, arg[1]); CtlC.SIntVar(objtyp, arg[0]); CtlC.CallParMethod(this, 2296, arg, NIL); END SaveObject; PROCEDURE (this: _WizHook) CurrentLangID* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2299, ret); RETURN CtlC.VarInt(ret) END CurrentLangID; PROCEDURE (this: _WizHook) KeyboardLangID* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2300, ret); RETURN CtlC.VarInt(ret) END KeyboardLangID; PROCEDURE (this: _WizHook) AccessUserDataDir* (): CtlT.Strg, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2302, ret); RETURN CtlC.VarStr(ret) END AccessUserDataDir; PROCEDURE (this: _WizHook) OfficeAddInDir* (): CtlT.Strg, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2303, ret); RETURN CtlC.VarStr(ret) END OfficeAddInDir; PROCEDURE (this: _WizHook) EmbedFileOnDataPage* (DpName: ARRAY OF CHAR; FileToInsert: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(DpName, arg[1]); CtlC.StrVar(FileToInsert, arg[0]); CtlC.CallParMethod(this, 2305, arg, ret); RETURN CtlC.VarStr(ret) END EmbedFileOnDataPage; PROCEDURE (this: _WizHook) DbcVbProject* (): CtlVBIDE._VBProject, NEW; BEGIN RETURN CtlVBIDE.This_VBProject(CtlC.GetAny(this, 2306)) END DbcVbProject; PROCEDURE (this: _WizHook) ReportLeaksToFile* (fRptToFile: BOOLEAN; bstrFileOut: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.BoolVar(fRptToFile, arg[1]); CtlC.StrVar(bstrFileOut, arg[0]); CtlC.CallParMethod(this, 2292, arg, NIL); END ReportLeaksToFile; PROCEDURE (this: _WizHook) IsMatchToDbcConnectString* (bstrConnectionString: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrConnectionString, arg[0]); CtlC.CallGetMethod(this, 2291, arg, ret); RETURN CtlC.VarBool(ret) END IsMatchToDbcConnectString; PROCEDURE (this: _WizHook) LoadImexSpecSolution* (bstrFilename: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrFilename, arg[0]); CtlC.CallParMethod(this, 2282, arg, NIL); END LoadImexSpecSolution; PROCEDURE (this: _WizHook) SetDpBlockKeyInput* (fBlockKeys: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(fBlockKeys, arg[0]); CtlC.CallParMethod(this, 2283, arg, NIL); END SetDpBlockKeyInput; PROCEDURE (this: _WizHook) FirstDbcDataObject* (VAR Name: CtlT.Strg; VAR ObjType: AcObjectType; VAR Attribs: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; Name_TEMP: CtlT.Variant; BEGIN CtlC.StrVar(Name, Name_TEMP); CtlC.RefStrVar(Name_TEMP, arg[2]); CtlC.RefIntVar(ObjType, arg[1]); CtlC.RefIntVar(Attribs, arg[0]); CtlC.CallParMethod(this, 2323, arg, ret); Name := CtlC.VarStr(Name_TEMP); RETURN CtlC.VarBool(ret) END FirstDbcDataObject; PROCEDURE (this: _WizHook) CloseCurrentDatabase* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2324, ret); RETURN CtlC.VarBool(ret) END CloseCurrentDatabase; (* ---------- _DefaultWebOptions, hidden, dual ---------- *) PROCEDURE (this: _DefaultWebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _DefaultWebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _DefaultWebOptions) HyperlinkColor* (): AcColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 2279) END HyperlinkColor; PROCEDURE (this: _DefaultWebOptions) PUTHyperlinkColor* (p1: AcColorIndex), NEW; BEGIN CtlC.PutInt(this, 2279, p1) END PUTHyperlinkColor; PROCEDURE (this: _DefaultWebOptions) FollowedHyperlinkColor* (): AcColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 2280) END FollowedHyperlinkColor; PROCEDURE (this: _DefaultWebOptions) PUTFollowedHyperlinkColor* (p1: AcColorIndex), NEW; BEGIN CtlC.PutInt(this, 2280, p1) END PUTFollowedHyperlinkColor; PROCEDURE (this: _DefaultWebOptions) UnderlineHyperlinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2281) END UnderlineHyperlinks; PROCEDURE (this: _DefaultWebOptions) PUTUnderlineHyperlinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2281, p1) END PUTUnderlineHyperlinks; PROCEDURE (this: _DefaultWebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2284) END OrganizeInFolder; PROCEDURE (this: _DefaultWebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2284, p1) END PUTOrganizeInFolder; PROCEDURE (this: _DefaultWebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2285) END UseLongFileNames; PROCEDURE (this: _DefaultWebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2285, p1) END PUTUseLongFileNames; PROCEDURE (this: _DefaultWebOptions) CheckIfOfficeIsHTMLEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2286) END CheckIfOfficeIsHTMLEditor; PROCEDURE (this: _DefaultWebOptions) PUTCheckIfOfficeIsHTMLEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2286, p1) END PUTCheckIfOfficeIsHTMLEditor; PROCEDURE (this: _DefaultWebOptions) DownloadComponents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2287) END DownloadComponents; PROCEDURE (this: _DefaultWebOptions) PUTDownloadComponents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2287, p1) END PUTDownloadComponents; PROCEDURE (this: _DefaultWebOptions) LocationOfComponents* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2288) END LocationOfComponents; PROCEDURE (this: _DefaultWebOptions) PUTLocationOfComponents* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2288, p1) END PUTLocationOfComponents; PROCEDURE (this: _DefaultWebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 2289) END Encoding; PROCEDURE (this: _DefaultWebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 2289, p1) END PUTEncoding; PROCEDURE (this: _DefaultWebOptions) AlwaysSaveInDefaultEncoding* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2290) END AlwaysSaveInDefaultEncoding; PROCEDURE (this: _DefaultWebOptions) PUTAlwaysSaveInDefaultEncoding* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2290, p1) END PUTAlwaysSaveInDefaultEncoding; PROCEDURE (this: _DefaultWebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2307) END FolderSuffix; (* ---------- _WebOptions, hidden, dual ---------- *) PROCEDURE (this: _WebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2005)) END Application; PROCEDURE (this: _WebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2087) END Parent; PROCEDURE (this: _WebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2284) END OrganizeInFolder; PROCEDURE (this: _WebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2284, p1) END PUTOrganizeInFolder; PROCEDURE (this: _WebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2285) END UseLongFileNames; PROCEDURE (this: _WebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2285, p1) END PUTUseLongFileNames; PROCEDURE (this: _WebOptions) DownloadComponents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2287) END DownloadComponents; PROCEDURE (this: _WebOptions) PUTDownloadComponents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2287, p1) END PUTDownloadComponents; PROCEDURE (this: _WebOptions) LocationOfComponents* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2288) END LocationOfComponents; PROCEDURE (this: _WebOptions) PUTLocationOfComponents* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2288, p1) END PUTLocationOfComponents; PROCEDURE (this: _WebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 2289) END Encoding; PROCEDURE (this: _WebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 2289, p1) END PUTEncoding; PROCEDURE (this: _WebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2307) END FolderSuffix; PROCEDURE (this: _WebOptions) UseDefaultFolderSuffix* (), NEW; BEGIN CtlC.CallMethod(this, 2308, NIL); END UseDefaultFolderSuffix; PROCEDURE NewFormatCondition* (): _FormatCondition; BEGIN RETURN This_FormatCondition(CtlC.NewObj("{E27A992D-A330-11D0-81DD-00C04FC2F51B}")) END NewFormatCondition; PROCEDURE NewAccessField* (): _AccessField; BEGIN RETURN This_AccessField(CtlC.NewObj("{044E54C5-B19B-11CE-A689-00AA003F0F07}")) END NewAccessField; PROCEDURE NewHyperlink* (): _Hyperlink; BEGIN RETURN This_Hyperlink(CtlC.NewObj("{50D56610-60AC-11CF-82C9-00AA004B9FE6}")) END NewHyperlink; PROCEDURE NewPage* (): _Page; BEGIN RETURN This_Page(CtlC.NewObj("{3B06E973-E47C-11CD-8701-00AA003F0F07}")) END NewPage; PROCEDURE NewControl* (): _Control; BEGIN RETURN This_Control(CtlC.NewObj("{02F92C80-8F8E-101B-AF4E-00AA003F0F07}")) END NewControl; PROCEDURE New_ControlInReportEvents* (): _Control; BEGIN RETURN This_Control(CtlC.NewObj("{90B322A4-F1D9-11CD-8701-00AA003F0F07}")) END New_ControlInReportEvents; PROCEDURE NewLabel* (): _Label; BEGIN RETURN This_Label(CtlC.NewObj("{3B06E947-E47C-11CD-8701-00AA003F0F07}")) END NewLabel; PROCEDURE New_ChildLabel* (): _Label; BEGIN RETURN This_Label(CtlC.NewObj("{BC9E4359-F037-11CD-8701-00AA003F0F07}")) END New_ChildLabel; PROCEDURE NewRectangle* (): _Rectangle; BEGIN RETURN This_Rectangle(CtlC.NewObj("{3B06E949-E47C-11CD-8701-00AA003F0F07}")) END NewRectangle; PROCEDURE NewLine* (): _Line; BEGIN RETURN This_Line(CtlC.NewObj("{3B06E94B-E47C-11CD-8701-00AA003F0F07}")) END NewLine; PROCEDURE NewImage* (): _Image; BEGIN RETURN This_Image(CtlC.NewObj("{3B06E94D-E47C-11CD-8701-00AA003F0F07}")) END NewImage; PROCEDURE NewCommandButton* (): _CommandButton; BEGIN RETURN This_CommandButton(CtlC.NewObj("{3B06E94F-E47C-11CD-8701-00AA003F0F07}")) END NewCommandButton; PROCEDURE NewOptionButton* (): _OptionButton; BEGIN RETURN This_OptionButton(CtlC.NewObj("{3B06E951-E47C-11CD-8701-00AA003F0F07}")) END NewOptionButton; PROCEDURE New_OptionButtonInOption* (): _OptionButton; BEGIN RETURN This_OptionButton(CtlC.NewObj("{BC9E435A-F037-11CD-8701-00AA003F0F07}")) END New_OptionButtonInOption; PROCEDURE NewCheckBox* (): _Checkbox; BEGIN RETURN This_Checkbox(CtlC.NewObj("{3B06E953-E47C-11CD-8701-00AA003F0F07}")) END NewCheckBox; PROCEDURE New_CheckBoxInOption* (): _Checkbox; BEGIN RETURN This_Checkbox(CtlC.NewObj("{BC9E435C-F037-11CD-8701-00AA003F0F07}")) END New_CheckBoxInOption; PROCEDURE NewOptionGroup* (): _OptionGroup; BEGIN RETURN This_OptionGroup(CtlC.NewObj("{3B06E955-E47C-11CD-8701-00AA003F0F07}")) END NewOptionGroup; PROCEDURE NewBoundObjectFrame* (): _BoundObjectFrame; BEGIN RETURN This_BoundObjectFrame(CtlC.NewObj("{3B06E957-E47C-11CD-8701-00AA003F0F07}")) END NewBoundObjectFrame; PROCEDURE NewTextBox* (): _Textbox; BEGIN RETURN This_Textbox(CtlC.NewObj("{3B06E945-E47C-11CD-8701-00AA003F0F07}")) END NewTextBox; PROCEDURE NewListBox* (): _ListBox; BEGIN RETURN This_ListBox(CtlC.NewObj("{3B06E959-E47C-11CD-8701-00AA003F0F07}")) END NewListBox; PROCEDURE NewComboBox* (): _Combobox; BEGIN RETURN This_Combobox(CtlC.NewObj("{3B06E95B-E47C-11CD-8701-00AA003F0F07}")) END NewComboBox; PROCEDURE NewObjectFrame* (): _ObjectFrame; BEGIN RETURN This_ObjectFrame(CtlC.NewObj("{3B06E95D-E47C-11CD-8701-00AA003F0F07}")) END NewObjectFrame; PROCEDURE NewPageBreak* (): _PageBreak; BEGIN RETURN This_PageBreak(CtlC.NewObj("{3B06E95F-E47C-11CD-8701-00AA003F0F07}")) END NewPageBreak; PROCEDURE NewToggleButton* (): _ToggleButton; BEGIN RETURN This_ToggleButton(CtlC.NewObj("{3B06E961-E47C-11CD-8701-00AA003F0F07}")) END NewToggleButton; PROCEDURE New_ToggleButtonInOption* (): _ToggleButton; BEGIN RETURN This_ToggleButton(CtlC.NewObj("{BC9E435E-F037-11CD-8701-00AA003F0F07}")) END New_ToggleButtonInOption; PROCEDURE NewPaletteButton* (): _PaletteButton; BEGIN RETURN This_PaletteButton(CtlC.NewObj("{9CD4A762-A6A9-11CE-A686-00AA003F0F07}")) END NewPaletteButton; PROCEDURE NewSubForm* (): _SubForm; BEGIN RETURN This_SubForm(CtlC.NewObj("{3B06E963-E47C-11CD-8701-00AA003F0F07}")) END NewSubForm; PROCEDURE NewSubReport* (): _SubReport; BEGIN RETURN This_SubReport(CtlC.NewObj("{3B06E965-E47C-11CD-8701-00AA003F0F07}")) END NewSubReport; PROCEDURE NewCustomControl* (): _CustomControl; BEGIN RETURN This_CustomControl(CtlC.NewObj("{3B06E967-E47C-11CD-8701-00AA003F0F07}")) END NewCustomControl; PROCEDURE New_CustomControlInReport* (): _CustomControl; BEGIN RETURN This_CustomControl(CtlC.NewObj("{300471E0-7426-11CE-AB63-00AA0042B7CE}")) END New_CustomControlInReport; PROCEDURE NewTabControl* (): _TabControl; BEGIN RETURN This_TabControl(CtlC.NewObj("{3B06E970-E47C-11CD-8701-00AA003F0F07}")) END NewTabControl; PROCEDURE NewSection* (): _Section; BEGIN RETURN This_Section(CtlC.NewObj("{BC9E4355-F037-11CD-8701-00AA003F0F07}")) END NewSection; PROCEDURE NewGroupLevel* (): _GroupLevel; BEGIN RETURN This_GroupLevel(CtlC.NewObj("{BC9E4356-F037-11CD-8701-00AA003F0F07}")) END NewGroupLevel; PROCEDURE New_SectionInReport* (): _Section; BEGIN RETURN This_Section(CtlC.NewObj("{BC9E4360-F037-11CD-8701-00AA003F0F07}")) END New_SectionInReport; PROCEDURE New_PageHdrFtrInReport* (): _Section; BEGIN RETURN This_Section(CtlC.NewObj("{7AD9E906-BAF8-11CE-A68A-00AA003F0F07}")) END New_PageHdrFtrInReport; PROCEDURE NewForm* (): _Form; BEGIN RETURN This_Form(CtlC.NewObj("{483615A0-74BE-101B-AF4E-00AA003F0F07}")) END NewForm; PROCEDURE NewReport* (): _Report; BEGIN RETURN This_Report(CtlC.NewObj("{27CE30A0-91FF-101B-AF4E-00AA003F0F07}")) END NewReport; PROCEDURE NewApplication* (): _Application; BEGIN RETURN This_Application(CtlC.NewObj("{73A4C9C1-D68D-11D0-98BF-00A0C90DC8D9}")) END NewApplication; PROCEDURE NewReferences* (): _References; BEGIN RETURN This_References(CtlC.NewObj("{EB106214-9C89-11CF-A2B3-00A0C90542FF}")) END NewReferences; PROCEDURE NewDataAccessPage* (): _DataAccessPage; BEGIN RETURN This_DataAccessPage(CtlC.NewObj("{493D8A73-1DB1-11D1-98A2-006008197D41}")) END NewDataAccessPage; PROCEDURE NewAllForms* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C813-3CFD-11D1-98BC-006008197D41}")) END NewAllForms; PROCEDURE NewAllReports* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C814-3CFD-11D1-98BC-006008197D41}")) END NewAllReports; PROCEDURE NewAllMacros* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C815-3CFD-11D1-98BC-006008197D41}")) END NewAllMacros; PROCEDURE NewAllModules* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C816-3CFD-11D1-98BC-006008197D41}")) END NewAllModules; PROCEDURE NewAllDataAccessPages* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C818-3CFD-11D1-98BC-006008197D41}")) END NewAllDataAccessPages; PROCEDURE NewAllTables* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C81B-3CFD-11D1-98BC-006008197D41}")) END NewAllTables; PROCEDURE NewAllQueries* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C81C-3CFD-11D1-98BC-006008197D41}")) END NewAllQueries; PROCEDURE NewAllViews* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C81E-3CFD-11D1-98BC-006008197D41}")) END NewAllViews; PROCEDURE NewAllStoredProcedures* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C820-3CFD-11D1-98BC-006008197D41}")) END NewAllStoredProcedures; PROCEDURE NewAllDatabaseDiagrams* (): AllObjects; BEGIN RETURN ThisAllObjects(CtlC.NewObj("{08F6C821-3CFD-11D1-98BC-006008197D41}")) END NewAllDatabaseDiagrams; PROCEDURE NewCurrentProject* (): _CurrentProject; BEGIN RETURN This_CurrentProject(CtlC.NewObj("{08F6C811-3CFD-11D1-98BC-006008197D41}")) END NewCurrentProject; PROCEDURE NewCurrentData* (): _CurrentData; BEGIN RETURN This_CurrentData(CtlC.NewObj("{08F6C819-3CFD-11D1-98BC-006008197D41}")) END NewCurrentData; PROCEDURE NewCodeProject* (): _CurrentProject; BEGIN RETURN This_CurrentProject(CtlC.NewObj("{9212BA72-3E79-11D1-98BD-006008197D41}")) END NewCodeProject; PROCEDURE NewCodeData* (): _CurrentData; BEGIN RETURN This_CurrentData(CtlC.NewObj("{08F6C81A-3CFD-11D1-98BC-006008197D41}")) END NewCodeData; PROCEDURE NewWizHook* (): _WizHook; BEGIN RETURN This_WizHook(CtlC.NewObj("{CB9D3172-4728-11D1-8334-006008197CC8}")) END NewWizHook; PROCEDURE NewDefaultWebOptions* (): _DefaultWebOptions; BEGIN RETURN This_DefaultWebOptions(CtlC.NewObj("{416ED4F1-AB31-11D1-BF72-0060083E43CF}")) END NewDefaultWebOptions; PROCEDURE NewWebOptions* (): _WebOptions; BEGIN RETURN This_WebOptions(CtlC.NewObj("{416ED4F7-AB31-11D1-BF72-0060083E43CF}")) END NewWebOptions; PROCEDURE NewClass* (): _Dummy; BEGIN RETURN This_Dummy(CtlC.NewObj("{8B06E321-B23C-11CF-89A8-00A0C9054129}")) END NewClass; END CtlAccess9.

Ctl/Mod/Access9.odc

MODULE CtlADODB; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft ActiveX Data Objects 2.0 Library, help: , id: 0 *) (* guid: {00000200-0000-0010-8000-00AA006D2EA4}, lcid: 0, syskind: win32, version: 2.0 *) IMPORT CtlT, CtlC; CONST (* CursorTypeEnum *) adOpenUnspecified* = -1; adOpenForwardOnly* = 0; adOpenKeyset* = 1; adOpenDynamic* = 2; adOpenStatic* = 3; (* CursorOptionEnum *) adHoldRecords* = 256; adMovePrevious* = 512; adAddNew* = 16778240; adDelete* = 16779264; adUpdate* = 16809984; adBookmark* = 8192; adApproxPosition* = 16384; adUpdateBatch* = 65536; adResync* = 131072; adNotify* = 262144; adFind* = 524288; (* LockTypeEnum *) adLockUnspecified* = -1; adLockReadOnly* = 1; adLockPessimistic* = 2; adLockOptimistic* = 3; adLockBatchOptimistic* = 4; (* ExecuteOptionEnum *) adOptionUnspecified* = -1; adAsyncExecute* = 16; adAsyncFetch* = 32; adAsyncFetchNonBlocking* = 64; adExecuteNoRecords* = 128; (* ConnectOptionEnum *) adConnectUnspecified* = -1; adAsyncConnect* = 16; (* ObjectStateEnum *) adStateClosed* = 0; adStateOpen* = 1; adStateConnecting* = 2; adStateExecuting* = 4; adStateFetching* = 8; (* CursorLocationEnum *) adUseNone* = 1; adUseServer* = 2; adUseClient* = 3; adUseClientBatch* = 3; (* DataTypeEnum *) adEmpty* = 0; adTinyInt* = 16; adSmallInt* = 2; adInteger* = 3; adBigInt* = 20; adUnsignedTinyInt* = 17; adUnsignedSmallInt* = 18; adUnsignedInt* = 19; adUnsignedBigInt* = 21; adSingle* = 4; adDouble* = 5; adCurrency* = 6; adDecimal* = 14; adNumeric* = 131; adBoolean* = 11; adError* = 10; adUserDefined* = 132; adVariant* = 12; adIDispatch* = 9; adIUnknown* = 13; adGUID* = 72; adDate* = 7; adDBDate* = 133; adDBTime* = 134; adDBTimeStamp* = 135; adBSTR* = 8; adChar* = 129; adVarChar* = 200; adLongVarChar* = 201; adWChar* = 130; adVarWChar* = 202; adLongVarWChar* = 203; adBinary* = 128; adVarBinary* = 204; adLongVarBinary* = 205; adChapter* = 136; adFileTime* = 64; adDBFileTime* = 137; adPropVariant* = 138; adVarNumeric* = 139; (* FieldAttributeEnum *) adFldUnspecified* = -1; adFldMayDefer* = 2; adFldUpdatable* = 4; adFldUnknownUpdatable* = 8; adFldFixed* = 16; adFldIsNullable* = 32; adFldMayBeNull* = 64; adFldLong* = 128; adFldRowID* = 256; adFldRowVersion* = 512; adFldCacheDeferred* = 4096; adFldNegativeScale* = 16384; adFldKeyColumn* = 32768; (* EditModeEnum *) adEditNone* = 0; adEditInProgress* = 1; adEditAdd* = 2; adEditDelete* = 4; (* RecordStatusEnum *) adRecOK* = 0; adRecNew* = 1; adRecModified* = 2; adRecDeleted* = 4; adRecUnmodified* = 8; adRecInvalid* = 16; adRecMultipleChanges* = 64; adRecPendingChanges* = 128; adRecCanceled* = 256; adRecCantRelease* = 1024; adRecConcurrencyViolation* = 2048; adRecIntegrityViolation* = 4096; adRecMaxChangesExceeded* = 8192; adRecObjectOpen* = 16384; adRecOutOfMemory* = 32768; adRecPermissionDenied* = 65536; adRecSchemaViolation* = 131072; adRecDBDeleted* = 262144; (* GetRowsOptionEnum *) adGetRowsRest* = -1; (* PositionEnum *) adPosUnknown* = -1; adPosBOF* = -2; adPosEOF* = -3; (* BookmarkEnum *) adBookmarkCurrent* = 0; adBookmarkFirst* = 1; adBookmarkLast* = 2; (* MarshalOptionsEnum *) adMarshalAll* = 0; adMarshalModifiedOnly* = 1; (* AffectEnum *) adAffectCurrent* = 1; adAffectGroup* = 2; adAffectAll* = 3; adAffectAllChapters* = 4; (* ResyncEnum *) adResyncUnderlyingValues* = 1; adResyncAllValues* = 2; (* CompareEnum *) adCompareLessThan* = 0; adCompareEqual* = 1; adCompareGreaterThan* = 2; adCompareNotEqual* = 3; adCompareNotComparable* = 4; (* FilterGroupEnum *) adFilterNone* = 0; adFilterPendingRecords* = 1; adFilterAffectedRecords* = 2; adFilterFetchedRecords* = 3; adFilterPredicate* = 4; adFilterConflictingRecords* = 5; (* SearchDirectionEnum *) adSearchForward* = 1; adSearchBackward* = -1; (* PersistFormatEnum *) adPersistADTG* = 0; adPersistXML* = 1; (* StringFormatEnum *) adClipString* = 2; (* ADCPROP_UPDATECRITERIA_ENUM *) adCriteriaKey* = 0; adCriteriaAllCols* = 1; adCriteriaUpdCols* = 2; adCriteriaTimeStamp* = 3; (* ADCPROP_ASYNCTHREADPRIORITY_ENUM *) adPriorityLowest* = 1; adPriorityBelowNormal* = 2; adPriorityNormal* = 3; adPriorityAboveNormal* = 4; adPriorityHighest* = 5; (* ConnectPromptEnum *) adPromptAlways* = 1; adPromptComplete* = 2; adPromptCompleteRequired* = 3; adPromptNever* = 4; (* ConnectModeEnum *) adModeUnknown* = 0; adModeRead* = 1; adModeWrite* = 2; adModeReadWrite* = 3; adModeShareDenyRead* = 4; adModeShareDenyWrite* = 8; adModeShareExclusive* = 12; adModeShareDenyNone* = 16; (* IsolationLevelEnum *) adXactUnspecified* = -1; adXactChaos* = 16; adXactReadUncommitted* = 256; adXactBrowse* = 256; adXactCursorStability* = 4096; adXactReadCommitted* = 4096; adXactRepeatableRead* = 65536; adXactSerializable* = 1048576; adXactIsolated* = 1048576; (* XactAttributeEnum *) adXactCommitRetaining* = 131072; adXactAbortRetaining* = 262144; adXactAsyncPhaseOne* = 524288; adXactSyncPhaseOne* = 1048576; (* PropertyAttributesEnum *) adPropNotSupported* = 0; adPropRequired* = 1; adPropOptional* = 2; adPropRead* = 512; adPropWrite* = 1024; (* ErrorValueEnum *) adErrInvalidArgument* = 3001; adErrNoCurrentRecord* = 3021; adErrIllegalOperation* = 3219; adErrInTransaction* = 3246; adErrFeatureNotAvailable* = 3251; adErrItemNotFound* = 3265; adErrObjectInCollection* = 3367; adErrObjectNotSet* = 3420; adErrDataConversion* = 3421; adErrObjectClosed* = 3704; adErrObjectOpen* = 3705; adErrProviderNotFound* = 3706; adErrBoundToCommand* = 3707; adErrInvalidParamInfo* = 3708; adErrInvalidConnection* = 3709; adErrNotReentrant* = 3710; adErrStillExecuting* = 3711; adErrOperationCancelled* = 3712; adErrStillConnecting* = 3713; adErrNotExecuting* = 3715; adErrUnsafeOperation* = 3716; (* ParameterAttributesEnum *) adParamSigned* = 16; adParamNullable* = 64; adParamLong* = 128; (* ParameterDirectionEnum *) adParamUnknown* = 0; adParamInput* = 1; adParamOutput* = 2; adParamInputOutput* = 3; adParamReturnValue* = 4; (* CommandTypeEnum *) adCmdUnspecified* = -1; adCmdUnknown* = 8; adCmdText* = 1; adCmdTable* = 2; adCmdStoredProc* = 4; adCmdFile* = 256; adCmdTableDirect* = 512; (* EventStatusEnum *) adStatusOK* = 1; adStatusErrorsOccurred* = 2; adStatusCantDeny* = 3; adStatusCancel* = 4; adStatusUnwantedEvent* = 5; (* EventReasonEnum *) adRsnAddNew* = 1; adRsnDelete* = 2; adRsnUpdate* = 3; adRsnUndoUpdate* = 4; adRsnUndoAddNew* = 5; adRsnUndoDelete* = 6; adRsnRequery* = 7; adRsnResynch* = 8; adRsnClose* = 9; adRsnMove* = 10; adRsnFirstChange* = 11; adRsnMoveFirst* = 12; adRsnMoveNext* = 13; adRsnMovePrevious* = 14; adRsnMoveLast* = 15; (* SchemaEnum *) adSchemaProviderSpecific* = -1; adSchemaAsserts* = 0; adSchemaCatalogs* = 1; adSchemaCharacterSets* = 2; adSchemaCollations* = 3; adSchemaColumns* = 4; adSchemaCheckConstraints* = 5; adSchemaConstraintColumnUsage* = 6; adSchemaConstraintTableUsage* = 7; adSchemaKeyColumnUsage* = 8; adSchemaReferentialContraints* = 9; adSchemaTableConstraints* = 10; adSchemaColumnsDomainUsage* = 11; adSchemaIndexes* = 12; adSchemaColumnPrivileges* = 13; adSchemaTablePrivileges* = 14; adSchemaUsagePrivileges* = 15; adSchemaProcedures* = 16; adSchemaSchemata* = 17; adSchemaSQLLanguages* = 18; adSchemaStatistics* = 19; adSchemaTables* = 20; adSchemaTranslations* = 21; adSchemaProviderTypes* = 22; adSchemaViews* = 23; adSchemaViewColumnUsage* = 24; adSchemaViewTableUsage* = 25; adSchemaProcedureParameters* = 26; adSchemaForeignKeys* = 27; adSchemaPrimaryKeys* = 28; adSchemaProcedureColumns* = 29; adSchemaDBInfoKeywords* = 30; adSchemaDBInfoLiterals* = 31; adSchemaCubes* = 32; adSchemaDimensions* = 33; adSchemaHierarchies* = 34; adSchemaLevels* = 35; adSchemaMeasures* = 36; adSchemaProperties* = 37; adSchemaMembers* = 38; TYPE CursorTypeEnum* = INTEGER; CursorOptionEnum* = INTEGER; LockTypeEnum* = INTEGER; ExecuteOptionEnum* = INTEGER; ConnectOptionEnum* = INTEGER; ObjectStateEnum* = INTEGER; CursorLocationEnum* = INTEGER; DataTypeEnum* = INTEGER; FieldAttributeEnum* = INTEGER; EditModeEnum* = INTEGER; RecordStatusEnum* = INTEGER; GetRowsOptionEnum* = INTEGER; PositionEnum* = INTEGER; BookmarkEnum* = INTEGER; MarshalOptionsEnum* = INTEGER; AffectEnum* = INTEGER; ResyncEnum* = INTEGER; CompareEnum* = INTEGER; FilterGroupEnum* = INTEGER; SearchDirectionEnum* = INTEGER; SearchDirection* = SearchDirectionEnum; PersistFormatEnum* = INTEGER; StringFormatEnum* = INTEGER; ADCPROP_UPDATECRITERIA_ENUM* = INTEGER; ADCPROP_ASYNCTHREADPRIORITY_ENUM* = INTEGER; ConnectPromptEnum* = INTEGER; ConnectModeEnum* = INTEGER; IsolationLevelEnum* = INTEGER; XactAttributeEnum* = INTEGER; PropertyAttributesEnum* = INTEGER; ErrorValueEnum* = INTEGER; ParameterAttributesEnum* = INTEGER; ParameterDirectionEnum* = INTEGER; CommandTypeEnum* = INTEGER; EventStatusEnum* = INTEGER; EventReasonEnum* = INTEGER; SchemaEnum* = INTEGER; _Collection* = POINTER TO RECORD (CtlT.Object) END; _DynaCollection* = POINTER TO RECORD (CtlT.Object) END; _ADO* = POINTER TO RECORD (CtlT.Object) END; Properties* = POINTER TO RECORD (CtlT.Object) END; Property* = POINTER TO RECORD (CtlT.Object) END; Error* = POINTER TO RECORD (CtlT.Object) END; Errors* = POINTER TO RECORD (CtlT.Object) END; _Command15* = POINTER TO RECORD (CtlT.Object) END; _Connection* = POINTER TO RECORD (CtlT.Object) END; _Connection15* = POINTER TO RECORD (CtlT.Object) END; _Recordset* = POINTER TO RECORD (CtlT.Object) END; _Recordset15* = POINTER TO RECORD (CtlT.Object) END; Fields* = POINTER TO RECORD (CtlT.Object) END; Fields15* = POINTER TO RECORD (CtlT.Object) END; Field* = POINTER TO RECORD (CtlT.Object) END; _Parameter* = POINTER TO RECORD (CtlT.Object) END; Parameters* = POINTER TO RECORD (CtlT.Object) END; _Command* = POINTER TO RECORD (CtlT.Object) END; ConnectionEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; RecordsetEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Connection* = _Connection; Command* = _Command; Recordset* = _Recordset; Field15* = POINTER TO RECORD (CtlT.Object) END; Parameter* = _Parameter; PROCEDURE This_Collection* (v: CtlT.Any): _Collection; VAR new: _Collection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000512-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Collection; PROCEDURE Is_Collection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000512-0000-0010-8000-00AA006D2EA4}") END Is_Collection; PROCEDURE This_DynaCollection* (v: CtlT.Any): _DynaCollection; VAR new: _DynaCollection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000513-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_DynaCollection; PROCEDURE Is_DynaCollection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000513-0000-0010-8000-00AA006D2EA4}") END Is_DynaCollection; PROCEDURE This_ADO* (v: CtlT.Any): _ADO; VAR new: _ADO; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000534-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_ADO; PROCEDURE Is_ADO* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000534-0000-0010-8000-00AA006D2EA4}") END Is_ADO; PROCEDURE ThisProperties* (v: CtlT.Any): Properties; VAR new: Properties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000504-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisProperties; PROCEDURE IsProperties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000504-0000-0010-8000-00AA006D2EA4}") END IsProperties; PROCEDURE ThisProperty* (v: CtlT.Any): Property; VAR new: Property; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000503-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisProperty; PROCEDURE IsProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000503-0000-0010-8000-00AA006D2EA4}") END IsProperty; PROCEDURE ThisError* (v: CtlT.Any): Error; VAR new: Error; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000500-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisError; PROCEDURE IsError* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000500-0000-0010-8000-00AA006D2EA4}") END IsError; PROCEDURE ThisErrors* (v: CtlT.Any): Errors; VAR new: Errors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000501-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisErrors; PROCEDURE IsErrors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000501-0000-0010-8000-00AA006D2EA4}") END IsErrors; PROCEDURE This_Command15* (v: CtlT.Any): _Command15; VAR new: _Command15; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000508-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Command15; PROCEDURE Is_Command15* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000508-0000-0010-8000-00AA006D2EA4}") END Is_Command15; PROCEDURE This_Connection* (v: CtlT.Any): _Connection; VAR new: _Connection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000550-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Connection; PROCEDURE Is_Connection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000550-0000-0010-8000-00AA006D2EA4}") END Is_Connection; PROCEDURE This_Connection15* (v: CtlT.Any): _Connection15; VAR new: _Connection15; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000515-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Connection15; PROCEDURE Is_Connection15* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000515-0000-0010-8000-00AA006D2EA4}") END Is_Connection15; PROCEDURE This_Recordset* (v: CtlT.Any): _Recordset; VAR new: _Recordset; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000054F-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Recordset; PROCEDURE Is_Recordset* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000054F-0000-0010-8000-00AA006D2EA4}") END Is_Recordset; PROCEDURE This_Recordset15* (v: CtlT.Any): _Recordset15; VAR new: _Recordset15; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000050E-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Recordset15; PROCEDURE Is_Recordset15* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000050E-0000-0010-8000-00AA006D2EA4}") END Is_Recordset15; PROCEDURE ThisFields* (v: CtlT.Any): Fields; VAR new: Fields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000054D-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisFields; PROCEDURE IsFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000054D-0000-0010-8000-00AA006D2EA4}") END IsFields; PROCEDURE ThisFields15* (v: CtlT.Any): Fields15; VAR new: Fields15; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000506-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisFields15; PROCEDURE IsFields15* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000506-0000-0010-8000-00AA006D2EA4}") END IsFields15; PROCEDURE ThisField* (v: CtlT.Any): Field; VAR new: Field; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000054C-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisField; PROCEDURE IsField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000054C-0000-0010-8000-00AA006D2EA4}") END IsField; PROCEDURE This_Parameter* (v: CtlT.Any): _Parameter; VAR new: _Parameter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000050C-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Parameter; PROCEDURE Is_Parameter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000050C-0000-0010-8000-00AA006D2EA4}") END Is_Parameter; PROCEDURE ThisParameters* (v: CtlT.Any): Parameters; VAR new: Parameters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000050D-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisParameters; PROCEDURE IsParameters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000050D-0000-0010-8000-00AA006D2EA4}") END IsParameters; PROCEDURE This_Command* (v: CtlT.Any): _Command; VAR new: _Command; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000054E-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Command; PROCEDURE Is_Command* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000054E-0000-0010-8000-00AA006D2EA4}") END Is_Command; PROCEDURE ThisField15* (v: CtlT.Any): Field15; VAR new: Field15; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000505-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisField15; PROCEDURE IsField15* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000505-0000-0010-8000-00AA006D2EA4}") END IsField15; (* ---------- _Collection, dual, nonextensible ---------- *) PROCEDURE (this: _Collection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: _Collection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Collection) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; (* ---------- _DynaCollection, dual, nonextensible ---------- *) PROCEDURE (this: _DynaCollection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: _DynaCollection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _DynaCollection) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: _DynaCollection) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: _DynaCollection) Delete* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; (* ---------- _ADO, dual, nonextensible ---------- *) PROCEDURE (this: _ADO) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; (* ---------- Properties, dual, nonextensible ---------- *) PROCEDURE (this: Properties) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Properties) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Properties) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Properties) Item* (Index: CtlT.Any): Property, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END Item; (* ---------- Property, dual, nonextensible ---------- *) PROCEDURE (this: Property) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Property) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Property) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743810) END Name; PROCEDURE (this: Property) Type* (): DataTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Type; PROCEDURE (this: Property) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743812) END Attributes; PROCEDURE (this: Property) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610743812, p1) END PUTAttributes; (* ---------- Error, dual, nonextensible ---------- *) PROCEDURE (this: Error) Number* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Number; PROCEDURE (this: Error) Source* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Source; PROCEDURE (this: Error) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Description; PROCEDURE (this: Error) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743811) END HelpFile; PROCEDURE (this: Error) HelpContext* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743812) END HelpContext; PROCEDURE (this: Error) SQLState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743813) END SQLState; PROCEDURE (this: Error) NativeError* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743814) END NativeError; (* ---------- Errors, dual, nonextensible ---------- *) PROCEDURE (this: Errors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Errors) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Errors) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Errors) Item* (Index: CtlT.Any): Error, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisError(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Errors) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 1610809345, NIL); END Clear; (* ---------- _Command15, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Command15) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Command15) ActiveConnection* (): _Connection, NEW; BEGIN RETURN This_Connection(CtlC.GetAny(this, 1610809344)) END ActiveConnection; PROCEDURE (this: _Command15) PUTREFActiveConnection* (p1: _Connection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1610809344, arg, NIL); END PUTREFActiveConnection; PROCEDURE (this: _Command15) PUTActiveConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809344, p1) END PUTActiveConnection; PROCEDURE (this: _Command15) CommandText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END CommandText; PROCEDURE (this: _Command15) PUTCommandText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTCommandText; PROCEDURE (this: _Command15) CommandTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END CommandTimeout; PROCEDURE (this: _Command15) PUTCommandTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTCommandTimeout; PROCEDURE (this: _Command15) Prepared* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809351) END Prepared; PROCEDURE (this: _Command15) PUTPrepared* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809351, p1) END PUTPrepared; PROCEDURE (this: _Command15) Execute* (RecordsAffected: CtlT.Any; Parameters: CtlT.Any; Options: INTEGER): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RecordsAffected, arg[2]); CtlC.AnyVar(Parameters, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809353, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END Execute; PROCEDURE (this: _Command15) CreateParameter* (Name: ARRAY OF CHAR; Type: DataTypeEnum; Direction: ParameterDirectionEnum; Size: INTEGER; (* optional *) Value: CtlT.Any): _Parameter, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[4]); CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Direction, arg[2]); CtlC.IntVar(Size, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 1610809354, arg, ret); RETURN This_Parameter(CtlC.VarAny(ret)) END CreateParameter; PROCEDURE (this: _Command15) Parameters* (): Parameters, NEW; BEGIN RETURN ThisParameters(CtlC.GetAny(this, 0)) END Parameters; PROCEDURE (this: _Command15) PUTCommandType* (p1: CommandTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1610809356, p1) END PUTCommandType; PROCEDURE (this: _Command15) CommandType* (): CommandTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809356) END CommandType; PROCEDURE (this: _Command15) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809358) END Name; PROCEDURE (this: _Command15) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809358, p1) END PUTName; (* ---------- _Connection, dual ---------- *) PROCEDURE (this: _Connection) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Connection) ConnectionString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END ConnectionString; PROCEDURE (this: _Connection) PUTConnectionString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTConnectionString; PROCEDURE (this: _Connection) CommandTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END CommandTimeout; PROCEDURE (this: _Connection) PUTCommandTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTCommandTimeout; PROCEDURE (this: _Connection) ConnectionTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END ConnectionTimeout; PROCEDURE (this: _Connection) PUTConnectionTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTConnectionTimeout; PROCEDURE (this: _Connection) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Version; PROCEDURE (this: _Connection) Close* (), NEW; BEGIN CtlC.CallMethod(this, 5, NIL); END Close; PROCEDURE (this: _Connection) Execute* (CommandText: ARRAY OF CHAR; RecordsAffected: CtlT.Any; Options: INTEGER): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(CommandText, arg[2]); CtlC.AnyVar(RecordsAffected, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 6, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END Execute; PROCEDURE (this: _Connection) BeginTrans* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 7, ret); RETURN CtlC.VarInt(ret) END BeginTrans; PROCEDURE (this: _Connection) CommitTrans* (), NEW; BEGIN CtlC.CallMethod(this, 8, NIL); END CommitTrans; PROCEDURE (this: _Connection) RollbackTrans* (), NEW; BEGIN CtlC.CallMethod(this, 9, NIL); END RollbackTrans; PROCEDURE (this: _Connection) Open* (ConnectionString: ARRAY OF CHAR; UserID: ARRAY OF CHAR; Password: ARRAY OF CHAR; Options: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(ConnectionString, arg[3]); CtlC.StrVar(UserID, arg[2]); CtlC.StrVar(Password, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END Open; PROCEDURE (this: _Connection) Errors* (): Errors, NEW; BEGIN RETURN ThisErrors(CtlC.GetAny(this, 11)) END Errors; PROCEDURE (this: _Connection) DefaultDatabase* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END DefaultDatabase; PROCEDURE (this: _Connection) PUTDefaultDatabase* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12, p1) END PUTDefaultDatabase; PROCEDURE (this: _Connection) IsolationLevel* (): IsolationLevelEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END IsolationLevel; PROCEDURE (this: _Connection) PUTIsolationLevel* (p1: IsolationLevelEnum), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTIsolationLevel; PROCEDURE (this: _Connection) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 14) END Attributes; PROCEDURE (this: _Connection) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 14, p1) END PUTAttributes; PROCEDURE (this: _Connection) CursorLocation* (): CursorLocationEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 15) END CursorLocation; PROCEDURE (this: _Connection) PUTCursorLocation* (p1: CursorLocationEnum), NEW; BEGIN CtlC.PutInt(this, 15, p1) END PUTCursorLocation; PROCEDURE (this: _Connection) Mode* (): ConnectModeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END Mode; PROCEDURE (this: _Connection) PUTMode* (p1: ConnectModeEnum), NEW; BEGIN CtlC.PutInt(this, 16, p1) END PUTMode; PROCEDURE (this: _Connection) Provider* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Provider; PROCEDURE (this: _Connection) PUTProvider* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTProvider; PROCEDURE (this: _Connection) State* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END State; PROCEDURE (this: _Connection) OpenSchema* (Schema: SchemaEnum; (* optional *) Restrictions: CtlT.Any; SchemaID: CtlT.Any): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Schema, arg[2]); CtlC.AnyVar(Restrictions, arg[1]); CtlC.AnyVar(SchemaID, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END OpenSchema; PROCEDURE (this: _Connection) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 21, NIL); END Cancel; (* ---------- _Connection15, hidden, dual ---------- *) PROCEDURE (this: _Connection15) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Connection15) ConnectionString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END ConnectionString; PROCEDURE (this: _Connection15) PUTConnectionString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTConnectionString; PROCEDURE (this: _Connection15) CommandTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END CommandTimeout; PROCEDURE (this: _Connection15) PUTCommandTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTCommandTimeout; PROCEDURE (this: _Connection15) ConnectionTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END ConnectionTimeout; PROCEDURE (this: _Connection15) PUTConnectionTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTConnectionTimeout; PROCEDURE (this: _Connection15) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Version; PROCEDURE (this: _Connection15) Close* (), NEW; BEGIN CtlC.CallMethod(this, 5, NIL); END Close; PROCEDURE (this: _Connection15) Execute* (CommandText: ARRAY OF CHAR; RecordsAffected: CtlT.Any; Options: INTEGER): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(CommandText, arg[2]); CtlC.AnyVar(RecordsAffected, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 6, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END Execute; PROCEDURE (this: _Connection15) BeginTrans* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 7, ret); RETURN CtlC.VarInt(ret) END BeginTrans; PROCEDURE (this: _Connection15) CommitTrans* (), NEW; BEGIN CtlC.CallMethod(this, 8, NIL); END CommitTrans; PROCEDURE (this: _Connection15) RollbackTrans* (), NEW; BEGIN CtlC.CallMethod(this, 9, NIL); END RollbackTrans; PROCEDURE (this: _Connection15) Open* (ConnectionString: ARRAY OF CHAR; UserID: ARRAY OF CHAR; Password: ARRAY OF CHAR; Options: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(ConnectionString, arg[3]); CtlC.StrVar(UserID, arg[2]); CtlC.StrVar(Password, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END Open; PROCEDURE (this: _Connection15) Errors* (): Errors, NEW; BEGIN RETURN ThisErrors(CtlC.GetAny(this, 11)) END Errors; PROCEDURE (this: _Connection15) DefaultDatabase* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END DefaultDatabase; PROCEDURE (this: _Connection15) PUTDefaultDatabase* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12, p1) END PUTDefaultDatabase; PROCEDURE (this: _Connection15) IsolationLevel* (): IsolationLevelEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END IsolationLevel; PROCEDURE (this: _Connection15) PUTIsolationLevel* (p1: IsolationLevelEnum), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTIsolationLevel; PROCEDURE (this: _Connection15) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 14) END Attributes; PROCEDURE (this: _Connection15) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 14, p1) END PUTAttributes; PROCEDURE (this: _Connection15) CursorLocation* (): CursorLocationEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 15) END CursorLocation; PROCEDURE (this: _Connection15) PUTCursorLocation* (p1: CursorLocationEnum), NEW; BEGIN CtlC.PutInt(this, 15, p1) END PUTCursorLocation; PROCEDURE (this: _Connection15) Mode* (): ConnectModeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END Mode; PROCEDURE (this: _Connection15) PUTMode* (p1: ConnectModeEnum), NEW; BEGIN CtlC.PutInt(this, 16, p1) END PUTMode; PROCEDURE (this: _Connection15) Provider* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END Provider; PROCEDURE (this: _Connection15) PUTProvider* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTProvider; PROCEDURE (this: _Connection15) State* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END State; PROCEDURE (this: _Connection15) OpenSchema* (Schema: SchemaEnum; (* optional *) Restrictions: CtlT.Any; SchemaID: CtlT.Any): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Schema, arg[2]); CtlC.AnyVar(Restrictions, arg[1]); CtlC.AnyVar(SchemaID, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END OpenSchema; (* ---------- _Recordset, dual, nonextensible ---------- *) PROCEDURE (this: _Recordset) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Recordset) AbsolutePosition* (): PositionEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1000) END AbsolutePosition; PROCEDURE (this: _Recordset) PUTAbsolutePosition* (p1: PositionEnum), NEW; BEGIN CtlC.PutInt(this, 1000, p1) END PUTAbsolutePosition; PROCEDURE (this: _Recordset) PUTREFActiveConnection* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1001, arg, NIL); END PUTREFActiveConnection; PROCEDURE (this: _Recordset) PUTActiveConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1001, p1) END PUTActiveConnection; PROCEDURE (this: _Recordset) ActiveConnection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1001) END ActiveConnection; PROCEDURE (this: _Recordset) BOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1002) END BOF; PROCEDURE (this: _Recordset) Bookmark* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1003) END Bookmark; PROCEDURE (this: _Recordset) PUTBookmark* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1003, p1) END PUTBookmark; PROCEDURE (this: _Recordset) CacheSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END CacheSize; PROCEDURE (this: _Recordset) PUTCacheSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTCacheSize; PROCEDURE (this: _Recordset) CursorType* (): CursorTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END CursorType; PROCEDURE (this: _Recordset) PUTCursorType* (p1: CursorTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTCursorType; PROCEDURE (this: _Recordset) EOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1006) END EOF; PROCEDURE (this: _Recordset) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 0)) END Fields; PROCEDURE (this: _Recordset) LockType* (): LockTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1008) END LockType; PROCEDURE (this: _Recordset) PUTLockType* (p1: LockTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1008, p1) END PUTLockType; PROCEDURE (this: _Recordset) MaxRecords* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1009) END MaxRecords; PROCEDURE (this: _Recordset) PUTMaxRecords* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1009, p1) END PUTMaxRecords; PROCEDURE (this: _Recordset) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1010) END RecordCount; PROCEDURE (this: _Recordset) PUTREFSource* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1011, arg, NIL); END PUTREFSource; PROCEDURE (this: _Recordset) PUTSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1011, p1) END PUTSource; PROCEDURE (this: _Recordset) Source* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1011) END Source; PROCEDURE (this: _Recordset) AddNew* ((* optional *) FieldList: CtlT.Any; Values: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FieldList, arg[1]); CtlC.AnyVar(Values, arg[0]); CtlC.CallParMethod(this, 1012, arg, NIL); END AddNew; PROCEDURE (this: _Recordset) CancelUpdate* (), NEW; BEGIN CtlC.CallMethod(this, 1013, NIL); END CancelUpdate; PROCEDURE (this: _Recordset) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1014, NIL); END Close; PROCEDURE (this: _Recordset) Delete* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1015, arg, NIL); END Delete; PROCEDURE (this: _Recordset) GetRows* (Rows: INTEGER; (* optional *) Start: CtlT.Any; Fields: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Rows, arg[2]); CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Fields, arg[0]); CtlC.CallParMethod(this, 1016, arg, ret); RETURN CtlC.VarAny(ret) END GetRows; PROCEDURE (this: _Recordset) Move* (NumRecords: INTEGER; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(NumRecords, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1017, arg, NIL); END Move; PROCEDURE (this: _Recordset) MoveNext* (), NEW; BEGIN CtlC.CallMethod(this, 1018, NIL); END MoveNext; PROCEDURE (this: _Recordset) MovePrevious* (), NEW; BEGIN CtlC.CallMethod(this, 1019, NIL); END MovePrevious; PROCEDURE (this: _Recordset) MoveFirst* (), NEW; BEGIN CtlC.CallMethod(this, 1020, NIL); END MoveFirst; PROCEDURE (this: _Recordset) MoveLast* (), NEW; BEGIN CtlC.CallMethod(this, 1021, NIL); END MoveLast; PROCEDURE (this: _Recordset) Open* (Source: CtlT.Any; ActiveConnection: CtlT.Any; CursorType: CursorTypeEnum; LockType: LockTypeEnum; Options: INTEGER), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[4]); CtlC.AnyVar(ActiveConnection, arg[3]); CtlC.IntVar(CursorType, arg[2]); CtlC.IntVar(LockType, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1022, arg, NIL); END Open; PROCEDURE (this: _Recordset) Requery* (Options: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1023, arg, NIL); END Requery; PROCEDURE (this: _Recordset) _xResync* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1610809378, arg, NIL); END _xResync; PROCEDURE (this: _Recordset) Update* ((* optional *) Fields: CtlT.Any; Values: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Fields, arg[1]); CtlC.AnyVar(Values, arg[0]); CtlC.CallParMethod(this, 1025, arg, NIL); END Update; PROCEDURE (this: _Recordset) AbsolutePage* (): PositionEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1047) END AbsolutePage; PROCEDURE (this: _Recordset) PUTAbsolutePage* (p1: PositionEnum), NEW; BEGIN CtlC.PutInt(this, 1047, p1) END PUTAbsolutePage; PROCEDURE (this: _Recordset) EditMode* (): EditModeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1026) END EditMode; PROCEDURE (this: _Recordset) Filter* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1030) END Filter; PROCEDURE (this: _Recordset) PUTFilter* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1030, p1) END PUTFilter; PROCEDURE (this: _Recordset) PageCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1050) END PageCount; PROCEDURE (this: _Recordset) PageSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1048) END PageSize; PROCEDURE (this: _Recordset) PUTPageSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1048, p1) END PUTPageSize; PROCEDURE (this: _Recordset) Sort* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END Sort; PROCEDURE (this: _Recordset) PUTSort* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTSort; PROCEDURE (this: _Recordset) Status* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1029) END Status; PROCEDURE (this: _Recordset) State* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1054) END State; PROCEDURE (this: _Recordset) _xClone* (): _Recordset, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610809392, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END _xClone; PROCEDURE (this: _Recordset) UpdateBatch* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1035, arg, NIL); END UpdateBatch; PROCEDURE (this: _Recordset) CancelBatch* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1049, arg, NIL); END CancelBatch; PROCEDURE (this: _Recordset) CursorLocation* (): CursorLocationEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1051) END CursorLocation; PROCEDURE (this: _Recordset) PUTCursorLocation* (p1: CursorLocationEnum), NEW; BEGIN CtlC.PutInt(this, 1051, p1) END PUTCursorLocation; PROCEDURE (this: _Recordset) NextRecordset* ((* optional *) RecordsAffected: CtlT.Any): _Recordset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RecordsAffected, arg[0]); CtlC.CallParMethod(this, 1052, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END NextRecordset; PROCEDURE (this: _Recordset) Supports* (CursorOptions: CursorOptionEnum): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(CursorOptions, arg[0]); CtlC.CallParMethod(this, 1036, arg, ret); RETURN CtlC.VarBool(ret) END Supports; PROCEDURE (this: _Recordset) Collect* (Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, -8, arg, ret); RETURN CtlC.VarAny(ret) END Collect; PROCEDURE (this: _Recordset) PUTCollect* (Index: CtlT.Any; p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, -8, arg, NIL); END PUTCollect; PROCEDURE (this: _Recordset) MarshalOptions* (): MarshalOptionsEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1053) END MarshalOptions; PROCEDURE (this: _Recordset) PUTMarshalOptions* (p1: MarshalOptionsEnum), NEW; BEGIN CtlC.PutInt(this, 1053, p1) END PUTMarshalOptions; PROCEDURE (this: _Recordset) Find* (Criteria: ARRAY OF CHAR; SkipRecords: INTEGER; SearchDirection: SearchDirectionEnum; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[3]); CtlC.IntVar(SkipRecords, arg[2]); CtlC.IntVar(SearchDirection, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1058, arg, NIL); END Find; PROCEDURE (this: _Recordset) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 1055, NIL); END Cancel; PROCEDURE (this: _Recordset) DataSource* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 1056) END DataSource; PROCEDURE (this: _Recordset) PUTREFDataSource* (p1: CtlT.IUnknown), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntfceVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1056, arg, NIL); END PUTREFDataSource; PROCEDURE (this: _Recordset) Save* (FileName: ARRAY OF CHAR; PersistFormat: PersistFormatEnum), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[1]); CtlC.IntVar(PersistFormat, arg[0]); CtlC.CallParMethod(this, 1057, arg, NIL); END Save; PROCEDURE (this: _Recordset) ActiveCommand* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1061) END ActiveCommand; PROCEDURE (this: _Recordset) PUTStayInSync* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTStayInSync; PROCEDURE (this: _Recordset) StayInSync* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END StayInSync; PROCEDURE (this: _Recordset) GetString* (StringFormat: StringFormatEnum; NumRows: INTEGER; ColumnDelimeter: ARRAY OF CHAR; RowDelimeter: ARRAY OF CHAR; NullExpr: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(StringFormat, arg[4]); CtlC.IntVar(NumRows, arg[3]); CtlC.StrVar(ColumnDelimeter, arg[2]); CtlC.StrVar(RowDelimeter, arg[1]); CtlC.StrVar(NullExpr, arg[0]); CtlC.CallParMethod(this, 1062, arg, ret); RETURN CtlC.VarStr(ret) END GetString; PROCEDURE (this: _Recordset) DataMember* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1064) END DataMember; PROCEDURE (this: _Recordset) PUTDataMember* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1064, p1) END PUTDataMember; PROCEDURE (this: _Recordset) CompareBookmarks* (Bookmark1: CtlT.Any; Bookmark2: CtlT.Any): CompareEnum, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bookmark1, arg[1]); CtlC.AnyVar(Bookmark2, arg[0]); CtlC.CallParMethod(this, 1065, arg, ret); RETURN CtlC.VarInt(ret) END CompareBookmarks; PROCEDURE (this: _Recordset) Clone* (LockType: LockTypeEnum): _Recordset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(LockType, arg[0]); CtlC.CallParMethod(this, 1034, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END Clone; PROCEDURE (this: _Recordset) Resync* (AffectRecords: AffectEnum; ResyncValues: ResyncEnum), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[1]); CtlC.IntVar(ResyncValues, arg[0]); CtlC.CallParMethod(this, 1024, arg, NIL); END Resync; (* ---------- _Recordset15, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Recordset15) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Recordset15) AbsolutePosition* (): PositionEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1000) END AbsolutePosition; PROCEDURE (this: _Recordset15) PUTAbsolutePosition* (p1: PositionEnum), NEW; BEGIN CtlC.PutInt(this, 1000, p1) END PUTAbsolutePosition; PROCEDURE (this: _Recordset15) PUTREFActiveConnection* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1001, arg, NIL); END PUTREFActiveConnection; PROCEDURE (this: _Recordset15) PUTActiveConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1001, p1) END PUTActiveConnection; PROCEDURE (this: _Recordset15) ActiveConnection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1001) END ActiveConnection; PROCEDURE (this: _Recordset15) BOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1002) END BOF; PROCEDURE (this: _Recordset15) Bookmark* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1003) END Bookmark; PROCEDURE (this: _Recordset15) PUTBookmark* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1003, p1) END PUTBookmark; PROCEDURE (this: _Recordset15) CacheSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END CacheSize; PROCEDURE (this: _Recordset15) PUTCacheSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTCacheSize; PROCEDURE (this: _Recordset15) CursorType* (): CursorTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END CursorType; PROCEDURE (this: _Recordset15) PUTCursorType* (p1: CursorTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTCursorType; PROCEDURE (this: _Recordset15) EOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1006) END EOF; PROCEDURE (this: _Recordset15) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 0)) END Fields; PROCEDURE (this: _Recordset15) LockType* (): LockTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1008) END LockType; PROCEDURE (this: _Recordset15) PUTLockType* (p1: LockTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1008, p1) END PUTLockType; PROCEDURE (this: _Recordset15) MaxRecords* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1009) END MaxRecords; PROCEDURE (this: _Recordset15) PUTMaxRecords* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1009, p1) END PUTMaxRecords; PROCEDURE (this: _Recordset15) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1010) END RecordCount; PROCEDURE (this: _Recordset15) PUTREFSource* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1011, arg, NIL); END PUTREFSource; PROCEDURE (this: _Recordset15) PUTSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1011, p1) END PUTSource; PROCEDURE (this: _Recordset15) Source* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1011) END Source; PROCEDURE (this: _Recordset15) AddNew* ((* optional *) FieldList: CtlT.Any; Values: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FieldList, arg[1]); CtlC.AnyVar(Values, arg[0]); CtlC.CallParMethod(this, 1012, arg, NIL); END AddNew; PROCEDURE (this: _Recordset15) CancelUpdate* (), NEW; BEGIN CtlC.CallMethod(this, 1013, NIL); END CancelUpdate; PROCEDURE (this: _Recordset15) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1014, NIL); END Close; PROCEDURE (this: _Recordset15) Delete* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1015, arg, NIL); END Delete; PROCEDURE (this: _Recordset15) GetRows* (Rows: INTEGER; (* optional *) Start: CtlT.Any; Fields: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Rows, arg[2]); CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Fields, arg[0]); CtlC.CallParMethod(this, 1016, arg, ret); RETURN CtlC.VarAny(ret) END GetRows; PROCEDURE (this: _Recordset15) Move* (NumRecords: INTEGER; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(NumRecords, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1017, arg, NIL); END Move; PROCEDURE (this: _Recordset15) MoveNext* (), NEW; BEGIN CtlC.CallMethod(this, 1018, NIL); END MoveNext; PROCEDURE (this: _Recordset15) MovePrevious* (), NEW; BEGIN CtlC.CallMethod(this, 1019, NIL); END MovePrevious; PROCEDURE (this: _Recordset15) MoveFirst* (), NEW; BEGIN CtlC.CallMethod(this, 1020, NIL); END MoveFirst; PROCEDURE (this: _Recordset15) MoveLast* (), NEW; BEGIN CtlC.CallMethod(this, 1021, NIL); END MoveLast; PROCEDURE (this: _Recordset15) Open* (Source: CtlT.Any; ActiveConnection: CtlT.Any; CursorType: CursorTypeEnum; LockType: LockTypeEnum; Options: INTEGER), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[4]); CtlC.AnyVar(ActiveConnection, arg[3]); CtlC.IntVar(CursorType, arg[2]); CtlC.IntVar(LockType, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1022, arg, NIL); END Open; PROCEDURE (this: _Recordset15) Requery* (Options: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1023, arg, NIL); END Requery; PROCEDURE (this: _Recordset15) _xResync* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1610809378, arg, NIL); END _xResync; PROCEDURE (this: _Recordset15) Update* ((* optional *) Fields: CtlT.Any; Values: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Fields, arg[1]); CtlC.AnyVar(Values, arg[0]); CtlC.CallParMethod(this, 1025, arg, NIL); END Update; PROCEDURE (this: _Recordset15) AbsolutePage* (): PositionEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1047) END AbsolutePage; PROCEDURE (this: _Recordset15) PUTAbsolutePage* (p1: PositionEnum), NEW; BEGIN CtlC.PutInt(this, 1047, p1) END PUTAbsolutePage; PROCEDURE (this: _Recordset15) EditMode* (): EditModeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1026) END EditMode; PROCEDURE (this: _Recordset15) Filter* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1030) END Filter; PROCEDURE (this: _Recordset15) PUTFilter* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1030, p1) END PUTFilter; PROCEDURE (this: _Recordset15) PageCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1050) END PageCount; PROCEDURE (this: _Recordset15) PageSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1048) END PageSize; PROCEDURE (this: _Recordset15) PUTPageSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1048, p1) END PUTPageSize; PROCEDURE (this: _Recordset15) Sort* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END Sort; PROCEDURE (this: _Recordset15) PUTSort* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTSort; PROCEDURE (this: _Recordset15) Status* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1029) END Status; PROCEDURE (this: _Recordset15) State* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1054) END State; PROCEDURE (this: _Recordset15) _xClone* (): _Recordset, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610809392, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END _xClone; PROCEDURE (this: _Recordset15) UpdateBatch* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1035, arg, NIL); END UpdateBatch; PROCEDURE (this: _Recordset15) CancelBatch* (AffectRecords: AffectEnum), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(AffectRecords, arg[0]); CtlC.CallParMethod(this, 1049, arg, NIL); END CancelBatch; PROCEDURE (this: _Recordset15) CursorLocation* (): CursorLocationEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1051) END CursorLocation; PROCEDURE (this: _Recordset15) PUTCursorLocation* (p1: CursorLocationEnum), NEW; BEGIN CtlC.PutInt(this, 1051, p1) END PUTCursorLocation; PROCEDURE (this: _Recordset15) NextRecordset* ((* optional *) RecordsAffected: CtlT.Any): _Recordset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RecordsAffected, arg[0]); CtlC.CallParMethod(this, 1052, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END NextRecordset; PROCEDURE (this: _Recordset15) Supports* (CursorOptions: CursorOptionEnum): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(CursorOptions, arg[0]); CtlC.CallParMethod(this, 1036, arg, ret); RETURN CtlC.VarBool(ret) END Supports; PROCEDURE (this: _Recordset15) Collect* (Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, -8, arg, ret); RETURN CtlC.VarAny(ret) END Collect; PROCEDURE (this: _Recordset15) PUTCollect* (Index: CtlT.Any; p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, -8, arg, NIL); END PUTCollect; PROCEDURE (this: _Recordset15) MarshalOptions* (): MarshalOptionsEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1053) END MarshalOptions; PROCEDURE (this: _Recordset15) PUTMarshalOptions* (p1: MarshalOptionsEnum), NEW; BEGIN CtlC.PutInt(this, 1053, p1) END PUTMarshalOptions; PROCEDURE (this: _Recordset15) Find* (Criteria: ARRAY OF CHAR; SkipRecords: INTEGER; SearchDirection: SearchDirectionEnum; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[3]); CtlC.IntVar(SkipRecords, arg[2]); CtlC.IntVar(SearchDirection, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1058, arg, NIL); END Find; (* ---------- Fields, dual, nonextensible ---------- *) PROCEDURE (this: Fields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Fields) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Fields) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Fields) Item* (Index: CtlT.Any): Field, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Fields) Append* (Name: ARRAY OF CHAR; Type: DataTypeEnum; DefinedSize: INTEGER; Attrib: FieldAttributeEnum), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.IntVar(Type, arg[2]); CtlC.IntVar(DefinedSize, arg[1]); CtlC.IntVar(Attrib, arg[0]); CtlC.CallParMethod(this, 1610874880, arg, NIL); END Append; PROCEDURE (this: Fields) Delete* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1610874881, arg, NIL); END Delete; (* ---------- Fields15, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Fields15) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Fields15) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Fields15) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Fields15) Item* (Index: CtlT.Any): Field, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END Item; (* ---------- Field, dual, nonextensible ---------- *) PROCEDURE (this: Field) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: Field) ActualSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1109) END ActualSize; PROCEDURE (this: Field) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1036) END Attributes; PROCEDURE (this: Field) DefinedSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1103) END DefinedSize; PROCEDURE (this: Field) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1100) END Name; PROCEDURE (this: Field) Type* (): DataTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1102) END Type; PROCEDURE (this: Field) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Field) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Field) Precision* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809351) END Precision; PROCEDURE (this: Field) NumericScale* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809352) END NumericScale; PROCEDURE (this: Field) AppendChunk* (Data: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Data, arg[0]); CtlC.CallParMethod(this, 1107, arg, NIL); END AppendChunk; PROCEDURE (this: Field) GetChunk* (Length: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 1108, arg, ret); RETURN CtlC.VarAny(ret) END GetChunk; PROCEDURE (this: Field) OriginalValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1104) END OriginalValue; PROCEDURE (this: Field) UnderlyingValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1105) END UnderlyingValue; PROCEDURE (this: Field) DataFormat* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 1610809357) END DataFormat; PROCEDURE (this: Field) PUTREFDataFormat* (p1: CtlT.IUnknown), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntfceVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1610809357, arg, NIL); END PUTREFDataFormat; PROCEDURE (this: Field) PUTPrecision* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 1610809351, p1) END PUTPrecision; PROCEDURE (this: Field) PUTNumericScale* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 1610809352, p1) END PUTNumericScale; PROCEDURE (this: Field) PUTType* (p1: DataTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1102, p1) END PUTType; PROCEDURE (this: Field) PUTDefinedSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1103, p1) END PUTDefinedSize; PROCEDURE (this: Field) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1036, p1) END PUTAttributes; (* ---------- _Parameter, dual, nonextensible ---------- *) PROCEDURE (this: _Parameter) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Parameter) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: _Parameter) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: _Parameter) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _Parameter) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _Parameter) Type* (): DataTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809348) END Type; PROCEDURE (this: _Parameter) PUTType* (p1: DataTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1610809348, p1) END PUTType; PROCEDURE (this: _Parameter) PUTDirection* (p1: ParameterDirectionEnum), NEW; BEGIN CtlC.PutInt(this, 1610809350, p1) END PUTDirection; PROCEDURE (this: _Parameter) Direction* (): ParameterDirectionEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809350) END Direction; PROCEDURE (this: _Parameter) PUTPrecision* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 1610809352, p1) END PUTPrecision; PROCEDURE (this: _Parameter) Precision* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809352) END Precision; PROCEDURE (this: _Parameter) PUTNumericScale* (p1: BYTE), NEW; BEGIN CtlC.PutByte(this, 1610809354, p1) END PUTNumericScale; PROCEDURE (this: _Parameter) NumericScale* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809354) END NumericScale; PROCEDURE (this: _Parameter) PUTSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809356, p1) END PUTSize; PROCEDURE (this: _Parameter) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809356) END Size; PROCEDURE (this: _Parameter) AppendChunk* (Val: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Val, arg[0]); CtlC.CallParMethod(this, 1610809358, arg, NIL); END AppendChunk; PROCEDURE (this: _Parameter) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809359) END Attributes; PROCEDURE (this: _Parameter) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809359, p1) END PUTAttributes; (* ---------- Parameters, dual, nonextensible ---------- *) PROCEDURE (this: Parameters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Parameters) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Parameters) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Parameters) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Parameters) Delete* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Parameters) Item* (Index: CtlT.Any): _Parameter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Parameter(CtlC.VarAny(ret)) END Item; (* ---------- _Command, dual, nonextensible ---------- *) PROCEDURE (this: _Command) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: _Command) ActiveConnection* (): _Connection, NEW; BEGIN RETURN This_Connection(CtlC.GetAny(this, 1610809344)) END ActiveConnection; PROCEDURE (this: _Command) PUTREFActiveConnection* (p1: _Connection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1610809344, arg, NIL); END PUTREFActiveConnection; PROCEDURE (this: _Command) PUTActiveConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809344, p1) END PUTActiveConnection; PROCEDURE (this: _Command) CommandText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END CommandText; PROCEDURE (this: _Command) PUTCommandText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTCommandText; PROCEDURE (this: _Command) CommandTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END CommandTimeout; PROCEDURE (this: _Command) PUTCommandTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTCommandTimeout; PROCEDURE (this: _Command) Prepared* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809351) END Prepared; PROCEDURE (this: _Command) PUTPrepared* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809351, p1) END PUTPrepared; PROCEDURE (this: _Command) Execute* (RecordsAffected: CtlT.Any; Parameters: CtlT.Any; Options: INTEGER): _Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RecordsAffected, arg[2]); CtlC.AnyVar(Parameters, arg[1]); CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809353, arg, ret); RETURN This_Recordset(CtlC.VarAny(ret)) END Execute; PROCEDURE (this: _Command) CreateParameter* (Name: ARRAY OF CHAR; Type: DataTypeEnum; Direction: ParameterDirectionEnum; Size: INTEGER; (* optional *) Value: CtlT.Any): _Parameter, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[4]); CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Direction, arg[2]); CtlC.IntVar(Size, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 1610809354, arg, ret); RETURN This_Parameter(CtlC.VarAny(ret)) END CreateParameter; PROCEDURE (this: _Command) Parameters* (): Parameters, NEW; BEGIN RETURN ThisParameters(CtlC.GetAny(this, 0)) END Parameters; PROCEDURE (this: _Command) PUTCommandType* (p1: CommandTypeEnum), NEW; BEGIN CtlC.PutInt(this, 1610809356, p1) END PUTCommandType; PROCEDURE (this: _Command) CommandType* (): CommandTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809356) END CommandType; PROCEDURE (this: _Command) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809358) END Name; PROCEDURE (this: _Command) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809358, p1) END PUTName; PROCEDURE (this: _Command) State* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874880) END State; PROCEDURE (this: _Command) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 1610874881, NIL); END Cancel; (* ---------- ConnectionEvents ---------- *) PROCEDURE (this: ConnectionEvents) InfoMessage* (pError: Error; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) BeginTransComplete* (TransactionLevel: INTEGER; pError: Error; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) CommitTransComplete* (pError: Error; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) RollbackTransComplete* (pError: Error; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) WillExecute* (VAR Source: CtlT.Strg; VAR CursorType: CursorTypeEnum; VAR LockType: LockTypeEnum; VAR Options: INTEGER; VAR adStatus: EventStatusEnum; pCommand: _Command; pRecordset: _Recordset; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) ExecuteComplete* (RecordsAffected: INTEGER; pError: Error; VAR adStatus: EventStatusEnum; pCommand: _Command; pRecordset: _Recordset; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) WillConnect* (VAR ConnectionString: CtlT.Strg; VAR UserID: CtlT.Strg; VAR Password: CtlT.Strg; VAR Options: INTEGER; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) ConnectComplete* (pError: Error; VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) Disconnect* (VAR adStatus: EventStatusEnum; pConnection: _Connection): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: ConnectionEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 0: ASSERT(n = 3, 11); CtlC.ResVar(this.InfoMessage(ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) | 1: ASSERT(n = 4, 11); CtlC.ResVar(this.BeginTransComplete(CtlC.VarInt(par[3]), ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) | 3: ASSERT(n = 3, 11); CtlC.ResVar(this.CommitTransComplete(ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) | 2: ASSERT(n = 3, 11); CtlC.ResVar(this.RollbackTransComplete(ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) | 4: ASSERT(n = 8, 11); CtlC.ResVar(this.WillExecute(CtlC.VarRefStr(par[7])[0], CtlC.VarRefInt(par[6])[0], CtlC.VarRefInt(par[5])[0], CtlC.VarRefInt(par[4])[0], CtlC.VarRefInt(par[3])[0], This_Command(CtlC.VarAny(par[2])), This_Recordset(CtlC.VarAny(par[1])), This_Connection(CtlC.VarAny(par[0]))), ret); CtlC.RetStr(par[7]) | 5: ASSERT(n = 6, 11); CtlC.ResVar(this.ExecuteComplete(CtlC.VarInt(par[5]), ThisError(CtlC.VarAny(par[4])), CtlC.VarRefInt(par[3])[0], This_Command(CtlC.VarAny(par[2])), This_Recordset(CtlC.VarAny(par[1])), This_Connection(CtlC.VarAny(par[0]))), ret) | 6: ASSERT(n = 6, 11); CtlC.ResVar(this.WillConnect(CtlC.VarRefStr(par[5])[0], CtlC.VarRefStr(par[4])[0], CtlC.VarRefStr(par[3])[0], CtlC.VarRefInt(par[2])[0], CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret); CtlC.RetStr(par[5]); CtlC.RetStr(par[4]); CtlC.RetStr(par[3]) | 7: ASSERT(n = 3, 11); CtlC.ResVar(this.ConnectComplete(ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) | 8: ASSERT(n = 2, 11); CtlC.ResVar(this.Disconnect(CtlC.VarRefInt(par[1])[0], This_Connection(CtlC.VarAny(par[0]))), ret) END END Invoke; PROCEDURE (this: ConnectionEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00000400-0000-0010-8000-00AA006D2EA4}" END GetIID; (* ---------- RecordsetEvents ---------- *) PROCEDURE (this: RecordsetEvents) WillChangeField* (cFields: INTEGER; Fields: CtlT.Any; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) FieldChangeComplete* (cFields: INTEGER; Fields: CtlT.Any; pError: Error; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) WillChangeRecord* (adReason: EventReasonEnum; cRecords: INTEGER; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) RecordChangeComplete* (adReason: EventReasonEnum; cRecords: INTEGER; pError: Error; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) WillChangeRecordset* (adReason: EventReasonEnum; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) RecordsetChangeComplete* (adReason: EventReasonEnum; pError: Error; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) WillMove* (adReason: EventReasonEnum; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) MoveComplete* (adReason: EventReasonEnum; pError: Error; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) EndOfRecordset* (VAR fMoreData: BOOLEAN; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) FetchProgress* (Progress: INTEGER; MaxProgress: INTEGER; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) FetchComplete* (pError: Error; VAR adStatus: EventStatusEnum; pRecordset: _Recordset): CtlT.RESULT, NEW, ABSTRACT; PROCEDURE (this: RecordsetEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 9: ASSERT(n = 4, 11); CtlC.ResVar(this.WillChangeField(CtlC.VarInt(par[3]), CtlC.VarAny(par[2]), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 10: ASSERT(n = 5, 11); CtlC.ResVar(this.FieldChangeComplete(CtlC.VarInt(par[4]), CtlC.VarAny(par[3]), ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 11: ASSERT(n = 4, 11); CtlC.ResVar(this.WillChangeRecord(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 12: ASSERT(n = 5, 11); CtlC.ResVar(this.RecordChangeComplete(CtlC.VarInt(par[4]), CtlC.VarInt(par[3]), ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 13: ASSERT(n = 3, 11); CtlC.ResVar(this.WillChangeRecordset(CtlC.VarInt(par[2]), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 14: ASSERT(n = 4, 11); CtlC.ResVar(this.RecordsetChangeComplete(CtlC.VarInt(par[3]), ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 15: ASSERT(n = 3, 11); CtlC.ResVar(this.WillMove(CtlC.VarInt(par[2]), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 16: ASSERT(n = 4, 11); CtlC.ResVar(this.MoveComplete(CtlC.VarInt(par[3]), ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 17: ASSERT(n = 3, 11); CtlC.ResVar(this.EndOfRecordset(CtlC.VarRefBool(par[2])[0], CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret); CtlC.RetBool(par[2]) | 18: ASSERT(n = 4, 11); CtlC.ResVar(this.FetchProgress(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) | 19: ASSERT(n = 3, 11); CtlC.ResVar(this.FetchComplete(ThisError(CtlC.VarAny(par[2])), CtlC.VarRefInt(par[1])[0], This_Recordset(CtlC.VarAny(par[0]))), ret) END END Invoke; PROCEDURE (this: RecordsetEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00000266-0000-0010-8000-00AA006D2EA4}" END GetIID; (* ---------- Field15, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Field15) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 500)) END Properties; PROCEDURE (this: Field15) ActualSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1109) END ActualSize; PROCEDURE (this: Field15) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1036) END Attributes; PROCEDURE (this: Field15) DefinedSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1103) END DefinedSize; PROCEDURE (this: Field15) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1100) END Name; PROCEDURE (this: Field15) Type* (): DataTypeEnum, NEW; BEGIN RETURN CtlC.GetInt(this, 1102) END Type; PROCEDURE (this: Field15) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Field15) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Field15) Precision* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809351) END Precision; PROCEDURE (this: Field15) NumericScale* (): BYTE, NEW; BEGIN RETURN CtlC.GetByte(this, 1610809352) END NumericScale; PROCEDURE (this: Field15) AppendChunk* (Data: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Data, arg[0]); CtlC.CallParMethod(this, 1107, arg, NIL); END AppendChunk; PROCEDURE (this: Field15) GetChunk* (Length: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 1108, arg, ret); RETURN CtlC.VarAny(ret) END GetChunk; PROCEDURE (this: Field15) OriginalValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1104) END OriginalValue; PROCEDURE (this: Field15) UnderlyingValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1105) END UnderlyingValue; PROCEDURE NewConnection* (): _Connection; BEGIN RETURN This_Connection(CtlC.NewObj("{00000514-0000-0010-8000-00AA006D2EA4}")) END NewConnection; PROCEDURE NewCommand* (): _Command; BEGIN RETURN This_Command(CtlC.NewObj("{00000507-0000-0010-8000-00AA006D2EA4}")) END NewCommand; PROCEDURE NewRecordset* (): _Recordset; BEGIN RETURN This_Recordset(CtlC.NewObj("{00000535-0000-0010-8000-00AA006D2EA4}")) END NewRecordset; PROCEDURE NewParameter* (): _Parameter; BEGIN RETURN This_Parameter(CtlC.NewObj("{0000050B-0000-0010-8000-00AA006D2EA4}")) END NewParameter; END CtlADODB.

Ctl/Mod/ADODB.odc

MODULE CtlC; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" purpose = "conversion functions for ole automation wrappers" changes = " - 20070205, bh, Unicode support - 20151012, center #76, NIL option for parameter 'par' in CtlT.OutObject.Invoke " issues = " - ... " **) IMPORT SYSTEM, COM, WinApi, WinOle, WinOleAut, CtlT; CONST nullid = WinOle.GUID_NULL; TYPE ArrAny = POINTER TO ARRAY OF CtlT.Any; ArrObj = POINTER TO ARRAY OF CtlT.Object; ArrByte = POINTER TO ARRAY OF BYTE; ArrSInt = POINTER TO ARRAY OF SHORTINT; ArrInt = POINTER TO ARRAY OF INTEGER; ArrSReal = POINTER TO ARRAY OF SHORTREAL; ArrReal = POINTER TO ARRAY OF REAL; ArrBool = POINTER TO ARRAY OF BOOLEAN; ArrRes = POINTER TO ARRAY OF COM.RESULT; ArrCy = POINTER TO ARRAY OF CtlT.OleCy; ArrDate = POINTER TO ARRAY OF CtlT.OleDate; ArrStr = POINTER TO ARRAY OF CtlT.Strg; ArrIntfce = POINTER TO ARRAY OF COM.IUnknown; Arr2Any = POINTER TO ARRAY OF ARRAY OF CtlT.Any; Arr2Obj = POINTER TO ARRAY OF ARRAY OF CtlT.Object; Arr2Byte = POINTER TO ARRAY OF ARRAY OF BYTE; Arr2SInt = POINTER TO ARRAY OF ARRAY OF SHORTINT; Arr2Int = POINTER TO ARRAY OF ARRAY OF INTEGER; Arr2SReal = POINTER TO ARRAY OF ARRAY OF SHORTREAL; Arr2Real = POINTER TO ARRAY OF ARRAY OF REAL; Arr2Bool = POINTER TO ARRAY OF ARRAY OF BOOLEAN; Arr2Res = POINTER TO ARRAY OF ARRAY OF COM.RESULT; Arr2Cy = POINTER TO ARRAY OF ARRAY OF CtlT.OleCy; Arr2Date = POINTER TO ARRAY OF ARRAY OF CtlT.OleDate; Arr2Str = POINTER TO ARRAY OF ARRAY OF CtlT.Strg; Arr2Intfce = POINTER TO ARRAY OF ARRAY OF COM.IUnknown; AnyEnum = POINTER TO RECORD (CtlT.Enumerator) enum: WinOleAut.IEnumVARIANT END; EnumWrapper = POINTER TO RECORD (WinOleAut.IEnumVARIANT) enum: CtlT.Enumerator; cur: INTEGER END; Temp = POINTER TO RECORD str: CtlT.Strg; obj: CtlT.Object; any: CtlT.Any END; VAR nullpar: WinOleAut.DISPPARAMS; (* empty parameter list *) putId: ARRAY 1 OF WinOleAut.DISPID; (* dispid of put value parameter *) (* string tools *) PROCEDURE AllocSysString (IN s: ARRAY OF CHAR): WinOle.BSTR; BEGIN RETURN WinOleAut.SysAllocString(s); END AllocSysString; PROCEDURE AllocString (s: WinOle.BSTR): CtlT.Strg; VAR i, n: INTEGER; str: CtlT.Strg; BEGIN IF s # NIL THEN n := WinOleAut.SysStringLen(s); NEW(str, n + 1); str^ := s$ ELSE NEW(str, 1); str[0] := 0X END; RETURN str END AllocString; PROCEDURE AllocSafeArray (len, elsize, flag: INTEGER; OUT arr: WinOleAut.PtrSAFEARRAY; OUT adr: INTEGER); VAR res: COM.RESULT; BEGIN res := WinOleAut.SafeArrayAllocDescriptor(1, arr); ASSERT(res >= 0, 11); arr.rgsabound[0].lLbound := 0; arr.rgsabound[0].cElements := len; arr.cbElements := elsize; arr.fFeatures := SHORT(arr.fFeatures + SHORT(flag)); res := WinOleAut.SafeArrayAllocData(arr); ASSERT(res >= 0, 11); res := WinOleAut.SafeArrayAccessData(arr, adr); ASSERT(res >= 0, 11); END AllocSafeArray; PROCEDURE AllocSafeArray2 ( len, len1, elsize, flag: INTEGER; OUT arr: WinOleAut.PtrSAFEARRAY; OUT adr: INTEGER ); VAR res: COM.RESULT; BEGIN res := WinOleAut.SafeArrayAllocDescriptor(2, arr); ASSERT(res >= 0, 11); arr.rgsabound[0].lLbound := 0; arr.rgsabound[0].cElements := len1; arr.rgsabound[1].lLbound := 0; arr.rgsabound[1].cElements := len; arr.cbElements := elsize; arr.fFeatures := SHORT(arr.fFeatures + SHORT(flag)); res := WinOleAut.SafeArrayAllocData(arr); ASSERT(res >= 0, 11); res := WinOleAut.SafeArrayAccessData(arr, adr); ASSERT(res >= 0, 11); END AllocSafeArray2; (* transformation tools to type VARIANT (not public) *) PROCEDURE ByteVar* (x: BYTE; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_UI1; var.u.bVal := SHORT(CHR(x)) END ByteVar; PROCEDURE SIntVar* (x: SHORTINT; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_I2; var.u.iVal := x END SIntVar; PROCEDURE IntVar* (x: INTEGER; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_I4; var.u.lVal := x END IntVar; PROCEDURE SRealVar* (x: SHORTREAL; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_R4; var.u.fltVal := x END SRealVar; PROCEDURE RealVar* (x: REAL; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_R8; var.u.dblVal := x END RealVar; PROCEDURE BoolVar* (x: BOOLEAN; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_BOOL; IF x THEN var.u.boolVal := -1 ELSE var.u.boolVal := 0 END END BoolVar; PROCEDURE ResVar* (x: COM.RESULT; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_ERROR; var.u.scode := x END ResVar; PROCEDURE CyVar* (x: CtlT.OleCy; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_CY; var.u.cyVal := x END CyVar; PROCEDURE DateVar* (x: CtlT.OleDate; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_DATE; var.u.date := x END DateVar; PROCEDURE StrVar* (IN str: ARRAY OF CHAR; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_BSTR; var.u.bstrVal := AllocSysString(str) END StrVar; PROCEDURE ObjVar* (obj: CtlT.Object; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_DISPATCH; var.u.pdispVal := CtlT.Disp(obj) END ObjVar; PROCEDURE IntfceVar* (unk: COM.IUnknown; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_UNKNOWN; var.u.punkVal := unk END IntfceVar; PROCEDURE EnumVar* (enum: CtlT.Enumerator; VAR var: CtlT.Variant); VAR e: EnumWrapper; BEGIN var.vt := WinOle.VT_UNKNOWN; NEW(e); e.enum := enum; var.u.punkVal := e END EnumVar; PROCEDURE^ AnyVar* (v: CtlT.Any; VAR var: CtlT.Variant); PROCEDURE ByteArrVar* (VAR x: ARRAY OF BYTE; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_UI1; AllocSafeArray(LEN(x), SIZE(BYTE), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(BYTE)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ByteArrVar; PROCEDURE SIntArrVar* (VAR x: ARRAY OF SHORTINT; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_I2; AllocSafeArray(LEN(x), SIZE(SHORTINT), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(SHORTINT)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END SIntArrVar; PROCEDURE IntArrVar* (VAR x: ARRAY OF INTEGER; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_I4; AllocSafeArray(LEN(x), SIZE(INTEGER), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(INTEGER)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END IntArrVar; PROCEDURE SRealArrVar* (VAR x: ARRAY OF SHORTREAL; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_R4; AllocSafeArray(LEN(x), SIZE(SHORTREAL), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(SHORTREAL)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END SRealArrVar; PROCEDURE RealArrVar* (VAR x: ARRAY OF REAL; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_R8; AllocSafeArray(LEN(x), SIZE(REAL), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(REAL)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END RealArrVar; PROCEDURE BoolArrVar* (VAR x: ARRAY OF BOOLEAN; VAR var: CtlT.Variant); VAR a, i: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_BOOL; AllocSafeArray(LEN(x), 2, 0, var.u.parray, a); i := 0; WHILE i < LEN(x) DO IF x[i] THEN SYSTEM.PUT(a, SHORT((* LONG( *)-1)) ELSE SYSTEM.PUT(a, SHORT((* LONG( *)0)) END; INC(a, 2); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END BoolArrVar; PROCEDURE ResArrVar* (VAR x: ARRAY OF COM.RESULT; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_ERROR; AllocSafeArray(LEN(x), SIZE(COM.RESULT), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(COM.RESULT)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ResArrVar; PROCEDURE CyArrVar* (VAR x: ARRAY OF CtlT.OleCy; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_CY; AllocSafeArray(LEN(x), SIZE(CtlT.OleCy), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(CtlT.OleCy)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END CyArrVar; PROCEDURE DateArrVar* (VAR x: ARRAY OF CtlT.OleDate; VAR var: CtlT.Variant); VAR a: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_DATE; AllocSafeArray(LEN(x), SIZE(CtlT.OleDate), 0, var.u.parray, a); SYSTEM.MOVE(SYSTEM.ADR(x), a, LEN(x) * SIZE(CtlT.OleDate)); res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END DateArrVar; PROCEDURE StrArrVar* (VAR x: ARRAY OF CtlT.Strg; VAR var: CtlT.Variant); VAR a, i: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_BSTR; AllocSafeArray(LEN(x), SIZE(WinOle.BSTR), WinOleAut.FADF_BSTR, var.u.parray, a); i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, AllocSysString(x[i]^)); INC(a, SIZE(WinOle.BSTR)); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END StrArrVar; PROCEDURE ObjArrVar* (VAR x: ARRAY OF CtlT.Object; VAR var: CtlT.Variant); VAR i: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF WinOleAut.IDispatch; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_DISPATCH; AllocSafeArray( LEN(x), SIZE(WinOleAut.IDispatch), WinOleAut.FADF_DISPATCH, var.u.parray, SYSTEM.VAL(INTEGER, p)); i := 0; WHILE i < LEN(x) DO p[i] := CtlT.Disp(x[i]); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ObjArrVar; PROCEDURE IntfceArrVar* (VAR x: ARRAY OF COM.IUnknown; VAR var: CtlT.Variant); VAR i: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF COM.IUnknown; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_UNKNOWN; AllocSafeArray( LEN(x), SIZE(COM.IUnknown), WinOleAut.FADF_UNKNOWN, var.u.parray, SYSTEM.VAL(INTEGER, p)); i := 0; WHILE i < LEN(x) DO p[i] := x[i]; INC(i) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END IntfceArrVar; PROCEDURE AnyArrVar* (VAR x: ARRAY OF CtlT.Any; VAR var: CtlT.Variant); VAR i: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF CtlT.Variant; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_VARIANT; AllocSafeArray(LEN(x), SIZE(CtlT.Variant), WinOleAut.FADF_VARIANT, var.u.parray, SYSTEM.VAL(INTEGER, p)); i := 0; WHILE i < LEN(x) DO AnyVar(x[i], p[i]); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END AnyArrVar; PROCEDURE ByteArr2Var* (VAR x: ARRAY OF ARRAY OF BYTE; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_UI1; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(BYTE), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(BYTE)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ByteArr2Var; PROCEDURE SIntArr2Var* (VAR x: ARRAY OF ARRAY OF SHORTINT; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_I2; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(SHORTINT), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(SHORTINT)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END SIntArr2Var; PROCEDURE IntArr2Var* (VAR x: ARRAY OF ARRAY OF INTEGER; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_I4; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(INTEGER), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(INTEGER)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END IntArr2Var; PROCEDURE SRealArr2Var* (VAR x: ARRAY OF ARRAY OF SHORTREAL; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_R4; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(SHORTREAL), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(SHORTREAL)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END SRealArr2Var; PROCEDURE RealArr2Var* (VAR x: ARRAY OF ARRAY OF REAL; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_R8; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(REAL), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(REAL)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END RealArr2Var; PROCEDURE BoolArr2Var* (VAR x: ARRAY OF ARRAY OF BOOLEAN; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_BOOL; AllocSafeArray2(LEN(x), LEN(x, 1), 2, 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO IF x[i, j] THEN SYSTEM.PUT(a, SHORT((* LONG( *)-1)) ELSE SYSTEM.PUT(a, SHORT((* LONG( *)0)) END; INC(a, 2); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END BoolArr2Var; PROCEDURE ResArr2Var* (VAR x: ARRAY OF ARRAY OF COM.RESULT; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_ERROR; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(COM.RESULT), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(COM.RESULT)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ResArr2Var; PROCEDURE CyArr2Var* (VAR x: ARRAY OF ARRAY OF CtlT.OleCy; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_CY; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(CtlT.OleCy), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(CtlT.OleCy)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END CyArr2Var; PROCEDURE DateArr2Var* (VAR x: ARRAY OF ARRAY OF CtlT.OleDate; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_DATE; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(CtlT.OleDate), 0, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, x[i, j]); INC(a, SIZE(CtlT.OleDate)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END DateArr2Var; PROCEDURE StrArr2Var* (VAR x: ARRAY OF ARRAY OF CtlT.Strg; VAR var: CtlT.Variant); VAR a, i, j: INTEGER; res: COM.RESULT; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_BSTR; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(WinOle.BSTR), WinOleAut.FADF_BSTR, var.u.parray, a); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO SYSTEM.PUT(a, AllocSysString(x[i, j]^)); INC(a, SIZE(WinOle.BSTR)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END StrArr2Var; PROCEDURE ObjArr2Var* (VAR x: ARRAY OF ARRAY OF CtlT.Object; VAR var: CtlT.Variant); VAR i, j: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF WinOleAut.IDispatch; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_DISPATCH; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(WinOleAut.IDispatch), WinOleAut.FADF_DISPATCH, var.u.parray, SYSTEM.VAL(INTEGER, p)); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO p[i] := CtlT.Disp(x[i, j]); INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(WinOleAut.IDispatch) * LEN(x)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END ObjArr2Var; PROCEDURE IntfceArr2Var* (VAR x: ARRAY OF ARRAY OF COM.IUnknown; VAR var: CtlT.Variant); VAR i, j: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF COM.IUnknown; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_UNKNOWN; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(COM.IUnknown), WinOleAut.FADF_UNKNOWN, var.u.parray, SYSTEM.VAL(INTEGER, p)); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO p[i] := x[i, j]; INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(COM.IUnknown) * LEN(x)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END IntfceArr2Var; PROCEDURE AnyArr2Var* (VAR x: ARRAY OF ARRAY OF CtlT.Any; VAR var: CtlT.Variant); VAR i, j: INTEGER; res: COM.RESULT; p: POINTER TO ARRAY [untagged] OF CtlT.Variant; BEGIN var.vt := WinOle.VT_ARRAY + WinOle.VT_VARIANT; AllocSafeArray2(LEN(x), LEN(x, 1), SIZE(CtlT.Variant), WinOleAut.FADF_VARIANT, var.u.parray, SYSTEM.VAL(INTEGER, p)); j := 0; WHILE j < LEN(x, 1) DO i := 0; WHILE i < LEN(x) DO AnyVar(x[i, j], p[i]); INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(CtlT.Variant) * LEN(x)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(var.u.parray); END AnyArr2Var; PROCEDURE AnyVar* (v: CtlT.Any; VAR var: CtlT.Variant); BEGIN IF v # NIL THEN IF v.dim = 0 THEN var.vt := v.typeId; CASE v.typeId OF | CtlT.byte: var.u.bVal := SHORT(CHR(v(CtlT.ByteT).val)) | CtlT.shortint: var.u.iVal := v(CtlT.ShortInt).val | CtlT.integer: var.u.lVal := v(CtlT.Integer).val | CtlT.shortreal: var.u.fltVal := v(CtlT.ShortReal).val | CtlT.real: var.u.dblVal := v(CtlT.RealT).val | CtlT.boolean: IF v(CtlT.Boolean).val THEN var.u.boolVal := -1 ELSE var.u.boolVal := 0 END | CtlT.result: var.u.scode:= v(CtlT.Result).val | CtlT.object: var.u.pdispVal := CtlT.Disp(v(CtlT.Object)) | CtlT.interface: var.u.punkVal := v(CtlT.Interface).val | CtlT.currency: var.u.cyVal := v(CtlT.Currency).val | CtlT.date: var.u.date := v(CtlT.DateT).val | CtlT.string: var.u.bstrVal := AllocSysString(v(CtlT.String).val^); END ELSIF v.dim = 1 THEN CASE v.typeId OF | CtlT.byte: ByteArrVar(v(CtlT.ByteArray).p^, var) | CtlT.shortint: SIntArrVar(v(CtlT.ShortIntArray).p^, var) | CtlT.integer: IntArrVar(v(CtlT.IntegerArray).p^, var) | CtlT.shortreal: SRealArrVar(v(CtlT.ShortRealArray).p^, var) | CtlT.real: RealArrVar(v(CtlT.RealArray).p^, var) | CtlT.boolean: BoolArrVar(v(CtlT.BooleanArray).p^, var) | CtlT.result: ResArrVar(v(CtlT.ResultArray).p^, var) | CtlT.object: ObjArrVar(v(CtlT.ObjectArray).p^, var) | CtlT.interface: IntfceArrVar(v(CtlT.InterfaceArray).p^, var) | CtlT.currency: CyArrVar(v(CtlT.CurrencyArray).p^, var) | CtlT.date: DateArrVar(v(CtlT.DateArray).p^, var) | CtlT.string: StrArrVar(v(CtlT.StringArray).p^, var) | CtlT.any: AnyArrVar(v(CtlT.AnyArray).p^, var) END ELSIF v.dim = 2 THEN CASE v.typeId OF | CtlT.byte: ByteArr2Var(v(CtlT.ByteArray2).p^, var) | CtlT.shortint: SIntArr2Var(v(CtlT.ShortIntArray2).p^, var) | CtlT.integer: IntArr2Var(v(CtlT.IntegerArray2).p^, var) | CtlT.shortreal: SRealArr2Var(v(CtlT.ShortRealArray2).p^, var) | CtlT.real: RealArr2Var(v(CtlT.RealArray2).p^, var) | CtlT.boolean: BoolArr2Var(v(CtlT.BooleanArray2).p^, var) | CtlT.result: ResArr2Var(v(CtlT.ResultArray2).p^, var) | CtlT.object: ObjArr2Var(v(CtlT.ObjectArray2).p^, var) | CtlT.interface: IntfceArr2Var(v(CtlT.InterfaceArray2).p^, var) | CtlT.currency: CyArr2Var(v(CtlT.CurrencyArray2).p^, var) | CtlT.date: DateArr2Var(v(CtlT.DateArray2).p^, var) | CtlT.string: StrArr2Var(v(CtlT.StringArray2).p^, var) | CtlT.any: AnyArr2Var(v(CtlT.AnyArray2).p^, var) END ELSE HALT(100) END ELSE var.vt := WinOle.VT_EMPTY END END AnyVar; PROCEDURE RefByteVar* (VAR x: BYTE; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_UI1 + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefByteVar; PROCEDURE RefSIntVar* (VAR x: SHORTINT; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_I2 + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefSIntVar; PROCEDURE RefIntVar* (VAR x: INTEGER; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_I4 + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefIntVar; PROCEDURE RefSRealVar* (VAR x: SHORTREAL; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_R4 + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefSRealVar; PROCEDURE RefRealVar* (VAR x: REAL; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_R8 + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefRealVar; PROCEDURE RefResVar* (VAR x: COM.RESULT; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_ERROR + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefResVar; PROCEDURE RefCyVar* (VAR x: CtlT.OleCy; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_CY + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefCyVar; PROCEDURE RefDateVar* (VAR x: CtlT.OleDate; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_DATE + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefDateVar; PROCEDURE RefIntfceVar* (VAR unk: COM.IUnknown; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_UNKNOWN + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(unk) END RefIntfceVar; PROCEDURE RefBoolVar* (VAR x: CtlT.Variant; VAR var: CtlT.Variant); BEGIN x.vt := WinOle.VT_BOOL; var.vt := WinOle.VT_BOOL + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x.u.boolVal) END RefBoolVar; PROCEDURE RefStrVar* (VAR x: CtlT.Variant; VAR var: CtlT.Variant); BEGIN x.vt := WinOle.VT_BSTR; var.vt := WinOle.VT_BSTR + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x.u.bstrVal) END RefStrVar; PROCEDURE RefObjVar* (VAR x: CtlT.Variant; VAR var: CtlT.Variant); BEGIN x.vt := WinOle.VT_DISPATCH; var.vt := WinOle.VT_DISPATCH + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x.u.pdispVal) END RefObjVar; PROCEDURE RefAnyVar* (VAR x: CtlT.Variant; VAR var: CtlT.Variant); BEGIN var.vt := WinOle.VT_VARIANT + WinOle.VT_BYREF; var.u.byref := SYSTEM.ADR(x) END RefAnyVar; (* PROCEDURE BoolRefVar* (x: BOOLEAN; VAR var: CtlT.Variant); BEGIN ASSERT(var.vt = WinOle.VT_BOOL + WinOle.VT_BYREF, 100); IF x THEN var.u.pboolVal[0] := -1 ELSE var.u.pboolVal[0] := 0 END END BoolRefVar; PROCEDURE StrRefVar* (IN str: ARRAY OF CHAR; VAR var: CtlT.Variant); BEGIN ASSERT(var.vt = WinOle.VT_BSTR + WinOle.VT_BYREF, 100); var.u.pbstrVal[0] := AllocSysString(str) END StrRefVar; PROCEDURE ObjRefVar* (obj: CtlT.Object; VAR var: CtlT.Variant); BEGIN ASSERT(var.vt = WinOle.VT_DISPATCH + WinOle.VT_BYREF, 100); var.u.ppdispVal[0] := CtlT.Disp(obj) END ObjRefVar; PROCEDURE AnyRefVar* (v: CtlT.Any; VAR var: CtlT.Variant); BEGIN ASSERT(var.vt = WinOle.VT_DISPATCH + WinOle.VT_VARIANT, 100); AnyVar(v, var.u.pvarVal^) END AnyRefVar; *) (* transformation tools from type VARIANT (not public) *) PROCEDURE^ VarAny* (VAR v: CtlT.Variant): CtlT.Any; PROCEDURE VarByte* (VAR v: CtlT.Variant): BYTE; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_UI1 THEN RETURN SHORT(ORD(v.u.pbVal[0])) ELSE ASSERT(v.vt = WinOle.VT_UI1, 100); RETURN SHORT(ORD(v.u.bVal)) END END VarByte; PROCEDURE VarSInt* (VAR v: CtlT.Variant): SHORTINT; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_I2 THEN RETURN v.u.piVal[0] ELSE ASSERT(v.vt = WinOle.VT_I2, 100); RETURN v.u.iVal END END VarSInt; PROCEDURE VarInt* (VAR v: CtlT.Variant): INTEGER; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_I4 THEN RETURN v.u.plVal[0] ELSE ASSERT(v.vt = WinOle.VT_I4, 100); RETURN v.u.lVal END END VarInt; PROCEDURE VarSReal* (VAR v: CtlT.Variant): SHORTREAL; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_R4 THEN RETURN v.u.pfltVal[0] ELSE ASSERT(v.vt = WinOle.VT_R4, 100); RETURN v.u.fltVal END END VarSReal; PROCEDURE VarReal* (VAR v: CtlT.Variant): REAL; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_R8 THEN RETURN v.u.pdblVal[0] ELSE ASSERT(v.vt = WinOle.VT_R8, 100); RETURN v.u.dblVal END END VarReal; PROCEDURE VarBool* (VAR v: CtlT.Variant): BOOLEAN; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_BOOL THEN RETURN v.u.pboolVal[0] # 0 ELSE ASSERT(v.vt = WinOle.VT_BOOL, 100); RETURN v.u.boolVal # 0 END END VarBool; PROCEDURE VarRes* (VAR v: CtlT.Variant): COM.RESULT; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_ERROR THEN RETURN v.u.pscode[0] ELSE ASSERT(v.vt = WinOle.VT_ERROR, 100); RETURN v.u.scode END END VarRes; PROCEDURE VarCy* (VAR v: CtlT.Variant): CtlT.OleCy; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_CY THEN RETURN v.u.pcyVal[0] ELSE ASSERT(v.vt = WinOle.VT_CY, 100); RETURN v.u.cyVal END END VarCy; PROCEDURE VarDate* (VAR v: CtlT.Variant): CtlT.OleDate; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_DATE THEN RETURN v.u.pdate[0] ELSE ASSERT(v.vt = WinOle.VT_DATE, 100); RETURN v.u.date END END VarDate; PROCEDURE VarStr* (VAR v: CtlT.Variant): CtlT.Strg; VAR s: CtlT.Strg; res: COM.RESULT; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_BSTR THEN s := AllocString(v.u.pbstrVal[0]) ELSE ASSERT(v.vt = WinOle.VT_BSTR, 100); s := AllocString(v.u.bstrVal) END; res := WinOleAut.VariantClear(v); RETURN s END VarStr; PROCEDURE VarObj* (VAR v: CtlT.Variant): CtlT.Object; VAR obj: CtlT.Object; res: COM.RESULT; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_DISPATCH THEN obj := CtlT.Obj(v.u.ppdispVal[0]) ELSE ASSERT(v.vt = WinOle.VT_DISPATCH, 100); obj := CtlT.Obj(v.u.pdispVal) END; res := WinOleAut.VariantClear(v); RETURN obj END VarObj; PROCEDURE VarIntfce* (VAR v: CtlT.Variant): COM.IUnknown; VAR unk: COM.IUnknown; res: COM.RESULT; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_UNKNOWN THEN unk := v.u.ppunkVal[0] ELSE ASSERT(v.vt = WinOle.VT_UNKNOWN, 100); unk := v.u.punkVal END; res := WinOleAut.VariantClear(v); RETURN unk END VarIntfce; PROCEDURE VarEnum* (VAR v: CtlT.Variant): CtlT.Enumerator; VAR enum: WinOleAut.IEnumVARIANT; res: COM.RESULT; e: AnyEnum; BEGIN IF v.vt = WinOle.VT_BYREF + WinOle.VT_UNKNOWN THEN res := v.u.ppunkVal[0].QueryInterface(COM.ID(enum), enum) ELSE ASSERT(v.vt = WinOle.VT_UNKNOWN, 100); res := v.u.punkVal.QueryInterface(COM.ID(enum), enum) END; ASSERT(res >= 0, 100); res := WinOleAut.VariantClear(v); NEW(e); e.enum := enum; RETURN e END VarEnum; PROCEDURE VarByteArr* (VAR v: CtlT.Variant): ArrByte; VAR x: ArrByte; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_UI1, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(BYTE)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarByteArr; PROCEDURE VarSIntArr* (VAR v: CtlT.Variant): ArrSInt; VAR x: ArrSInt; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_I2, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(SHORTINT)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarSIntArr; PROCEDURE VarIntArr* (VAR v: CtlT.Variant): ArrInt; VAR x: ArrInt; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_I4, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(INTEGER)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarIntArr; PROCEDURE VarSRealArr* (VAR v: CtlT.Variant): ArrSReal; VAR x: ArrSReal; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_R4, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(SHORTREAL)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarSRealArr; PROCEDURE VarRealArr* (VAR v: CtlT.Variant): ArrReal; VAR x: ArrReal; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_R8, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(REAL)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarRealArr; PROCEDURE VarBoolArr* (VAR v: CtlT.Variant): ArrBool; VAR x: ArrBool; i, a: INTEGER; res: COM.RESULT; b: SHORTINT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_BOOL, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, b); x[i] := b # 0 ; INC(a, 2); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarBoolArr; PROCEDURE VarResArr* (VAR v: CtlT.Variant): ArrRes; VAR x: ArrRes; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_ERROR, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(COM.RESULT)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarResArr; PROCEDURE VarCyArr* (VAR v: CtlT.Variant): ArrCy; VAR x: ArrCy; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_CY, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(CtlT.OleCy)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarCyArr; PROCEDURE VarDateArr* (VAR v: CtlT.Variant): ArrDate; VAR x: ArrDate; a: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DATE, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); SYSTEM.MOVE(a, SYSTEM.ADR(x^), LEN(x^) * SIZE(CtlT.OleDate)); res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarDateArr; PROCEDURE VarStrArr* (VAR v: CtlT.Variant): ArrStr; VAR x: ArrStr; i, a: INTEGER; res: COM.RESULT; s: WinOle.BSTR; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DATE, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, s); x[i] := AllocString(s); INC(a, SIZE(WinOle.BSTR)); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarStrArr; PROCEDURE VarObjArr* (VAR v: CtlT.Variant): ArrObj; VAR x: ArrObj; i: INTEGER; p: POINTER TO ARRAY [untagged] OF WinOleAut.IDispatch; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DISPATCH, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); i := 0; WHILE i < LEN(x^) DO x[i] := CtlT.Obj(p[i]); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarObjArr; PROCEDURE VarIntfceArr* (VAR v: CtlT.Variant): ArrIntfce; VAR x: ArrIntfce; i: INTEGER; p: POINTER TO ARRAY [untagged] OF COM.IUnknown; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_UNKNOWN, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); i := 0; WHILE i < LEN(x^) DO x[i] := p[i]; INC(i) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarIntfceArr; PROCEDURE VarAnyArr* (VAR v: CtlT.Variant): ArrAny; VAR x: ArrAny; i: INTEGER; p: POINTER TO ARRAY [untagged] OF CtlT.Variant; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_VARIANT, 100); ASSERT(v.u.parray.cDims = 1, 100); NEW(x, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); i := 0; WHILE i < LEN(x^) DO x[i] := VarAny(p[i]); INC(i) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarAnyArr; PROCEDURE VarByteArr2* (VAR v: CtlT.Variant): Arr2Byte; VAR x: Arr2Byte; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_UI1, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(BYTE)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarByteArr2; PROCEDURE VarSIntArr2* (VAR v: CtlT.Variant): Arr2SInt; VAR x: Arr2SInt; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_I2, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(SHORTINT)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarSIntArr2; PROCEDURE VarIntArr2* (VAR v: CtlT.Variant): Arr2Int; VAR x: Arr2Int; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_I4, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(INTEGER)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarIntArr2; PROCEDURE VarSRealArr2* (VAR v: CtlT.Variant): Arr2SReal; VAR x: Arr2SReal; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_R4, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(SHORTREAL)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarSRealArr2; PROCEDURE VarRealArr2* (VAR v: CtlT.Variant): Arr2Real; VAR x: Arr2Real; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_R8, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(REAL)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarRealArr2; PROCEDURE VarBoolArr2* (VAR v: CtlT.Variant): Arr2Bool; VAR x: Arr2Bool; a, i, j: INTEGER; res: COM.RESULT; b: SHORTINT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_BOOL, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, b); x[i, j] := b # 0; INC(a, 2); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarBoolArr2; PROCEDURE VarResArr2* (VAR v: CtlT.Variant): Arr2Res; VAR x: Arr2Res; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_ERROR, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(COM.RESULT)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarResArr2; PROCEDURE VarCyArr2* (VAR v: CtlT.Variant): Arr2Cy; VAR x: Arr2Cy; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_CY, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(CtlT.OleCy)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarCyArr2; PROCEDURE VarDateArr2* (VAR v: CtlT.Variant): Arr2Date; VAR x: Arr2Date; a, i, j: INTEGER; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DATE, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, x[i, j]); INC(a, SIZE(CtlT.OleDate)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarDateArr2; PROCEDURE VarStrArr2* (VAR v: CtlT.Variant): Arr2Str; VAR x: Arr2Str; a, i, j: INTEGER; res: COM.RESULT; s: WinOle.BSTR; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DATE, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, a); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO SYSTEM.GET(a, s); x[i, j] := AllocString(s); INC(a, SIZE(WinOle.BSTR)); INC(i) END; INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarStrArr2; PROCEDURE VarObjArr2* (VAR v: CtlT.Variant): Arr2Obj; VAR x: Arr2Obj; i, j: INTEGER; p: POINTER TO ARRAY [untagged] OF WinOleAut.IDispatch; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_DISPATCH, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO x[i, j] := CtlT.Obj(p[i]); INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(WinOleAut.IDispatch) * LEN(x^)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarObjArr2; PROCEDURE VarIntfceArr2* (VAR v: CtlT.Variant): Arr2Intfce; VAR x: Arr2Intfce; i, j: INTEGER; p: POINTER TO ARRAY [untagged] OF COM.IUnknown; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_UNKNOWN, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO x[i, j] := p[i]; INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(COM.IUnknown) * LEN(x^)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarIntfceArr2; PROCEDURE VarAnyArr2* (VAR v: CtlT.Variant): Arr2Any; VAR x: Arr2Any; i, j: INTEGER; p: POINTER TO ARRAY [untagged] OF CtlT.Variant; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ARRAY + WinOle.VT_VARIANT, 100); ASSERT(v.u.parray.cDims = 2, 100); NEW(x, v.u.parray.rgsabound[1].cElements, v.u.parray.rgsabound[0].cElements); res := WinOleAut.SafeArrayAccessData(v.u.parray, SYSTEM.VAL(INTEGER, p)); ASSERT(res >= 0, 11); j := 0; WHILE j < LEN(x^, 1) DO i := 0; WHILE i < LEN(x^) DO x[i, j] := VarAny(p[i]); INC(i) END; INC(SYSTEM.VAL(INTEGER, p), SIZE(CtlT.Variant) * LEN(x^)); INC(j) END; res := WinOleAut.SafeArrayUnaccessData(v.u.parray); res := WinOleAut.VariantClear(v); RETURN x END VarAnyArr2; PROCEDURE VarAny* (VAR v: CtlT.Variant): CtlT.Any; CONST c0 = 693596; (* 1.1.1900 - 2 *) VAR c: CtlT.ByteT; i: CtlT.ShortInt; l: CtlT.Integer; r: CtlT.ShortReal; lr: CtlT.RealT; b: CtlT.Boolean; cy: CtlT.Currency; d: CtlT.DateT; s: CtlT.String; e: CtlT.Result; int: CtlT.Interface; res: COM.RESULT; ca: CtlT.ByteArray; ia: CtlT.ShortIntArray; la: CtlT.IntegerArray; ra: CtlT.ShortRealArray; lra: CtlT.RealArray; ba: CtlT.BooleanArray; cya: CtlT.CurrencyArray; da: CtlT.DateArray; sa: CtlT.StringArray; ea: CtlT.ResultArray; obja: CtlT.ObjectArray; inta: CtlT.InterfaceArray; aa: CtlT.AnyArray; ca2: CtlT.ByteArray2; ia2: CtlT.ShortIntArray2; la2: CtlT.IntegerArray2; ra2: CtlT.ShortRealArray2; lra2: CtlT.RealArray2; ba2: CtlT.BooleanArray2; cya2: CtlT.CurrencyArray2; da2: CtlT.DateArray2; sa2: CtlT.StringArray2; ea2: CtlT.ResultArray2; obja2: CtlT.ObjectArray2; inta2: CtlT.InterfaceArray2; aa2: CtlT.AnyArray2; BEGIN IF ODD(v.vt DIV WinOle.VT_ARRAY) THEN ASSERT(~ODD(v.vt DIV WinOle.VT_BYREF), 100); IF v.u.parray.cDims = 1 THEN CASE v.vt MOD 4096 OF | WinOle.VT_UI1: NEW(ca); ca.typeId := CtlT.byte; ca.dim := 1; ca.p := VarByteArr(v); RETURN ca | WinOle.VT_I2: NEW(ia); ia.typeId := CtlT.shortint; ia.dim := 1; ia.p := VarSIntArr(v); RETURN ia | WinOle.VT_I4: NEW(la); la.typeId := CtlT.integer; la.dim := 1; la.p := VarIntArr(v); RETURN la | WinOle.VT_R4: NEW(ra); ra.typeId := CtlT.shortreal; ra.dim := 1; ra.p := VarSRealArr(v); RETURN ra | WinOle.VT_R8: NEW(lra); lra.typeId := CtlT.real; lra.dim := 1; lra.p := VarRealArr(v); RETURN lra | WinOle.VT_BOOL: NEW(ba); ba.typeId := CtlT.boolean; ba.dim := 1; ba.p := VarBoolArr(v); RETURN ba | WinOle.VT_CY: NEW(cya); cya.typeId := CtlT.currency; cya.dim := 1; cya.p := VarCyArr(v); RETURN cya | WinOle.VT_DATE: NEW(da); da.typeId := CtlT.date; da.dim := 1; da.p := VarDateArr(v); RETURN da | WinOle.VT_ERROR: NEW(ea); ea.typeId := CtlT.result; ea.dim := 1; ea.p := VarResArr(v); RETURN ea | WinOle.VT_DISPATCH: NEW(obja); obja.typeId := CtlT.object; obja.dim := 1; obja.p := VarObjArr(v); RETURN obja | WinOle.VT_UNKNOWN: NEW(inta); inta.typeId := CtlT.interface; inta.dim := 1; inta.p := VarIntfceArr(v); RETURN inta | WinOle.VT_BSTR: NEW(sa); sa.typeId := CtlT.string; sa.dim := 1; sa.p := VarStrArr(v); RETURN sa | WinOle.VT_VARIANT: NEW(aa); aa.typeId := CtlT.any; aa.dim := 1; aa.p := VarAnyArr(v); RETURN aa END ELSIF v.u.parray.cDims = 2 THEN CASE v.vt MOD 4096 OF | WinOle.VT_UI1: NEW(ca2); ca2.typeId := CtlT.byte; ca2.dim := 2; ca2.p := VarByteArr2(v); RETURN ca2 | WinOle.VT_I2: NEW(ia2); ia2.typeId := CtlT.shortint; ia2.dim := 2; ia2.p := VarSIntArr2(v); RETURN ia2 | WinOle.VT_I4: NEW(la2); la2.typeId := CtlT.integer; la2.dim := 2; la2.p := VarIntArr2(v); RETURN la2 | WinOle.VT_R4: NEW(ra2); ra2.typeId := CtlT.shortreal; ra2.dim := 2; ra2.p := VarSRealArr2(v); RETURN ra2 | WinOle.VT_R8: NEW(lra2); lra2.typeId := CtlT.real; lra2.dim := 2; lra2.p := VarRealArr2(v); RETURN lra2 | WinOle.VT_BOOL: NEW(ba2); ba2.typeId := CtlT.boolean; ba2.dim := 2; ba2.p := VarBoolArr2(v); RETURN ba2 | WinOle.VT_CY: NEW(cya2); cya2.typeId := CtlT.currency; cya2.dim := 2; cya2.p := VarCyArr2(v); RETURN cya2 | WinOle.VT_DATE: NEW(da2); da2.typeId := CtlT.date; da2.dim := 2; da2.p := VarDateArr2(v); RETURN da2 | WinOle.VT_ERROR: NEW(ea2); ea2.typeId := CtlT.result; ea2.dim := 2; ea2.p := VarResArr2(v); RETURN ea2 | WinOle.VT_DISPATCH: NEW(obja2); obja2.typeId := CtlT.object; obja2.dim := 2; obja2.p := VarObjArr2(v); RETURN obja2 | WinOle.VT_UNKNOWN: NEW(inta2); inta2.typeId := CtlT.interface; inta2.dim := 2; inta2.p := VarIntfceArr2(v); RETURN inta2 | WinOle.VT_BSTR: NEW(sa2); sa2.typeId := CtlT.string; sa2.dim := 2; sa2.p := VarStrArr2(v); RETURN sa2 | WinOle.VT_VARIANT: NEW(aa2); aa2.typeId := CtlT.any; aa2.dim := 2; aa2.p := VarAnyArr2(v); RETURN aa2 END ELSE HALT(100) END ELSIF ODD(v.vt DIV WinOle.VT_BYREF) THEN CASE v.vt MOD 4096 OF | WinOle.VT_UI1: NEW(c); c.typeId := CtlT.byte; c.val := SHORT(ORD(v.u.pbVal[0])); RETURN c | WinOle.VT_I2: NEW(i); i.typeId := CtlT.shortint; i.val := v.u.piVal[0]; RETURN i | WinOle.VT_I4: NEW(l); l.typeId := CtlT.integer; l.val := v.u.plVal[0]; RETURN l | WinOle.VT_R4: NEW(r); r.typeId := CtlT.shortreal; r.val := v.u.pfltVal[0]; RETURN r | WinOle.VT_R8: NEW(lr); lr.typeId := CtlT.real; lr.val := v.u.pdblVal[0]; RETURN lr | WinOle.VT_BOOL: NEW(b); b.typeId := CtlT.boolean; b.val := v.u.pboolVal[0] # 0; RETURN b | WinOle.VT_CY: NEW(cy); cy.typeId := CtlT.currency; cy.val := v.u.pcyVal[0]; RETURN cy | WinOle.VT_DATE: NEW(d); d.typeId := CtlT.date; d.val := v.u.pdate[0]; RETURN d | WinOle.VT_ERROR: NEW(e); e.typeId := CtlT.result; e.val := v.u.pscode[0]; RETURN e | WinOle.VT_DISPATCH: RETURN CtlT.Obj(v.u.ppdispVal[0]) | WinOle.VT_UNKNOWN: NEW(int); int.typeId := CtlT.interface; int.val := v.u.ppunkVal[0]; RETURN int | WinOle.VT_BSTR: NEW(s); s.typeId := CtlT.string; s.val := AllocString(v.u.pbstrVal[0]); RETURN s | WinOle.VT_VARIANT: RETURN VarAny(v.u.pvarVal^) END ELSE CASE v.vt MOD 4096 OF | WinOle.VT_EMPTY: RETURN NIL | WinOle.VT_UI1: NEW(c); c.typeId := CtlT.byte; c.val := SHORT(ORD(v.u.bVal)); RETURN c | WinOle.VT_I2: NEW(i); i.typeId := CtlT.shortint; i.val := v.u.iVal; RETURN i | WinOle.VT_I4: NEW(l); l.typeId := CtlT.integer; l.val := v.u.lVal; RETURN l | WinOle.VT_R4: NEW(r); r.typeId := CtlT.shortreal; r.val := v.u.fltVal; RETURN r | WinOle.VT_R8: NEW(lr); lr.typeId := CtlT.real; lr.val := v.u.dblVal; RETURN lr | WinOle.VT_BOOL: NEW(b); b.typeId := CtlT.boolean; b.val := v.u.boolVal # 0; RETURN b | WinOle.VT_CY: NEW(cy); cy.typeId := CtlT.currency; cy.val := v.u.cyVal; RETURN cy | WinOle.VT_DATE: NEW(d); d.typeId := CtlT.date; d.val := v.u.date; RETURN d | WinOle.VT_ERROR: NEW(e); e.typeId := CtlT.result; e.val := v.u.scode; RETURN e | WinOle.VT_DISPATCH: RETURN CtlT.Obj(v.u.pdispVal) | WinOle.VT_UNKNOWN: NEW(int); int.typeId := CtlT.interface; int.val := v.u.punkVal; RETURN int | WinOle.VT_BSTR: NEW(s); s.typeId := CtlT.string; s.val := AllocString(v.u.bstrVal); RETURN s END END; res := WinOleAut.VariantClear(v) END VarAny; PROCEDURE VarRefByte* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF BYTE; TYPE T = POINTER TO ARRAY [untagged] OF BYTE; BEGIN ASSERT(v.vt = WinOle.VT_UI1 + WinOle.VT_BYREF, 100); RETURN SYSTEM.VAL(T, v.u.pbVal) END VarRefByte; PROCEDURE VarRefSInt* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF SHORTINT; BEGIN ASSERT(v.vt = WinOle.VT_I2 + WinOle.VT_BYREF, 100); RETURN v.u.piVal END VarRefSInt; PROCEDURE VarRefInt* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF INTEGER; BEGIN ASSERT(v.vt = WinOle.VT_I4 + WinOle.VT_BYREF, 100); RETURN v.u.plVal END VarRefInt; PROCEDURE VarRefSReal* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF SHORTREAL; BEGIN ASSERT(v.vt = WinOle.VT_R4 + WinOle.VT_BYREF, 100); RETURN v.u.pfltVal END VarRefSReal; PROCEDURE VarRefReal* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF REAL; BEGIN ASSERT(v.vt = WinOle.VT_R8 + WinOle.VT_BYREF, 100); RETURN v.u.pdblVal END VarRefReal; PROCEDURE VarRefRes* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_ERROR + WinOle.VT_BYREF, 100); RETURN v.u.pscode END VarRefRes; PROCEDURE VarRefCy* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF CtlT.OleCy; BEGIN ASSERT(v.vt = WinOle.VT_CY + WinOle.VT_BYREF, 100); RETURN v.u.pcyVal END VarRefCy; PROCEDURE VarRefDate* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF CtlT.OleDate; BEGIN ASSERT(v.vt = WinOle.VT_DATE + WinOle.VT_BYREF, 100); RETURN v.u.pdate END VarRefDate; PROCEDURE VarRefIntfce* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF COM.IUnknown; VAR unk: POINTER TO ARRAY [untagged] OF COM.IUnknown; res: COM.RESULT; BEGIN ASSERT(v.vt = WinOle.VT_UNKNOWN + WinOle.VT_BYREF, 100); unk := v.u.ppunkVal; res := WinOleAut.VariantClear(v); RETURN unk END VarRefIntfce; PROCEDURE VarRefBool* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF BOOLEAN; TYPE PB = POINTER TO ARRAY [untagged] OF BOOLEAN; BEGIN ASSERT(v.vt = WinOle.VT_BOOL + WinOle.VT_BYREF, 100); v.sign := SYSTEM.VAL(SHORTCHAR, v.u.pboolVal[0] # 0); RETURN SYSTEM.VAL(PB, SYSTEM.ADR(v.sign)) END VarRefBool; PROCEDURE VarRefStr* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF CtlT.Strg; TYPE PS = POINTER TO ARRAY [untagged] OF CtlT.Strg; VAR t: Temp; BEGIN ASSERT(v.vt = WinOle.VT_BSTR + WinOle.VT_BYREF, 100); NEW(t); t.str := AllocString(v.u.pbstrVal[0]); v.Hi32 := SYSTEM.ADR(t.str); RETURN SYSTEM.VAL(PS, v.Hi32) END VarRefStr; PROCEDURE VarRefObj* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF CtlT.Object; TYPE PO = POINTER TO ARRAY [untagged] OF CtlT.Object; VAR t: Temp; BEGIN ASSERT(v.vt = WinOle.VT_DISPATCH + WinOle.VT_BYREF, 100); NEW(t); t.obj := CtlT.Obj(v.u.ppdispVal[0]); v.Hi32 := SYSTEM.ADR(t.obj); RETURN SYSTEM.VAL(PO, v.Hi32) END VarRefObj; PROCEDURE VarRefAny* (VAR v: CtlT.Variant): POINTER TO ARRAY [untagged] OF CtlT.Any; TYPE PA = POINTER TO ARRAY [untagged] OF CtlT.Any; VAR t: Temp; BEGIN ASSERT(v.vt = WinOle.VT_VARIANT + WinOle.VT_BYREF, 100); NEW(t); t.any := VarAny(v.u.pvarVal^); v.Hi32 := SYSTEM.ADR(t.any); RETURN SYSTEM.VAL(PA, v.Hi32) END VarRefAny; PROCEDURE RetBool* (VAR var: CtlT.Variant); BEGIN ASSERT(var.vt = WinOle.VT_BOOL + WinOle.VT_BYREF, 100); IF SYSTEM.VAL(BOOLEAN, var.sign) THEN var.u.pboolVal[0] := -1 ELSE var.u.pboolVal[0] := 0 END END RetBool; PROCEDURE RetStr* (VAR var: CtlT.Variant); VAR str: CtlT.Strg; BEGIN ASSERT(var.vt = WinOle.VT_BSTR + WinOle.VT_BYREF, 100); SYSTEM.GET(var.Hi32, str); var.u.pbstrVal[0] := AllocSysString(str) END RetStr; PROCEDURE RetObj* (VAR var: CtlT.Variant); VAR obj: CtlT.Object; BEGIN ASSERT(var.vt = WinOle.VT_DISPATCH + WinOle.VT_BYREF, 100); SYSTEM.GET(var.Hi32, obj); IF obj # NIL THEN var.u.ppdispVal[0] := obj.disp ELSE var.u.ppdispVal[0] := NIL END END RetObj; PROCEDURE RetAny* (VAR var: CtlT.Variant); VAR a: CtlT.Any; BEGIN ASSERT(var.vt = WinOle.VT_DISPATCH + WinOle.VT_VARIANT, 100); SYSTEM.GET(var.Hi32, a); AnyVar(a, var.u.pvarVal^) END RetAny; (* enumerator methods *) PROCEDURE (e: AnyEnum) First (): CtlT.Any; VAR res: COM.RESULT; var: ARRAY 1 OF WinOleAut.VARIANT; BEGIN res := e.enum.Reset(); res := e.enum.Next(1, var, NIL); IF res = 0 THEN RETURN VarAny(var[0]) ELSE RETURN NIL END END First; PROCEDURE (e: AnyEnum) Next (): CtlT.Any; VAR res: COM.RESULT; var: ARRAY 1 OF WinOleAut.VARIANT; BEGIN res := e.enum.Next(1, var, NIL); IF res = 0 THEN RETURN VarAny(var[0]) ELSE RETURN NIL END END Next; (* EnumWrapper *) PROCEDURE (this: EnumWrapper) Next (num: INTEGER; OUT elem: ARRAY [untagged] OF WinOleAut.VARIANT; OUT [nil] fetched: INTEGER): COM.RESULT; VAR n, i: INTEGER; obj: CtlT.Any; BEGIN n := 0; IF VALID(fetched) THEN fetched := 0 ELSIF num # 1 THEN RETURN 80004003H (* E_POINTER *) END; obj := this.enum.First(); i := 0; WHILE i < this.cur DO obj := this.enum.Next(); INC(i) END; IF obj # NIL THEN WHILE (obj # NIL) & (num > 0) DO AnyVar(obj, elem[n]); INC(this.cur); INC(n); DEC(num); obj := this.enum.Next() END; IF VALID(fetched) THEN fetched := n END; RETURN 0 END; RETURN 1 (* S_FALSE *) END Next; PROCEDURE (this: EnumWrapper) Skip (num: INTEGER): COM.RESULT; BEGIN INC(this.cur, num); RETURN 0 END Skip; PROCEDURE (this: EnumWrapper) Reset (): COM.RESULT; BEGIN this.cur := 0; RETURN 0 END Reset; PROCEDURE (this: EnumWrapper) Clone (OUT [nil] enum: WinOleAut.IEnumVARIANT): COM.RESULT; VAR new: EnumWrapper; BEGIN NEW(new); IF new # NIL THEN new.enum := this.enum; new.cur := this.cur; enum := new; RETURN 0 ELSE RETURN 8007000EH (* E_OUTOFMEMORY *) END END Clone; (* wrapper functions *) PROCEDURE IsObj* (a: CtlT.Any; IN id: COM.GUID): BOOLEAN; VAR res: COM.RESULT; unk: COM.IUnknown; iid: COM.GUID; BEGIN WITH a: CtlT.OutObject DO a.GetIID(iid); RETURN id = iid | a: CtlT.Object DO res := a.disp.QueryInterface(id, unk); RETURN res >= 0 ELSE RETURN FALSE END END IsObj; PROCEDURE InitObj* (obj: CtlT.Object; a: CtlT.Any; IN id: COM.GUID); VAR res: COM.RESULT; BEGIN obj.typeId := CtlT.object; WITH a: CtlT.Object DO res := a.disp.QueryInterface(id, SYSTEM.VAL(COM.IUnknown, obj.disp)); ASSERT(res >= 0, 100) ELSE HALT(100) END END InitObj; PROCEDURE NewObj* (IN clsid: COM.GUID): CtlT.Any; VAR res: COM.RESULT; unk: COM.IUnknown; disp: WinOleAut.IDispatch; BEGIN res := WinOle.CoCreateInstance(clsid, NIL, CtlT.context, COM.ID(unk), unk); IF res >= 0 THEN res := unk.QueryInterface(COM.ID(disp), disp); IF res >= 0 THEN RETURN CtlT.Obj(disp) END END; RETURN NIL END NewObj; PROCEDURE ShowError (res: COM.RESULT; VAR error: WinOleAut.EXCEPINFO; param: INTEGER); VAR source, description: ARRAY 256 OF CHAR; code, i: INTEGER; scode: COM.RESULT; BEGIN source := ""; description := ""; code := 0; scode := 0; IF res = 80020009H (* DISP_E_EXCEPTION *) THEN IF error.pfnDeferredFillIn # NIL THEN scode := error.pfnDeferredFillIn(error) END; code := error.wCode; scode := error.scode; IF error.bstrSource # NIL THEN IF LEN(error.bstrSource$) >= LEN(source) THEN error.bstrSource[LEN(source) - 1] := 0X END; source := error.bstrSource$; WinOleAut.SysFreeString(error.bstrSource) END; IF error.bstrDescription # NIL THEN IF LEN(error.bstrDescription$) >= LEN(description) THEN error.bstrDescription[LEN(description) - 1] := 0X END; description := error.bstrDescription$; WinOleAut.SysFreeString(error.bstrDescription) END ELSIF (res = 8002000AH (* DISP_E_OVERFLOW *) ) OR (res = 80020005H (* DISP_E_TYPEMISMATCH *) ) THEN description := "Type error in parameter" END; IF description = "" THEN i := WinApi.FormatMessageW({12}, 0, res, 0, description, LEN(description), NIL); IF i > 0 THEN REPEAT DEC(i) UNTIL (i < 0) OR (description[i] >= " "); description[i + 1] := 0X; ELSE description := "" END END; HALT(10) END ShowError; PROCEDURE CallMethod* (obj: CtlT.Object; id: INTEGER; OUT [nil] ret: CtlT.Variant); VAR res: COM.RESULT; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 1, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END END CallMethod; PROCEDURE CallParMethod* (obj: CtlT.Object; id: INTEGER; VAR arg: ARRAY OF CtlT.Variant; OUT [nil] ret: CtlT.Variant); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.cNamedArgs := 0; par.cArgs := LEN(arg); WHILE (par.cArgs > 0) & (par.rgvarg[0].vt = WinOle.VT_EMPTY) DO DEC(par.cArgs); INC(SYSTEM.VAL(INTEGER, par.rgvarg), SIZE(CtlT.Variant)) END; param := 0; WHILE param < par.cArgs DO IF par.rgvarg[param].vt = WinOle.VT_EMPTY THEN par.rgvarg[param].vt := WinOle.VT_ERROR; par.rgvarg[param].u.scode := WinApi.DISP_E_PARAMNOTFOUND END; INC(param) END; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 1, par, ret, error, param); IF res < 0 THEN ShowError(res, error, par.cArgs - param) END; WHILE par.cArgs > 0 DO DEC(par.cArgs); res := WinOleAut.VariantClear(par.rgvarg[par.cArgs]) END END CallParMethod; PROCEDURE CallGetMethod* (obj: CtlT.Object; id: INTEGER; VAR arg: ARRAY OF CtlT.Variant; OUT [nil] ret: CtlT.Variant); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.cNamedArgs := 0; par.cArgs := LEN(arg); WHILE (par.cArgs > 0) & (par.rgvarg[0].vt = WinOle.VT_EMPTY) DO DEC(par.cArgs); INC(SYSTEM.VAL(INTEGER, par.rgvarg), SIZE(CtlT.Variant)) END; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, par, ret, error, param); IF res < 0 THEN ShowError(res, error, par.cArgs - param) END; WHILE par.cArgs > 0 DO DEC(par.cArgs); res := WinOleAut.VariantClear(par.rgvarg[par.cArgs]) END END CallGetMethod; PROCEDURE CallPutMethod* (obj: CtlT.Object; id: INTEGER; VAR arg: ARRAY OF CtlT.Variant; OUT [nil] ret: CtlT.Variant); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := LEN(arg); WHILE (par.cArgs > 0) & (par.rgvarg[0].vt = WinOle.VT_EMPTY) DO DEC(par.cArgs); INC(SYSTEM.VAL(INTEGER, par.rgvarg), SIZE(CtlT.Variant)) END; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, ret, error, param); IF res < 0 THEN ShowError(res, error, par.cArgs - param) END; WHILE par.cArgs > 0 DO DEC(par.cArgs); res := WinOleAut.VariantClear(par.rgvarg[par.cArgs]) END END CallPutMethod; PROCEDURE CallPutRefMethod* (obj: CtlT.Object; id: INTEGER; VAR arg: ARRAY OF CtlT.Variant; OUT [nil] ret: CtlT.Variant); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := LEN(arg); WHILE (par.cArgs > 0) & (par.rgvarg[0].vt = WinOle.VT_EMPTY) DO DEC(par.cArgs); INC(SYSTEM.VAL(INTEGER, par.rgvarg), SIZE(CtlT.Variant)) END; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 8, par, ret, error, param); IF res < 0 THEN ShowError(res, error, par.cArgs - param) END; WHILE par.cArgs > 0 DO DEC(par.cArgs); res := WinOleAut.VariantClear(par.rgvarg[par.cArgs]) END END CallPutRefMethod; PROCEDURE GetByte* (obj: CtlT.Object; id: INTEGER): BYTE; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_UI1, 100); RETURN SHORT(ORD(ret.u.bVal)) END GetByte; PROCEDURE GetSInt* (obj: CtlT.Object; id: INTEGER): SHORTINT; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_I2, 100); RETURN ret.u.iVal END GetSInt; PROCEDURE GetInt* (obj: CtlT.Object; id: INTEGER): INTEGER; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_I4, 100); RETURN ret.u.lVal END GetInt; PROCEDURE GetSReal* (obj: CtlT.Object; id: INTEGER): SHORTREAL; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_R4, 100); RETURN ret.u.fltVal END GetSReal; PROCEDURE GetReal* (obj: CtlT.Object; id: INTEGER): REAL; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_R8, 100); RETURN ret.u.dblVal END GetReal; PROCEDURE GetBool* (obj: CtlT.Object; id: INTEGER): BOOLEAN; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_BOOL, 100); RETURN ret.u.boolVal # 0 END GetBool; PROCEDURE GetRes* (obj: CtlT.Object; id: INTEGER): COM.RESULT; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_ERROR, 100); RETURN ret.u.scode END GetRes; PROCEDURE GetCy* (obj: CtlT.Object; id: INTEGER): CtlT.OleCy; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_CY, 100); RETURN ret.u.cyVal END GetCy; PROCEDURE GetDate* (obj: CtlT.Object; id: INTEGER): CtlT.OleDate; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_DATE, 100); RETURN ret.u.date END GetDate; PROCEDURE GetStr* (obj: CtlT.Object; id: INTEGER): CtlT.Strg; VAR res: COM.RESULT; ret: CtlT.Variant; s: CtlT.Strg; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_BSTR, 100); s := AllocString(ret.u.bstrVal); res := WinOleAut.VariantClear(ret); RETURN s END GetStr; PROCEDURE GetObj* (obj: CtlT.Object; id: INTEGER): CtlT.Object; VAR res: COM.RESULT; ret: CtlT.Variant; o: CtlT.Object; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_DISPATCH, 100); o := CtlT.Obj(ret.u.pdispVal); res := WinOleAut.VariantClear(ret); RETURN o END GetObj; PROCEDURE GetIntfce* (obj: CtlT.Object; id: INTEGER): COM.IUnknown; VAR res: COM.RESULT; ret: CtlT.Variant; u: COM.IUnknown; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_UNKNOWN, 100); u := ret.u.punkVal; res := WinOleAut.VariantClear(ret); RETURN u END GetIntfce; PROCEDURE GetEnum* (obj: CtlT.Object; id: INTEGER): CtlT.Enumerator; VAR res: COM.RESULT; ret: CtlT.Variant; u: COM.IUnknown; enum: WinOleAut.IEnumVARIANT; param: INTEGER; error: WinOleAut.EXCEPINFO; e: AnyEnum; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; ASSERT(ret.vt = WinOle.VT_UNKNOWN, 100); res := ret.u.punkVal.QueryInterface(COM.ID(enum), enum); ASSERT(res >= 0, 100); res := WinOleAut.VariantClear(ret); NEW(e); e.enum := enum; RETURN e END GetEnum; PROCEDURE GetAny* (obj: CtlT.Object; id: INTEGER): CtlT.Any; VAR res: COM.RESULT; ret: CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN res := obj.disp.Invoke(id, nullid, CtlT.lcid, 2, nullpar, ret, error, param); IF res < 0 THEN ShowError(res, error, 0) END; RETURN VarAny(ret) END GetAny; PROCEDURE PutByte* (obj: CtlT.Object; id: INTEGER; val: BYTE); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_UI1; arg[0].u.bVal := SHORT(CHR(val)); res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutByte; PROCEDURE PutSInt* (obj: CtlT.Object; id: INTEGER; val: SHORTINT); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_I2; arg[0].u.iVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutSInt; PROCEDURE PutInt* (obj: CtlT.Object; id: INTEGER; val: INTEGER); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_I4; arg[0].u.lVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutInt; PROCEDURE PutSReal* (obj: CtlT.Object; id: INTEGER; val: SHORTREAL); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_R4; arg[0].u.fltVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutSReal; PROCEDURE PutReal* (obj: CtlT.Object; id: INTEGER; val: REAL); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_R8; arg[0].u.dblVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutReal; PROCEDURE PutBool* (obj: CtlT.Object; id: INTEGER; val: BOOLEAN); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_BOOL; IF val THEN arg[0].u.boolVal := -1 ELSE arg[0].u.boolVal := 0 END; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutBool; PROCEDURE PutRes* (obj: CtlT.Object; id: INTEGER; val: COM.RESULT); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_ERROR; arg[0].u.scode := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutRes; PROCEDURE PutCy* (obj: CtlT.Object; id: INTEGER; val: CtlT.OleCy); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_CY; arg[0].u.cyVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutCy; PROCEDURE PutDate* (obj: CtlT.Object; id: INTEGER; val: CtlT.OleDate); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_DATE; arg[0].u.date := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutDate; PROCEDURE PutStr* (obj: CtlT.Object; id: INTEGER; IN val: ARRAY OF CHAR); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_BSTR; arg[0].u.bstrVal := AllocSysString(val); res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutStr; PROCEDURE PutObj* (obj: CtlT.Object; id: INTEGER; val: CtlT.Object); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_DISPATCH; arg[0].u.pdispVal := CtlT.Disp(val); res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutObj; PROCEDURE PutIntfce* (obj: CtlT.Object; id: INTEGER; val: COM.IUnknown); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; arg[0].vt := WinOle.VT_UNKNOWN; arg[0].u.punkVal := val; res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutIntfce; PROCEDURE PutAny* (obj: CtlT.Object; id: INTEGER; val: CtlT.Any); VAR res: COM.RESULT; par: WinOleAut.DISPPARAMS; arg: ARRAY 1 OF CtlT.Variant; param: INTEGER; error: WinOleAut.EXCEPINFO; BEGIN par.rgvarg := arg; par.rgdispidNamedArgs := putId; par.cNamedArgs := 1; par.cArgs := 1; AnyVar(val, arg[0]); res := obj.disp.Invoke(id, nullid, CtlT.lcid, 4, par, NIL, error, param); IF res < 0 THEN ShowError(res, error, 1) END; res := WinOleAut.VariantClear(arg[0]) END PutAny; BEGIN putId[0] := WinOleAut.DISPID_PROPERTYPUT END CtlC.

Ctl/Mod/C.odc

MODULE CtlDAO36; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft DAO 3.6 Object Library, help: C:\Program Files\Common Files\Microsoft Shared\DAO\dao360.chm, id: 0 *) (* guid: {00025E01-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 5.0 *) IMPORT CtlT, CtlC; CONST (* RecordsetTypeEnum *) dbOpenTable* = 1; dbOpenDynaset* = 2; dbOpenSnapshot* = 4; dbOpenForwardOnly* = 8; dbOpenDynamic* = 16; (* EditModeEnum *) dbEditNone* = 0; dbEditInProgress* = 1; dbEditAdd* = 2; (* RecordsetOptionEnum *) dbDenyWrite* = 1; dbDenyRead* = 2; dbReadOnly* = 4; dbAppendOnly* = 8; dbInconsistent* = 16; dbConsistent* = 32; dbSQLPassThrough* = 64; dbFailOnError* = 128; dbForwardOnly* = 256; dbSeeChanges* = 512; dbRunAsync* = 1024; dbExecDirect* = 2048; (* LockTypeEnum *) dbPessimistic* = 2; dbOptimistic* = 3; dbOptimisticValue* = 1; dbOptimisticBatch* = 5; (* UpdateCriteriaEnum *) dbCriteriaKey* = 1; dbCriteriaModValues* = 2; dbCriteriaAllCols* = 4; dbCriteriaTimestamp* = 8; dbCriteriaDeleteInsert* = 16; dbCriteriaUpdate* = 32; (* FieldAttributeEnum *) dbFixedField* = 1; dbVariableField* = 2; dbAutoIncrField* = 16; dbUpdatableField* = 32; dbSystemField* = 8192; dbHyperlinkField* = 32768; dbDescending* = 1; (* DataTypeEnum *) dbBoolean* = 1; dbByte* = 2; dbInteger* = 3; dbLong* = 4; dbCurrency* = 5; dbSingle* = 6; dbDouble* = 7; dbDate* = 8; dbBinary* = 9; dbText* = 10; dbLongBinary* = 11; dbMemo* = 12; dbGUID* = 15; dbBigInt* = 16; dbVarBinary* = 17; dbChar* = 18; dbNumeric* = 19; dbDecimal* = 20; dbFloat* = 21; dbTime* = 22; dbTimeStamp* = 23; (* RelationAttributeEnum *) dbRelationUnique* = 1; dbRelationDontEnforce* = 2; dbRelationInherited* = 4; dbRelationUpdateCascade* = 256; dbRelationDeleteCascade* = 4096; dbRelationLeft* = 16777216; dbRelationRight* = 33554432; (* TableDefAttributeEnum *) dbAttachExclusive* = 65536; dbAttachSavePWD* = 131072; dbSystemObject* = -2147483646; dbAttachedTable* = 1073741824; dbAttachedODBC* = 536870912; dbHiddenObject* = 1; (* QueryDefTypeEnum *) dbQSelect* = 0; dbQProcedure* = 224; dbQAction* = 240; dbQCrosstab* = 16; dbQDelete* = 32; dbQUpdate* = 48; dbQAppend* = 64; dbQMakeTable* = 80; dbQDDL* = 96; dbQSQLPassThrough* = 112; dbQSetOperation* = 128; dbQSPTBulk* = 144; dbQCompound* = 160; (* QueryDefStateEnum *) dbQPrepare* = 1; dbQUnprepare* = 2; (* DatabaseTypeEnum *) dbVersion10* = 1; dbEncrypt* = 2; dbDecrypt* = 4; dbVersion11* = 8; dbVersion20* = 16; dbVersion30* = 32; dbVersion40* = 64; (* CollatingOrderEnum *) dbSortNeutral* = 1024; dbSortArabic* = 1025; dbSortCyrillic* = 1049; dbSortCzech* = 1029; dbSortDutch* = 1043; dbSortGeneral* = 1033; dbSortGreek* = 1032; dbSortHebrew* = 1037; dbSortHungarian* = 1038; dbSortIcelandic* = 1039; dbSortNorwdan* = 1030; dbSortPDXIntl* = 1033; dbSortPDXNor* = 1030; dbSortPDXSwe* = 1053; dbSortPolish* = 1045; dbSortSpanish* = 1034; dbSortSwedFin* = 1053; dbSortTurkish* = 1055; dbSortJapanese* = 1041; dbSortChineseSimplified* = 2052; dbSortChineseTraditional* = 1028; dbSortKorean* = 1042; dbSortThai* = 1054; dbSortSlovenian* = 1060; dbSortUndefined* = -1; (* IdleEnum *) dbFreeLocks* = 1; dbRefreshCache* = 8; (* PermissionEnum *) dbSecNoAccess* = 0; dbSecFullAccess* = 1048575; dbSecDelete* = 65536; dbSecReadSec* = 131072; dbSecWriteSec* = 262144; dbSecWriteOwner* = 524288; dbSecDBCreate* = 1; dbSecDBOpen* = 2; dbSecDBExclusive* = 4; dbSecDBAdmin* = 8; dbSecCreate* = 1; dbSecReadDef* = 4; dbSecWriteDef* = 65548; dbSecRetrieveData* = 20; dbSecInsertData* = 32; dbSecReplaceData* = 64; dbSecDeleteData* = 128; (* SynchronizeTypeEnum *) dbRepExportChanges* = 1; dbRepImportChanges* = 2; dbRepImpExpChanges* = 4; dbRepSyncInternet* = 16; (* ReplicaTypeEnum *) dbRepMakeReadOnly* = 2; dbRepMakePartial* = 1; (* WorkspaceTypeEnum *) dbUseODBC* = 1; dbUseJet* = 2; (* CursorDriverEnum *) dbUseDefaultCursor* = -1; dbUseODBCCursor* = 1; dbUseServerCursor* = 2; dbUseClientBatchCursor* = 3; dbUseNoCursor* = 4; (* DriverPromptEnum *) dbDriverPrompt* = 2; dbDriverNoPrompt* = 1; dbDriverComplete* = 0; dbDriverCompleteRequired* = 3; (* SetOptionEnum *) dbPageTimeout* = 6; dbLockRetry* = 57; dbMaxBufferSize* = 8; dbUserCommitSync* = 58; dbImplicitCommitSync* = 59; dbExclusiveAsyncDelay* = 60; dbSharedAsyncDelay* = 61; dbMaxLocksPerFile* = 62; dbLockDelay* = 63; dbRecycleLVs* = 65; dbFlushTransactionTimeout* = 66; (* ParameterDirectionEnum *) dbParamInput* = 1; dbParamOutput* = 2; dbParamInputOutput* = 3; dbParamReturnValue* = 4; (* UpdateTypeEnum *) dbUpdateBatch* = 4; dbUpdateRegular* = 1; dbUpdateCurrentRecord* = 2; (* RecordStatusEnum *) dbRecordUnmodified* = 0; dbRecordModified* = 1; dbRecordNew* = 2; dbRecordDeleted* = 3; dbRecordDBDeleted* = 4; (* CommitTransOptionsEnum *) dbForceOSFlush* = 1; (* _DAOSuppHelp *) LogMessages* = 0; KeepLocal* = 0; Replicable* = 0; ReplicableBool* = 0; V1xNullBehavior* = 0; (* LanguageConstants *) dbLangArabic* = ";LANGID=0x0401;CP=1256;COUNTRY=0"; dbLangCzech* = ";LANGID=0x0405;CP=1250;COUNTRY=0"; dbLangDutch* = ";LANGID=0x0413;CP=1252;COUNTRY=0"; dbLangGeneral* = ";LANGID=0x0409;CP=1252;COUNTRY=0"; dbLangGreek* = ";LANGID=0x0408;CP=1253;COUNTRY=0"; dbLangHebrew* = ";LANGID=0x040D;CP=1255;COUNTRY=0"; dbLangHungarian* = ";LANGID=0x040E;CP=1250;COUNTRY=0"; dbLangIcelandic* = ";LANGID=0x040F;CP=1252;COUNTRY=0"; dbLangNordic* = ";LANGID=0x041D;CP=1252;COUNTRY=0"; dbLangNorwDan* = ";LANGID=0x0406;CP=1252;COUNTRY=0"; dbLangPolish* = ";LANGID=0x0415;CP=1250;COUNTRY=0"; dbLangCyrillic* = ";LANGID=0x0419;CP=1251;COUNTRY=0"; dbLangSpanish* = ";LANGID=0x040A;CP=1252;COUNTRY=0"; dbLangSwedFin* = ";LANGID=0x041D;CP=1252;COUNTRY=0"; dbLangTurkish* = ";LANGID=0x041F;CP=1254;COUNTRY=0"; dbLangJapanese* = ";LANGID=0x0411;CP=932;COUNTRY=0"; dbLangChineseSimplified* = ";LANGID=0x0804;CP=936;COUNTRY=0"; dbLangChineseTraditional* = ";LANGID=0x0404;CP=950;COUNTRY=0"; dbLangKorean* = ";LANGID=0x0412;CP=949;COUNTRY=0"; dbLangThai* = ";LANGID=0x041E;CP=874;COUNTRY=0"; dbLangSlovenian* = ";LANGID=0x0424;CP=1250;COUNTRY=0"; TYPE RecordsetTypeEnum* = INTEGER; EditModeEnum* = INTEGER; RecordsetOptionEnum* = INTEGER; LockTypeEnum* = INTEGER; UpdateCriteriaEnum* = INTEGER; FieldAttributeEnum* = INTEGER; DataTypeEnum* = INTEGER; RelationAttributeEnum* = INTEGER; TableDefAttributeEnum* = INTEGER; QueryDefTypeEnum* = INTEGER; QueryDefStateEnum* = INTEGER; DatabaseTypeEnum* = INTEGER; CollatingOrderEnum* = INTEGER; IdleEnum* = INTEGER; PermissionEnum* = INTEGER; SynchronizeTypeEnum* = INTEGER; ReplicaTypeEnum* = INTEGER; WorkspaceTypeEnum* = INTEGER; CursorDriverEnum* = INTEGER; DriverPromptEnum* = INTEGER; SetOptionEnum* = INTEGER; ParameterDirectionEnum* = INTEGER; UpdateTypeEnum* = INTEGER; RecordStatusEnum* = INTEGER; CommitTransOptionsEnum* = INTEGER; _DAOSuppHelp* = INTEGER; _DBEngine* = POINTER TO RECORD (CtlT.Object) END; _DAO* = POINTER TO RECORD (CtlT.Object) END; Properties* = POINTER TO RECORD (CtlT.Object) END; _DynaCollection* = POINTER TO RECORD (CtlT.Object) END; _Collection* = POINTER TO RECORD (CtlT.Object) END; Property* = POINTER TO RECORD (CtlT.Object) END; Workspaces* = POINTER TO RECORD (CtlT.Object) END; Workspace* = POINTER TO RECORD (CtlT.Object) END; Databases* = POINTER TO RECORD (CtlT.Object) END; Database* = POINTER TO RECORD (CtlT.Object) END; TableDefs* = POINTER TO RECORD (CtlT.Object) END; TableDef* = _TableDef; _TableDef* = POINTER TO RECORD (CtlT.Object) END; Fields* = POINTER TO RECORD (CtlT.Object) END; Field* = _Field; _Field* = POINTER TO RECORD (CtlT.Object) END; Indexes* = POINTER TO RECORD (CtlT.Object) END; Index* = _Index; _Index* = POINTER TO RECORD (CtlT.Object) END; Recordset* = POINTER TO RECORD (CtlT.Object) END; QueryDef* = _QueryDef; _QueryDef* = POINTER TO RECORD (CtlT.Object) END; Parameters* = POINTER TO RECORD (CtlT.Object) END; Parameter* = POINTER TO RECORD (CtlT.Object) END; Connection* = POINTER TO RECORD (CtlT.Object) END; QueryDefs* = POINTER TO RECORD (CtlT.Object) END; Recordsets* = POINTER TO RECORD (CtlT.Object) END; Relations* = POINTER TO RECORD (CtlT.Object) END; Relation* = _Relation; _Relation* = POINTER TO RECORD (CtlT.Object) END; Containers* = POINTER TO RECORD (CtlT.Object) END; Container* = POINTER TO RECORD (CtlT.Object) END; Documents* = POINTER TO RECORD (CtlT.Object) END; Document* = POINTER TO RECORD (CtlT.Object) END; Users* = POINTER TO RECORD (CtlT.Object) END; User* = _User; _User* = POINTER TO RECORD (CtlT.Object) END; Groups* = POINTER TO RECORD (CtlT.Object) END; Group* = _Group; _Group* = POINTER TO RECORD (CtlT.Object) END; Connections* = POINTER TO RECORD (CtlT.Object) END; Errors* = POINTER TO RECORD (CtlT.Object) END; Error* = POINTER TO RECORD (CtlT.Object) END; DBEngine* = _DBEngine; (* DAO 3.0 DBEngine (private) *) PrivDBEngine* = _DBEngine; IndexFields* = POINTER TO RECORD (CtlT.Object) END; PROCEDURE This_DBEngine* (v: CtlT.Any): _DBEngine; VAR new: _DBEngine; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000021-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_DBEngine; PROCEDURE Is_DBEngine* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000021-0000-0010-8000-00AA006D2EA4}") END Is_DBEngine; PROCEDURE This_DAO* (v: CtlT.Any): _DAO; VAR new: _DAO; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000000A-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_DAO; PROCEDURE Is_DAO* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000000A-0000-0010-8000-00AA006D2EA4}") END Is_DAO; PROCEDURE ThisProperties* (v: CtlT.Any): Properties; VAR new: Properties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000029-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisProperties; PROCEDURE IsProperties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000029-0000-0010-8000-00AA006D2EA4}") END IsProperties; PROCEDURE This_DynaCollection* (v: CtlT.Any): _DynaCollection; VAR new: _DynaCollection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000000A2-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_DynaCollection; PROCEDURE Is_DynaCollection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000000A2-0000-0010-8000-00AA006D2EA4}") END Is_DynaCollection; PROCEDURE This_Collection* (v: CtlT.Any): _Collection; VAR new: _Collection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000000A0-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Collection; PROCEDURE Is_Collection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000000A0-0000-0010-8000-00AA006D2EA4}") END Is_Collection; PROCEDURE ThisProperty* (v: CtlT.Any): Property; VAR new: Property; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000027-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisProperty; PROCEDURE IsProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000027-0000-0010-8000-00AA006D2EA4}") END IsProperty; PROCEDURE ThisWorkspaces* (v: CtlT.Any): Workspaces; VAR new: Workspaces; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000003B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisWorkspaces; PROCEDURE IsWorkspaces* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000003B-0000-0010-8000-00AA006D2EA4}") END IsWorkspaces; PROCEDURE ThisWorkspace* (v: CtlT.Any): Workspace; VAR new: Workspace; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000039-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisWorkspace; PROCEDURE IsWorkspace* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000039-0000-0010-8000-00AA006D2EA4}") END IsWorkspace; PROCEDURE ThisDatabases* (v: CtlT.Any): Databases; VAR new: Databases; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000073-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisDatabases; PROCEDURE IsDatabases* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000073-0000-0010-8000-00AA006D2EA4}") END IsDatabases; PROCEDURE ThisDatabase* (v: CtlT.Any): Database; VAR new: Database; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000071-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisDatabase; PROCEDURE IsDatabase* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000071-0000-0010-8000-00AA006D2EA4}") END IsDatabase; PROCEDURE ThisTableDefs* (v: CtlT.Any): TableDefs; VAR new: TableDefs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000004B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisTableDefs; PROCEDURE IsTableDefs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000004B-0000-0010-8000-00AA006D2EA4}") END IsTableDefs; PROCEDURE This_TableDef* (v: CtlT.Any): _TableDef; VAR new: _TableDef; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000049-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_TableDef; PROCEDURE Is_TableDef* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000049-0000-0010-8000-00AA006D2EA4}") END Is_TableDef; PROCEDURE ThisFields* (v: CtlT.Any): Fields; VAR new: Fields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000053-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisFields; PROCEDURE IsFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000053-0000-0010-8000-00AA006D2EA4}") END IsFields; PROCEDURE This_Field* (v: CtlT.Any): _Field; VAR new: _Field; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000051-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Field; PROCEDURE Is_Field* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000051-0000-0010-8000-00AA006D2EA4}") END Is_Field; PROCEDURE ThisIndexes* (v: CtlT.Any): Indexes; VAR new: Indexes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000005B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisIndexes; PROCEDURE IsIndexes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000005B-0000-0010-8000-00AA006D2EA4}") END IsIndexes; PROCEDURE This_Index* (v: CtlT.Any): _Index; VAR new: _Index; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000059-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Index; PROCEDURE Is_Index* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000059-0000-0010-8000-00AA006D2EA4}") END Is_Index; PROCEDURE ThisRecordset* (v: CtlT.Any): Recordset; VAR new: Recordset; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000031-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisRecordset; PROCEDURE IsRecordset* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000031-0000-0010-8000-00AA006D2EA4}") END IsRecordset; PROCEDURE This_QueryDef* (v: CtlT.Any): _QueryDef; VAR new: _QueryDef; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000079-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_QueryDef; PROCEDURE Is_QueryDef* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000079-0000-0010-8000-00AA006D2EA4}") END Is_QueryDef; PROCEDURE ThisParameters* (v: CtlT.Any): Parameters; VAR new: Parameters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000083-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisParameters; PROCEDURE IsParameters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000083-0000-0010-8000-00AA006D2EA4}") END IsParameters; PROCEDURE ThisParameter* (v: CtlT.Any): Parameter; VAR new: Parameter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000081-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisParameter; PROCEDURE IsParameter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000081-0000-0010-8000-00AA006D2EA4}") END IsParameter; PROCEDURE ThisConnection* (v: CtlT.Any): Connection; VAR new: Connection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000041-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisConnection; PROCEDURE IsConnection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000041-0000-0010-8000-00AA006D2EA4}") END IsConnection; PROCEDURE ThisQueryDefs* (v: CtlT.Any): QueryDefs; VAR new: QueryDefs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000007B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisQueryDefs; PROCEDURE IsQueryDefs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000007B-0000-0010-8000-00AA006D2EA4}") END IsQueryDefs; PROCEDURE ThisRecordsets* (v: CtlT.Any): Recordsets; VAR new: Recordsets; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000033-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisRecordsets; PROCEDURE IsRecordsets* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000033-0000-0010-8000-00AA006D2EA4}") END IsRecordsets; PROCEDURE ThisRelations* (v: CtlT.Any): Relations; VAR new: Relations; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000008B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisRelations; PROCEDURE IsRelations* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000008B-0000-0010-8000-00AA006D2EA4}") END IsRelations; PROCEDURE This_Relation* (v: CtlT.Any): _Relation; VAR new: _Relation; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000089-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Relation; PROCEDURE Is_Relation* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000089-0000-0010-8000-00AA006D2EA4}") END Is_Relation; PROCEDURE ThisContainers* (v: CtlT.Any): Containers; VAR new: Containers; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000093-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisContainers; PROCEDURE IsContainers* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000093-0000-0010-8000-00AA006D2EA4}") END IsContainers; PROCEDURE ThisContainer* (v: CtlT.Any): Container; VAR new: Container; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000091-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisContainer; PROCEDURE IsContainer* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000091-0000-0010-8000-00AA006D2EA4}") END IsContainer; PROCEDURE ThisDocuments* (v: CtlT.Any): Documents; VAR new: Documents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000009B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisDocuments; PROCEDURE IsDocuments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000009B-0000-0010-8000-00AA006D2EA4}") END IsDocuments; PROCEDURE ThisDocument* (v: CtlT.Any): Document; VAR new: Document; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000099-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisDocument; PROCEDURE IsDocument* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000099-0000-0010-8000-00AA006D2EA4}") END IsDocument; PROCEDURE ThisUsers* (v: CtlT.Any): Users; VAR new: Users; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000006B-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisUsers; PROCEDURE IsUsers* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000006B-0000-0010-8000-00AA006D2EA4}") END IsUsers; PROCEDURE This_User* (v: CtlT.Any): _User; VAR new: _User; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000069-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_User; PROCEDURE Is_User* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000069-0000-0010-8000-00AA006D2EA4}") END Is_User; PROCEDURE ThisGroups* (v: CtlT.Any): Groups; VAR new: Groups; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000063-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisGroups; PROCEDURE IsGroups* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000063-0000-0010-8000-00AA006D2EA4}") END IsGroups; PROCEDURE This_Group* (v: CtlT.Any): _Group; VAR new: _Group; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000061-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END This_Group; PROCEDURE Is_Group* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000061-0000-0010-8000-00AA006D2EA4}") END Is_Group; PROCEDURE ThisConnections* (v: CtlT.Any): Connections; VAR new: Connections; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000043-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisConnections; PROCEDURE IsConnections* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000043-0000-0010-8000-00AA006D2EA4}") END IsConnections; PROCEDURE ThisErrors* (v: CtlT.Any): Errors; VAR new: Errors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000025-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisErrors; PROCEDURE IsErrors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000025-0000-0010-8000-00AA006D2EA4}") END IsErrors; PROCEDURE ThisError* (v: CtlT.Any): Error; VAR new: Error; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00000023-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisError; PROCEDURE IsError* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00000023-0000-0010-8000-00AA006D2EA4}") END IsError; PROCEDURE ThisIndexFields* (v: CtlT.Any): IndexFields; VAR new: IndexFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0000005D-0000-0010-8000-00AA006D2EA4}"); RETURN new ELSE RETURN NIL END END ThisIndexFields; PROCEDURE IsIndexFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0000005D-0000-0010-8000-00AA006D2EA4}") END IsIndexFields; (* ---------- _DBEngine, dual, nonextensible ---------- *) PROCEDURE (this: _DBEngine) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _DBEngine) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Version; PROCEDURE (this: _DBEngine) IniPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END IniPath; PROCEDURE (this: _DBEngine) PUTIniPath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809345, p1) END PUTIniPath; PROCEDURE (this: _DBEngine) PUTDefaultUser* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTDefaultUser; PROCEDURE (this: _DBEngine) PUTDefaultPassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809348, p1) END PUTDefaultPassword; PROCEDURE (this: _DBEngine) LoginTimeout* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809349) END LoginTimeout; PROCEDURE (this: _DBEngine) PUTLoginTimeout* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809349, p1) END PUTLoginTimeout; PROCEDURE (this: _DBEngine) Workspaces* (): Workspaces, NEW; BEGIN RETURN ThisWorkspaces(CtlC.GetAny(this, 0)) END Workspaces; PROCEDURE (this: _DBEngine) Errors* (): Errors, NEW; BEGIN RETURN ThisErrors(CtlC.GetAny(this, 1610809352)) END Errors; PROCEDURE (this: _DBEngine) Idle* ((* optional *) Action: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Action, arg[0]); CtlC.CallParMethod(this, 1610809353, arg, NIL); END Idle; PROCEDURE (this: _DBEngine) CompactDatabase* (SrcName: ARRAY OF CHAR; DstName: ARRAY OF CHAR; (* optional *) DstLocale: CtlT.Any; Options: CtlT.Any; SrcLocale: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(SrcName, arg[4]); CtlC.StrVar(DstName, arg[3]); CtlC.AnyVar(DstLocale, arg[2]); CtlC.AnyVar(Options, arg[1]); CtlC.AnyVar(SrcLocale, arg[0]); CtlC.CallParMethod(this, 1610809354, arg, NIL); END CompactDatabase; PROCEDURE (this: _DBEngine) RepairDatabase* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809355, arg, NIL); END RepairDatabase; PROCEDURE (this: _DBEngine) RegisterDatabase* (Dsn: ARRAY OF CHAR; Driver: ARRAY OF CHAR; Silent: BOOLEAN; Attributes: ARRAY OF CHAR), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Dsn, arg[3]); CtlC.StrVar(Driver, arg[2]); CtlC.BoolVar(Silent, arg[1]); CtlC.StrVar(Attributes, arg[0]); CtlC.CallParMethod(this, 1610809356, arg, NIL); END RegisterDatabase; PROCEDURE (this: _DBEngine) OpenDatabase* (Name: ARRAY OF CHAR; (* optional *) Options: CtlT.Any; ReadOnly: CtlT.Any; Connect: CtlT.Any): Database, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Options, arg[2]); CtlC.AnyVar(ReadOnly, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 1610809358, arg, ret); RETURN ThisDatabase(CtlC.VarAny(ret)) END OpenDatabase; PROCEDURE (this: _DBEngine) CreateDatabase* (Name: ARRAY OF CHAR; Locale: ARRAY OF CHAR; (* optional *) Option: CtlT.Any): Database, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[2]); CtlC.StrVar(Locale, arg[1]); CtlC.AnyVar(Option, arg[0]); CtlC.CallParMethod(this, 1610809359, arg, ret); RETURN ThisDatabase(CtlC.VarAny(ret)) END CreateDatabase; PROCEDURE (this: _DBEngine) BeginTrans* (), NEW; BEGIN CtlC.CallMethod(this, 1610809361, NIL); END BeginTrans; PROCEDURE (this: _DBEngine) CommitTrans* (Option: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Option, arg[0]); CtlC.CallParMethod(this, 1610809362, arg, NIL); END CommitTrans; PROCEDURE (this: _DBEngine) Rollback* (), NEW; BEGIN CtlC.CallMethod(this, 1610809363, NIL); END Rollback; PROCEDURE (this: _DBEngine) ISAMStats* (StatNum: INTEGER; (* optional *) Reset: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(StatNum, arg[1]); CtlC.AnyVar(Reset, arg[0]); CtlC.CallParMethod(this, 1610809366, arg, ret); RETURN CtlC.VarInt(ret) END ISAMStats; PROCEDURE (this: _DBEngine) SystemDB* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809367) END SystemDB; PROCEDURE (this: _DBEngine) PUTSystemDB* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809367, p1) END PUTSystemDB; PROCEDURE (this: _DBEngine) CreateWorkspace* (Name: ARRAY OF CHAR; UserName: ARRAY OF CHAR; Password: ARRAY OF CHAR; (* optional *) UseType: CtlT.Any): Workspace, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.StrVar(UserName, arg[2]); CtlC.StrVar(Password, arg[1]); CtlC.AnyVar(UseType, arg[0]); CtlC.CallParMethod(this, 1610809369, arg, ret); RETURN ThisWorkspace(CtlC.VarAny(ret)) END CreateWorkspace; PROCEDURE (this: _DBEngine) OpenConnection* (Name: ARRAY OF CHAR; (* optional *) Options: CtlT.Any; ReadOnly: CtlT.Any; Connect: CtlT.Any): Connection, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Options, arg[2]); CtlC.AnyVar(ReadOnly, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 1610809370, arg, ret); RETURN ThisConnection(CtlC.VarAny(ret)) END OpenConnection; PROCEDURE (this: _DBEngine) DefaultType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809371) END DefaultType; PROCEDURE (this: _DBEngine) PUTDefaultType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809371, p1) END PUTDefaultType; PROCEDURE (this: _DBEngine) SetOption* (Option: INTEGER; Value: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Option, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 1610809373, arg, NIL); END SetOption; (* ---------- _DAO, dual, nonextensible ---------- *) PROCEDURE (this: _DAO) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; (* ---------- Properties, dual, nonextensible ---------- *) PROCEDURE (this: Properties) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Properties) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Properties) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Properties) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Properties) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Properties) Item* (Item: CtlT.Any): Property, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END Item; (* ---------- _DynaCollection, dual, nonextensible ---------- *) PROCEDURE (this: _DynaCollection) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: _DynaCollection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _DynaCollection) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: _DynaCollection) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: _DynaCollection) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; (* ---------- _Collection, dual, nonextensible ---------- *) PROCEDURE (this: _Collection) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: _Collection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Collection) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; (* ---------- Property, dual, nonextensible ---------- *) PROCEDURE (this: Property) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Property) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Property) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Property) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Name; PROCEDURE (this: Property) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTName; PROCEDURE (this: Property) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809348) END Type; PROCEDURE (this: Property) PUTType* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809348, p1) END PUTType; PROCEDURE (this: Property) Inherited* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809350) END Inherited; (* ---------- Workspaces, dual, nonextensible ---------- *) PROCEDURE (this: Workspaces) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Workspaces) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Workspaces) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Workspaces) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Workspaces) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Workspaces) Item* (Item: CtlT.Any): Workspace, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisWorkspace(CtlC.VarAny(ret)) END Item; (* ---------- Workspace, dual, nonextensible ---------- *) PROCEDURE (this: Workspace) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Workspace) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: Workspace) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: Workspace) UserName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END UserName; PROCEDURE (this: Workspace) IsolateODBCTrans* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809349) END IsolateODBCTrans; PROCEDURE (this: Workspace) PUTIsolateODBCTrans* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809349, p1) END PUTIsolateODBCTrans; PROCEDURE (this: Workspace) Databases* (): Databases, NEW; BEGIN RETURN ThisDatabases(CtlC.GetAny(this, 0)) END Databases; PROCEDURE (this: Workspace) Users* (): Users, NEW; BEGIN RETURN ThisUsers(CtlC.GetAny(this, 1610809352)) END Users; PROCEDURE (this: Workspace) Groups* (): Groups, NEW; BEGIN RETURN ThisGroups(CtlC.GetAny(this, 1610809353)) END Groups; PROCEDURE (this: Workspace) BeginTrans* (), NEW; BEGIN CtlC.CallMethod(this, 1610809354, NIL); END BeginTrans; PROCEDURE (this: Workspace) CommitTrans* (Options: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809355, arg, NIL); END CommitTrans; PROCEDURE (this: Workspace) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1610809356, NIL); END Close; PROCEDURE (this: Workspace) Rollback* (), NEW; BEGIN CtlC.CallMethod(this, 1610809357, NIL); END Rollback; PROCEDURE (this: Workspace) OpenDatabase* (Name: ARRAY OF CHAR; (* optional *) Options: CtlT.Any; ReadOnly: CtlT.Any; Connect: CtlT.Any): Database, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Options, arg[2]); CtlC.AnyVar(ReadOnly, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 1610809358, arg, ret); RETURN ThisDatabase(CtlC.VarAny(ret)) END OpenDatabase; PROCEDURE (this: Workspace) CreateDatabase* (Name: ARRAY OF CHAR; Connect: ARRAY OF CHAR; (* optional *) Option: CtlT.Any): Database, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[2]); CtlC.StrVar(Connect, arg[1]); CtlC.AnyVar(Option, arg[0]); CtlC.CallParMethod(this, 1610809359, arg, ret); RETURN ThisDatabase(CtlC.VarAny(ret)) END CreateDatabase; PROCEDURE (this: Workspace) CreateUser* ((* optional *) Name: CtlT.Any; PID: CtlT.Any; Password: CtlT.Any): User, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(PID, arg[1]); CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 1610809360, arg, ret); RETURN This_User(CtlC.VarAny(ret)) END CreateUser; PROCEDURE (this: Workspace) CreateGroup* ((* optional *) Name: CtlT.Any; PID: CtlT.Any): Group, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(PID, arg[0]); CtlC.CallParMethod(this, 1610809361, arg, ret); RETURN This_Group(CtlC.VarAny(ret)) END CreateGroup; PROCEDURE (this: Workspace) OpenConnection* (Name: ARRAY OF CHAR; (* optional *) Options: CtlT.Any; ReadOnly: CtlT.Any; Connect: CtlT.Any): Connection, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Options, arg[2]); CtlC.AnyVar(ReadOnly, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 1610809362, arg, ret); RETURN ThisConnection(CtlC.VarAny(ret)) END OpenConnection; PROCEDURE (this: Workspace) LoginTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809363) END LoginTimeout; PROCEDURE (this: Workspace) PUTLoginTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809363, p1) END PUTLoginTimeout; PROCEDURE (this: Workspace) DefaultCursorDriver* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809365) END DefaultCursorDriver; PROCEDURE (this: Workspace) PUTDefaultCursorDriver* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809365, p1) END PUTDefaultCursorDriver; PROCEDURE (this: Workspace) hEnv* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809367) END hEnv; PROCEDURE (this: Workspace) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809368) END Type; PROCEDURE (this: Workspace) Connections* (): Connections, NEW; BEGIN RETURN ThisConnections(CtlC.GetAny(this, 1610809369)) END Connections; (* ---------- Databases, dual, nonextensible ---------- *) PROCEDURE (this: Databases) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Databases) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Databases) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Databases) Item* (Item: CtlT.Any): Database, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisDatabase(CtlC.VarAny(ret)) END Item; (* ---------- Database, dual, nonextensible ---------- *) PROCEDURE (this: Database) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Database) CollatingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809344) END CollatingOrder; PROCEDURE (this: Database) Connect* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Connect; PROCEDURE (this: Database) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Name; PROCEDURE (this: Database) QueryTimeout* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809347) END QueryTimeout; PROCEDURE (this: Database) PUTQueryTimeout* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809347, p1) END PUTQueryTimeout; PROCEDURE (this: Database) Transactions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809349) END Transactions; PROCEDURE (this: Database) Updatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809350) END Updatable; PROCEDURE (this: Database) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809351) END Version; PROCEDURE (this: Database) RecordsAffected* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809352) END RecordsAffected; PROCEDURE (this: Database) TableDefs* (): TableDefs, NEW; BEGIN RETURN ThisTableDefs(CtlC.GetAny(this, 0)) END TableDefs; PROCEDURE (this: Database) QueryDefs* (): QueryDefs, NEW; BEGIN RETURN ThisQueryDefs(CtlC.GetAny(this, 1610809354)) END QueryDefs; PROCEDURE (this: Database) Relations* (): Relations, NEW; BEGIN RETURN ThisRelations(CtlC.GetAny(this, 1610809355)) END Relations; PROCEDURE (this: Database) Containers* (): Containers, NEW; BEGIN RETURN ThisContainers(CtlC.GetAny(this, 1610809356)) END Containers; PROCEDURE (this: Database) Recordsets* (): Recordsets, NEW; BEGIN RETURN ThisRecordsets(CtlC.GetAny(this, 1610809357)) END Recordsets; PROCEDURE (this: Database) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1610809358, NIL); END Close; PROCEDURE (this: Database) Execute* (Query: ARRAY OF CHAR; (* optional *) Options: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Query, arg[1]); CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809359, arg, NIL); END Execute; PROCEDURE (this: Database) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809361, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; PROCEDURE (this: Database) CreateRelation* ((* optional *) Name: CtlT.Any; Table: CtlT.Any; ForeignTable: CtlT.Any; Attributes: CtlT.Any): Relation, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Table, arg[2]); CtlC.AnyVar(ForeignTable, arg[1]); CtlC.AnyVar(Attributes, arg[0]); CtlC.CallParMethod(this, 1610809362, arg, ret); RETURN This_Relation(CtlC.VarAny(ret)) END CreateRelation; PROCEDURE (this: Database) CreateTableDef* ((* optional *) Name: CtlT.Any; Attributes: CtlT.Any; SourceTableName: CtlT.Any; Connect: CtlT.Any): TableDef, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Attributes, arg[2]); CtlC.AnyVar(SourceTableName, arg[1]); CtlC.AnyVar(Connect, arg[0]); CtlC.CallParMethod(this, 1610809363, arg, ret); RETURN This_TableDef(CtlC.VarAny(ret)) END CreateTableDef; PROCEDURE (this: Database) CreateQueryDef* ((* optional *) Name: CtlT.Any; SQLText: CtlT.Any): QueryDef, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(SQLText, arg[0]); CtlC.CallParMethod(this, 1610809368, arg, ret); RETURN This_QueryDef(CtlC.VarAny(ret)) END CreateQueryDef; PROCEDURE (this: Database) ReplicaID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809376) END ReplicaID; PROCEDURE (this: Database) DesignMasterID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809377) END DesignMasterID; PROCEDURE (this: Database) PUTDesignMasterID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809377, p1) END PUTDesignMasterID; PROCEDURE (this: Database) Synchronize* (DbPathName: ARRAY OF CHAR; (* optional *) ExchangeType: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(DbPathName, arg[1]); CtlC.AnyVar(ExchangeType, arg[0]); CtlC.CallParMethod(this, 1610809379, arg, NIL); END Synchronize; PROCEDURE (this: Database) MakeReplica* (PathName: ARRAY OF CHAR; Description: ARRAY OF CHAR; (* optional *) Options: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(PathName, arg[2]); CtlC.StrVar(Description, arg[1]); CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809380, arg, NIL); END MakeReplica; PROCEDURE (this: Database) PUTConnect* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809345, p1) END PUTConnect; PROCEDURE (this: Database) NewPassword* (bstrOld: ARRAY OF CHAR; bstrNew: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrOld, arg[1]); CtlC.StrVar(bstrNew, arg[0]); CtlC.CallParMethod(this, 1610809382, arg, NIL); END NewPassword; PROCEDURE (this: Database) OpenRecordset* (Name: ARRAY OF CHAR; (* optional *) Type: CtlT.Any; Options: CtlT.Any; LockEdit: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Options, arg[1]); CtlC.AnyVar(LockEdit, arg[0]); CtlC.CallParMethod(this, 1610809383, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END OpenRecordset; PROCEDURE (this: Database) Connection* (): Connection, NEW; BEGIN RETURN ThisConnection(CtlC.GetAny(this, 1610809384)) END Connection; PROCEDURE (this: Database) PopulatePartial* (DbPathName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(DbPathName, arg[0]); CtlC.CallParMethod(this, 1610809385, arg, NIL); END PopulatePartial; (* ---------- TableDefs, dual, nonextensible ---------- *) PROCEDURE (this: TableDefs) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: TableDefs) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: TableDefs) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: TableDefs) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: TableDefs) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: TableDefs) Item* (Item: CtlT.Any): TableDef, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_TableDef(CtlC.VarAny(ret)) END Item; (* ---------- _TableDef, dual, nonextensible ---------- *) PROCEDURE (this: _TableDef) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _TableDef) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809344) END Attributes; PROCEDURE (this: _TableDef) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809344, p1) END PUTAttributes; PROCEDURE (this: _TableDef) Connect* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Connect; PROCEDURE (this: _TableDef) PUTConnect* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTConnect; PROCEDURE (this: _TableDef) DateCreated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809348) END DateCreated; PROCEDURE (this: _TableDef) LastUpdated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809349) END LastUpdated; PROCEDURE (this: _TableDef) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809350) END Name; PROCEDURE (this: _TableDef) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809350, p1) END PUTName; PROCEDURE (this: _TableDef) SourceTableName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809352) END SourceTableName; PROCEDURE (this: _TableDef) PUTSourceTableName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809352, p1) END PUTSourceTableName; PROCEDURE (this: _TableDef) Updatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809354) END Updatable; PROCEDURE (this: _TableDef) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809355) END ValidationText; PROCEDURE (this: _TableDef) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809355, p1) END PUTValidationText; PROCEDURE (this: _TableDef) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809357) END ValidationRule; PROCEDURE (this: _TableDef) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809357, p1) END PUTValidationRule; PROCEDURE (this: _TableDef) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809359) END RecordCount; PROCEDURE (this: _TableDef) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 0)) END Fields; PROCEDURE (this: _TableDef) Indexes* (): Indexes, NEW; BEGIN RETURN ThisIndexes(CtlC.GetAny(this, 1610809361)) END Indexes; PROCEDURE (this: _TableDef) OpenRecordset* ((* optional *) Type: CtlT.Any; Options: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809362, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END OpenRecordset; PROCEDURE (this: _TableDef) RefreshLink* (), NEW; BEGIN CtlC.CallMethod(this, 1610809363, NIL); END RefreshLink; PROCEDURE (this: _TableDef) CreateField* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Size: CtlT.Any): Field, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(Size, arg[0]); CtlC.CallParMethod(this, 1610809364, arg, ret); RETURN This_Field(CtlC.VarAny(ret)) END CreateField; PROCEDURE (this: _TableDef) CreateIndex* ((* optional *) Name: CtlT.Any): Index, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809365, arg, ret); RETURN This_Index(CtlC.VarAny(ret)) END CreateIndex; PROCEDURE (this: _TableDef) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809366, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; PROCEDURE (this: _TableDef) ConflictTable* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809367) END ConflictTable; PROCEDURE (this: _TableDef) ReplicaFilter* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809368) END ReplicaFilter; PROCEDURE (this: _TableDef) PUTReplicaFilter* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809368, p1) END PUTReplicaFilter; (* ---------- Fields, dual, nonextensible ---------- *) PROCEDURE (this: Fields) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Fields) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Fields) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Fields) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Fields) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Fields) Item* (Item: CtlT.Any): Field, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Field(CtlC.VarAny(ret)) END Item; (* ---------- _Field, dual, nonextensible ---------- *) PROCEDURE (this: _Field) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _Field) CollatingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809344) END CollatingOrder; PROCEDURE (this: _Field) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809345) END Type; PROCEDURE (this: _Field) PUTType* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809345, p1) END PUTType; PROCEDURE (this: _Field) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END Name; PROCEDURE (this: _Field) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTName; PROCEDURE (this: _Field) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END Size; PROCEDURE (this: _Field) PUTSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTSize; PROCEDURE (this: _Field) SourceField* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809351) END SourceField; PROCEDURE (this: _Field) SourceTable* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809352) END SourceTable; PROCEDURE (this: _Field) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: _Field) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: _Field) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809355) END Attributes; PROCEDURE (this: _Field) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809355, p1) END PUTAttributes; PROCEDURE (this: _Field) OrdinalPosition* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809357) END OrdinalPosition; PROCEDURE (this: _Field) PUTOrdinalPosition* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809357, p1) END PUTOrdinalPosition; PROCEDURE (this: _Field) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809359) END ValidationText; PROCEDURE (this: _Field) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809359, p1) END PUTValidationText; PROCEDURE (this: _Field) ValidateOnSet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809361) END ValidateOnSet; PROCEDURE (this: _Field) PUTValidateOnSet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809361, p1) END PUTValidateOnSet; PROCEDURE (this: _Field) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809363) END ValidationRule; PROCEDURE (this: _Field) PUTValidationRule* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809363, p1) END PUTValidationRule; PROCEDURE (this: _Field) DefaultValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809365) END DefaultValue; PROCEDURE (this: _Field) PUTDefaultValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809365, p1) END PUTDefaultValue; PROCEDURE (this: _Field) Required* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809367) END Required; PROCEDURE (this: _Field) PUTRequired* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809367, p1) END PUTRequired; PROCEDURE (this: _Field) AllowZeroLength* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809369) END AllowZeroLength; PROCEDURE (this: _Field) PUTAllowZeroLength* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809369, p1) END PUTAllowZeroLength; PROCEDURE (this: _Field) DataUpdatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809371) END DataUpdatable; PROCEDURE (this: _Field) ForeignName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809372) END ForeignName; PROCEDURE (this: _Field) PUTForeignName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809372, p1) END PUTForeignName; PROCEDURE (this: _Field) AppendChunk* (Val: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Val, arg[0]); CtlC.CallParMethod(this, 1610809374, arg, NIL); END AppendChunk; PROCEDURE (this: _Field) GetChunk* (Offset: INTEGER; Bytes: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Offset, arg[1]); CtlC.IntVar(Bytes, arg[0]); CtlC.CallParMethod(this, 1610809375, arg, ret); RETURN CtlC.VarAny(ret) END GetChunk; PROCEDURE (this: _Field) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809377, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; PROCEDURE (this: _Field) CollectionIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809378) END CollectionIndex; PROCEDURE (this: _Field) OriginalValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809379) END OriginalValue; PROCEDURE (this: _Field) VisibleValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809380) END VisibleValue; PROCEDURE (this: _Field) FieldSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809381) END FieldSize; (* ---------- Indexes, dual, nonextensible ---------- *) PROCEDURE (this: Indexes) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Indexes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Indexes) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Indexes) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Indexes) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Indexes) Item* (Item: CtlT.Any): Index, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Index(CtlC.VarAny(ret)) END Item; (* ---------- _Index, dual, nonextensible ---------- *) PROCEDURE (this: _Index) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _Index) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: _Index) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: _Index) Foreign* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809346) END Foreign; PROCEDURE (this: _Index) Unique* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809347) END Unique; PROCEDURE (this: _Index) PUTUnique* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809347, p1) END PUTUnique; PROCEDURE (this: _Index) Clustered* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809349) END Clustered; PROCEDURE (this: _Index) PUTClustered* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809349, p1) END PUTClustered; PROCEDURE (this: _Index) Required* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809351) END Required; PROCEDURE (this: _Index) PUTRequired* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809351, p1) END PUTRequired; PROCEDURE (this: _Index) IgnoreNulls* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809353) END IgnoreNulls; PROCEDURE (this: _Index) PUTIgnoreNulls* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809353, p1) END PUTIgnoreNulls; PROCEDURE (this: _Index) Primary* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809355) END Primary; PROCEDURE (this: _Index) PUTPrimary* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809355, p1) END PUTPrimary; PROCEDURE (this: _Index) DistinctCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809357) END DistinctCount; PROCEDURE (this: _Index) Fields* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809358) END Fields; PROCEDURE (this: _Index) PUTFields* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809358, p1) END PUTFields; PROCEDURE (this: _Index) CreateField* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Size: CtlT.Any): Field, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(Size, arg[0]); CtlC.CallParMethod(this, 1610809360, arg, ret); RETURN This_Field(CtlC.VarAny(ret)) END CreateField; PROCEDURE (this: _Index) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809361, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; (* ---------- Recordset, dual, nonextensible ---------- *) PROCEDURE (this: Recordset) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Recordset) BOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 101) END BOF; PROCEDURE (this: Recordset) Bookmark* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 102) END Bookmark; PROCEDURE (this: Recordset) PUTBookmark* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 102, p1) END PUTBookmark; PROCEDURE (this: Recordset) Bookmarkable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Bookmarkable; PROCEDURE (this: Recordset) DateCreated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 104) END DateCreated; PROCEDURE (this: Recordset) EOF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 105) END EOF; PROCEDURE (this: Recordset) Filter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END Filter; PROCEDURE (this: Recordset) PUTFilter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTFilter; PROCEDURE (this: Recordset) Index* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END Index; PROCEDURE (this: Recordset) PUTIndex* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTIndex; PROCEDURE (this: Recordset) LastModified* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 108) END LastModified; PROCEDURE (this: Recordset) LastUpdated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 109) END LastUpdated; PROCEDURE (this: Recordset) LockEdits* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 110) END LockEdits; PROCEDURE (this: Recordset) PUTLockEdits* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 110, p1) END PUTLockEdits; PROCEDURE (this: Recordset) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 111) END Name; PROCEDURE (this: Recordset) NoMatch* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 112) END NoMatch; PROCEDURE (this: Recordset) Sort* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END Sort; PROCEDURE (this: Recordset) PUTSort* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 113, p1) END PUTSort; PROCEDURE (this: Recordset) Transactions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 114) END Transactions; PROCEDURE (this: Recordset) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 115) END Type; PROCEDURE (this: Recordset) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 116) END RecordCount; PROCEDURE (this: Recordset) Updatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 117) END Updatable; PROCEDURE (this: Recordset) Restartable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 118) END Restartable; PROCEDURE (this: Recordset) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 119) END ValidationText; PROCEDURE (this: Recordset) ValidationRule* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 120) END ValidationRule; PROCEDURE (this: Recordset) CacheStart* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 121) END CacheStart; PROCEDURE (this: Recordset) PUTCacheStart* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 121, p1) END PUTCacheStart; PROCEDURE (this: Recordset) CacheSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END CacheSize; PROCEDURE (this: Recordset) PUTCacheSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTCacheSize; PROCEDURE (this: Recordset) PercentPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END PercentPosition; PROCEDURE (this: Recordset) PUTPercentPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTPercentPosition; PROCEDURE (this: Recordset) AbsolutePosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END AbsolutePosition; PROCEDURE (this: Recordset) PUTAbsolutePosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 124, p1) END PUTAbsolutePosition; PROCEDURE (this: Recordset) EditMode* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 125) END EditMode; PROCEDURE (this: Recordset) ODBCFetchCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 126) END ODBCFetchCount; PROCEDURE (this: Recordset) ODBCFetchDelay* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END ODBCFetchDelay; PROCEDURE (this: Recordset) Parent* (): Database, NEW; BEGIN RETURN ThisDatabase(CtlC.GetAny(this, 128)) END Parent; PROCEDURE (this: Recordset) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 0)) END Fields; PROCEDURE (this: Recordset) AddNew* (), NEW; BEGIN CtlC.CallMethod(this, 132, NIL); END AddNew; PROCEDURE (this: Recordset) Close* (), NEW; BEGIN CtlC.CallMethod(this, 133, NIL); END Close; PROCEDURE (this: Recordset) OpenRecordset* ((* optional *) Type: CtlT.Any; Options: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 134, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END OpenRecordset; PROCEDURE (this: Recordset) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 135, NIL); END Delete; PROCEDURE (this: Recordset) Edit* (), NEW; BEGIN CtlC.CallMethod(this, 136, NIL); END Edit; PROCEDURE (this: Recordset) FindFirst* (Criteria: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[0]); CtlC.CallParMethod(this, 137, arg, NIL); END FindFirst; PROCEDURE (this: Recordset) FindLast* (Criteria: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[0]); CtlC.CallParMethod(this, 138, arg, NIL); END FindLast; PROCEDURE (this: Recordset) FindNext* (Criteria: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[0]); CtlC.CallParMethod(this, 139, arg, NIL); END FindNext; PROCEDURE (this: Recordset) FindPrevious* (Criteria: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Criteria, arg[0]); CtlC.CallParMethod(this, 140, arg, NIL); END FindPrevious; PROCEDURE (this: Recordset) MoveFirst* (), NEW; BEGIN CtlC.CallMethod(this, 141, NIL); END MoveFirst; PROCEDURE (this: Recordset) MoveNext* (), NEW; BEGIN CtlC.CallMethod(this, 143, NIL); END MoveNext; PROCEDURE (this: Recordset) MovePrevious* (), NEW; BEGIN CtlC.CallMethod(this, 144, NIL); END MovePrevious; PROCEDURE (this: Recordset) Seek* (Comparison: ARRAY OF CHAR; Key1: CtlT.Any; (* optional *) Key2: CtlT.Any; Key3: CtlT.Any; Key4: CtlT.Any; Key5: CtlT.Any; Key6: CtlT.Any; Key7: CtlT.Any; Key8: CtlT.Any; Key9: CtlT.Any; Key10: CtlT.Any; Key11: CtlT.Any; Key12: CtlT.Any; Key13: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.StrVar(Comparison, arg[13]); CtlC.AnyVar(Key1, arg[12]); CtlC.AnyVar(Key2, arg[11]); CtlC.AnyVar(Key3, arg[10]); CtlC.AnyVar(Key4, arg[9]); CtlC.AnyVar(Key5, arg[8]); CtlC.AnyVar(Key6, arg[7]); CtlC.AnyVar(Key7, arg[6]); CtlC.AnyVar(Key8, arg[5]); CtlC.AnyVar(Key9, arg[4]); CtlC.AnyVar(Key10, arg[3]); CtlC.AnyVar(Key11, arg[2]); CtlC.AnyVar(Key12, arg[1]); CtlC.AnyVar(Key13, arg[0]); CtlC.CallParMethod(this, 145, arg, NIL); END Seek; PROCEDURE (this: Recordset) Clone* (): Recordset, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 147, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END Clone; PROCEDURE (this: Recordset) Requery* ((* optional *) NewQueryDef: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NewQueryDef, arg[0]); CtlC.CallParMethod(this, 148, arg, NIL); END Requery; PROCEDURE (this: Recordset) Move* (Rows: INTEGER; (* optional *) StartBookmark: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Rows, arg[1]); CtlC.AnyVar(StartBookmark, arg[0]); CtlC.CallParMethod(this, 149, arg, NIL); END Move; PROCEDURE (this: Recordset) FillCache* ((* optional *) Rows: CtlT.Any; StartBookmark: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Rows, arg[1]); CtlC.AnyVar(StartBookmark, arg[0]); CtlC.CallParMethod(this, 150, arg, NIL); END FillCache; PROCEDURE (this: Recordset) CopyQueryDef* (): QueryDef, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 153, ret); RETURN This_QueryDef(CtlC.VarAny(ret)) END CopyQueryDef; PROCEDURE (this: Recordset) GetRows* ((* optional *) NumRows: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[0]); CtlC.CallParMethod(this, 156, arg, ret); RETURN CtlC.VarAny(ret) END GetRows; PROCEDURE (this: Recordset) Collect* (Item: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, -8, arg, ret); RETURN CtlC.VarAny(ret) END Collect; PROCEDURE (this: Recordset) PUTCollect* (Item: CtlT.Any; p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, -8, arg, NIL); END PUTCollect; PROCEDURE (this: Recordset) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 157, NIL); END Cancel; PROCEDURE (this: Recordset) NextRecordset* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 158, ret); RETURN CtlC.VarBool(ret) END NextRecordset; PROCEDURE (this: Recordset) hStmt* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 159) END hStmt; PROCEDURE (this: Recordset) StillExecuting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 160) END StillExecuting; PROCEDURE (this: Recordset) BatchSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END BatchSize; PROCEDURE (this: Recordset) PUTBatchSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTBatchSize; PROCEDURE (this: Recordset) BatchCollisionCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END BatchCollisionCount; PROCEDURE (this: Recordset) BatchCollisions* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 163) END BatchCollisions; PROCEDURE (this: Recordset) Connection* (): Connection, NEW; BEGIN RETURN ThisConnection(CtlC.GetAny(this, 164)) END Connection; PROCEDURE (this: Recordset) PUTREFConnection* (p1: Connection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 164, arg, NIL); END PUTREFConnection; PROCEDURE (this: Recordset) RecordStatus* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 165) END RecordStatus; PROCEDURE (this: Recordset) UpdateOptions* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 166) END UpdateOptions; PROCEDURE (this: Recordset) PUTUpdateOptions* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 166, p1) END PUTUpdateOptions; PROCEDURE (this: Recordset) CancelUpdate* (UpdateType: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(UpdateType, arg[0]); CtlC.CallParMethod(this, 167, arg, NIL); END CancelUpdate; PROCEDURE (this: Recordset) Update* (UpdateType: INTEGER; Force: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(UpdateType, arg[1]); CtlC.BoolVar(Force, arg[0]); CtlC.CallParMethod(this, 168, arg, NIL); END Update; PROCEDURE (this: Recordset) MoveLast* (Options: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Options, arg[0]); CtlC.CallParMethod(this, 169, arg, NIL); END MoveLast; (* ---------- _QueryDef, dual, nonextensible ---------- *) PROCEDURE (this: _QueryDef) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _QueryDef) DateCreated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809344) END DateCreated; PROCEDURE (this: _QueryDef) LastUpdated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809345) END LastUpdated; PROCEDURE (this: _QueryDef) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Name; PROCEDURE (this: _QueryDef) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTName; PROCEDURE (this: _QueryDef) ODBCTimeout* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809348) END ODBCTimeout; PROCEDURE (this: _QueryDef) PUTODBCTimeout* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809348, p1) END PUTODBCTimeout; PROCEDURE (this: _QueryDef) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809350) END Type; PROCEDURE (this: _QueryDef) SQL* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809351) END SQL; PROCEDURE (this: _QueryDef) PUTSQL* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809351, p1) END PUTSQL; PROCEDURE (this: _QueryDef) Updatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809353) END Updatable; PROCEDURE (this: _QueryDef) Connect* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809354) END Connect; PROCEDURE (this: _QueryDef) PUTConnect* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809354, p1) END PUTConnect; PROCEDURE (this: _QueryDef) ReturnsRecords* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809356) END ReturnsRecords; PROCEDURE (this: _QueryDef) PUTReturnsRecords* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809356, p1) END PUTReturnsRecords; PROCEDURE (this: _QueryDef) RecordsAffected* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809358) END RecordsAffected; PROCEDURE (this: _QueryDef) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 1610809359)) END Fields; PROCEDURE (this: _QueryDef) Parameters* (): Parameters, NEW; BEGIN RETURN ThisParameters(CtlC.GetAny(this, 0)) END Parameters; PROCEDURE (this: _QueryDef) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1610809361, NIL); END Close; PROCEDURE (this: _QueryDef) Execute* ((* optional *) Options: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 1610809365, arg, NIL); END Execute; PROCEDURE (this: _QueryDef) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809370, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; PROCEDURE (this: _QueryDef) OpenRecordset* ((* optional *) Type: CtlT.Any; Options: CtlT.Any; LockEdit: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Options, arg[1]); CtlC.AnyVar(LockEdit, arg[0]); CtlC.CallParMethod(this, 1610809371, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END OpenRecordset; PROCEDURE (this: _QueryDef) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 1610809373, NIL); END Cancel; PROCEDURE (this: _QueryDef) hStmt* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809374) END hStmt; PROCEDURE (this: _QueryDef) MaxRecords* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809375) END MaxRecords; PROCEDURE (this: _QueryDef) PUTMaxRecords* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809375, p1) END PUTMaxRecords; PROCEDURE (this: _QueryDef) StillExecuting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809377) END StillExecuting; PROCEDURE (this: _QueryDef) CacheSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809378) END CacheSize; PROCEDURE (this: _QueryDef) PUTCacheSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809378, p1) END PUTCacheSize; PROCEDURE (this: _QueryDef) Prepare* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809380) END Prepare; PROCEDURE (this: _QueryDef) PUTPrepare* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610809380, p1) END PUTPrepare; (* ---------- Parameters, dual, nonextensible ---------- *) PROCEDURE (this: Parameters) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Parameters) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Parameters) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Parameters) Item* (Item: CtlT.Any): Parameter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisParameter(CtlC.VarAny(ret)) END Item; (* ---------- Parameter, dual, nonextensible ---------- *) PROCEDURE (this: Parameter) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Parameter) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: Parameter) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Parameter) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Parameter) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809347) END Type; PROCEDURE (this: Parameter) PUTType* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809347, p1) END PUTType; PROCEDURE (this: Parameter) Direction* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610809349) END Direction; PROCEDURE (this: Parameter) PUTDirection* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610809349, p1) END PUTDirection; (* ---------- Connection, dual, nonextensible ---------- *) PROCEDURE (this: Connection) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743808) END Name; PROCEDURE (this: Connection) Connect* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Connect; PROCEDURE (this: Connection) Database* (): Database, NEW; BEGIN RETURN ThisDatabase(CtlC.GetAny(this, 1610743810)) END Database; PROCEDURE (this: Connection) hDbc* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END hDbc; PROCEDURE (this: Connection) QueryTimeout* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743812) END QueryTimeout; PROCEDURE (this: Connection) PUTQueryTimeout* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 1610743812, p1) END PUTQueryTimeout; PROCEDURE (this: Connection) Transactions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743814) END Transactions; PROCEDURE (this: Connection) RecordsAffected* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743815) END RecordsAffected; PROCEDURE (this: Connection) StillExecuting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743816) END StillExecuting; PROCEDURE (this: Connection) Updatable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743817) END Updatable; PROCEDURE (this: Connection) QueryDefs* (): QueryDefs, NEW; BEGIN RETURN ThisQueryDefs(CtlC.GetAny(this, 0)) END QueryDefs; PROCEDURE (this: Connection) Recordsets* (): Recordsets, NEW; BEGIN RETURN ThisRecordsets(CtlC.GetAny(this, 1610743819)) END Recordsets; PROCEDURE (this: Connection) Cancel* (), NEW; BEGIN CtlC.CallMethod(this, 1610743820, NIL); END Cancel; PROCEDURE (this: Connection) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1610743821, NIL); END Close; PROCEDURE (this: Connection) CreateQueryDef* ((* optional *) Name: CtlT.Any; SQLText: CtlT.Any): QueryDef, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(SQLText, arg[0]); CtlC.CallParMethod(this, 1610743822, arg, ret); RETURN This_QueryDef(CtlC.VarAny(ret)) END CreateQueryDef; PROCEDURE (this: Connection) Execute* (Query: ARRAY OF CHAR; (* optional *) Options: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Query, arg[1]); CtlC.AnyVar(Options, arg[0]); CtlC.CallParMethod(this, 1610743823, arg, NIL); END Execute; PROCEDURE (this: Connection) OpenRecordset* (Name: ARRAY OF CHAR; (* optional *) Type: CtlT.Any; Options: CtlT.Any; LockEdit: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Options, arg[1]); CtlC.AnyVar(LockEdit, arg[0]); CtlC.CallParMethod(this, 1610743824, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END OpenRecordset; (* ---------- QueryDefs, dual, nonextensible ---------- *) PROCEDURE (this: QueryDefs) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: QueryDefs) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: QueryDefs) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: QueryDefs) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: QueryDefs) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: QueryDefs) Item* (Item: CtlT.Any): QueryDef, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_QueryDef(CtlC.VarAny(ret)) END Item; (* ---------- Recordsets, dual, nonextensible ---------- *) PROCEDURE (this: Recordsets) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Recordsets) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Recordsets) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Recordsets) Item* (Item: CtlT.Any): Recordset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisRecordset(CtlC.VarAny(ret)) END Item; (* ---------- Relations, dual, nonextensible ---------- *) PROCEDURE (this: Relations) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Relations) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Relations) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Relations) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Relations) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Relations) Item* (Item: CtlT.Any): Relation, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Relation(CtlC.VarAny(ret)) END Item; (* ---------- _Relation, dual, nonextensible ---------- *) PROCEDURE (this: _Relation) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _Relation) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: _Relation) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: _Relation) Table* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809346) END Table; PROCEDURE (this: _Relation) PUTTable* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTTable; PROCEDURE (this: _Relation) ForeignTable* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809348) END ForeignTable; PROCEDURE (this: _Relation) PUTForeignTable* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809348, p1) END PUTForeignTable; PROCEDURE (this: _Relation) Attributes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809350) END Attributes; PROCEDURE (this: _Relation) PUTAttributes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809350, p1) END PUTAttributes; PROCEDURE (this: _Relation) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 0)) END Fields; PROCEDURE (this: _Relation) CreateField* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Size: CtlT.Any): Field, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(Size, arg[0]); CtlC.CallParMethod(this, 1610809353, arg, ret); RETURN This_Field(CtlC.VarAny(ret)) END CreateField; PROCEDURE (this: _Relation) PartialReplica* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809354) END PartialReplica; PROCEDURE (this: _Relation) PUTPartialReplica* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809354, p1) END PUTPartialReplica; (* ---------- Containers, dual, nonextensible ---------- *) PROCEDURE (this: Containers) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Containers) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Containers) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Containers) Item* (Item: CtlT.Any): Container, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisContainer(CtlC.VarAny(ret)) END Item; (* ---------- Container, dual, nonextensible ---------- *) PROCEDURE (this: Container) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Container) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: Container) Owner* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Owner; PROCEDURE (this: Container) PUTOwner* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809345, p1) END PUTOwner; PROCEDURE (this: Container) UserName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END UserName; PROCEDURE (this: Container) PUTUserName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTUserName; PROCEDURE (this: Container) Permissions* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END Permissions; PROCEDURE (this: Container) PUTPermissions* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTPermissions; PROCEDURE (this: Container) Inherit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809351) END Inherit; PROCEDURE (this: Container) PUTInherit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809351, p1) END PUTInherit; PROCEDURE (this: Container) Documents* (): Documents, NEW; BEGIN RETURN ThisDocuments(CtlC.GetAny(this, 0)) END Documents; PROCEDURE (this: Container) AllPermissions* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809354) END AllPermissions; (* ---------- Documents, dual, nonextensible ---------- *) PROCEDURE (this: Documents) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Documents) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Documents) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Documents) Item* (Item: CtlT.Any): Document, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisDocument(CtlC.VarAny(ret)) END Item; (* ---------- Document, dual, nonextensible ---------- *) PROCEDURE (this: Document) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: Document) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: Document) Owner* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Owner; PROCEDURE (this: Document) PUTOwner* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809345, p1) END PUTOwner; PROCEDURE (this: Document) Container* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END Container; PROCEDURE (this: Document) UserName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809348) END UserName; PROCEDURE (this: Document) PUTUserName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809348, p1) END PUTUserName; PROCEDURE (this: Document) Permissions* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809350) END Permissions; PROCEDURE (this: Document) PUTPermissions* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809350, p1) END PUTPermissions; PROCEDURE (this: Document) DateCreated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809352) END DateCreated; PROCEDURE (this: Document) LastUpdated* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610809353) END LastUpdated; PROCEDURE (this: Document) AllPermissions* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809354) END AllPermissions; PROCEDURE (this: Document) CreateProperty* ((* optional *) Name: CtlT.Any; Type: CtlT.Any; Value: CtlT.Any; DDL: CtlT.Any): Property, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Value, arg[1]); CtlC.AnyVar(DDL, arg[0]); CtlC.CallParMethod(this, 1610809355, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END CreateProperty; (* ---------- Users, dual, nonextensible ---------- *) PROCEDURE (this: Users) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Users) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Users) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Users) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Users) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Users) Item* (Item: CtlT.Any): User, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_User(CtlC.VarAny(ret)) END Item; (* ---------- _User, dual, nonextensible ---------- *) PROCEDURE (this: _User) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _User) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: _User) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: _User) PUTPID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTPID; PROCEDURE (this: _User) PUTPassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTPassword; PROCEDURE (this: _User) Groups* (): Groups, NEW; BEGIN RETURN ThisGroups(CtlC.GetAny(this, 0)) END Groups; PROCEDURE (this: _User) NewPassword* (bstrOld: ARRAY OF CHAR; bstrNew: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrOld, arg[1]); CtlC.StrVar(bstrNew, arg[0]); CtlC.CallParMethod(this, 1610809349, arg, NIL); END NewPassword; PROCEDURE (this: _User) CreateGroup* ((* optional *) Name: CtlT.Any; PID: CtlT.Any): Group, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(PID, arg[0]); CtlC.CallParMethod(this, 1610809350, arg, ret); RETURN This_Group(CtlC.VarAny(ret)) END CreateGroup; (* ---------- Groups, dual, nonextensible ---------- *) PROCEDURE (this: Groups) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Groups) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Groups) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Groups) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: Groups) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: Groups) Item* (Item: CtlT.Any): Group, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Group(CtlC.VarAny(ret)) END Item; (* ---------- _Group, dual, nonextensible ---------- *) PROCEDURE (this: _Group) Properties* (): Properties, NEW; BEGIN RETURN ThisProperties(CtlC.GetAny(this, 10)) END Properties; PROCEDURE (this: _Group) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: _Group) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809344, p1) END PUTName; PROCEDURE (this: _Group) PUTPID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809346, p1) END PUTPID; PROCEDURE (this: _Group) Users* (): Users, NEW; BEGIN RETURN ThisUsers(CtlC.GetAny(this, 0)) END Users; PROCEDURE (this: _Group) CreateUser* ((* optional *) Name: CtlT.Any; PID: CtlT.Any; Password: CtlT.Any): User, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(PID, arg[1]); CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 1610809348, arg, ret); RETURN This_User(CtlC.VarAny(ret)) END CreateUser; (* ---------- Connections, dual, nonextensible ---------- *) PROCEDURE (this: Connections) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Connections) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Connections) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Connections) Item* (Item: CtlT.Any): Connection, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisConnection(CtlC.VarAny(ret)) END Item; (* ---------- Errors, dual, nonextensible ---------- *) PROCEDURE (this: Errors) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: Errors) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Errors) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: Errors) Item* (Item: CtlT.Any): Error, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisError(CtlC.VarAny(ret)) END Item; (* ---------- Error, dual, nonextensible ---------- *) PROCEDURE (this: Error) Number* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Number; PROCEDURE (this: Error) Source* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Source; PROCEDURE (this: Error) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Description; PROCEDURE (this: Error) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743811) END HelpFile; PROCEDURE (this: Error) HelpContext* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743812) END HelpContext; (* ---------- IndexFields, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IndexFields) Count* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 1610743808) END Count; PROCEDURE (this: IndexFields) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: IndexFields) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Refresh; PROCEDURE (this: IndexFields) Append* (Object: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, NIL); END Append; PROCEDURE (this: IndexFields) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Delete; PROCEDURE (this: IndexFields) Item* ((* optional *) Item: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Item, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarAny(ret) END Item; PROCEDURE NewTableDef* (): _TableDef; BEGIN RETURN This_TableDef(CtlC.NewObj("{00000103-0000-0010-8000-00AA006D2EA4}")) END NewTableDef; PROCEDURE NewField* (): _Field; BEGIN RETURN This_Field(CtlC.NewObj("{00000104-0000-0010-8000-00AA006D2EA4}")) END NewField; PROCEDURE NewIndex* (): _Index; BEGIN RETURN This_Index(CtlC.NewObj("{00000105-0000-0010-8000-00AA006D2EA4}")) END NewIndex; PROCEDURE NewQueryDef* (): _QueryDef; BEGIN RETURN This_QueryDef(CtlC.NewObj("{00000108-0000-0010-8000-00AA006D2EA4}")) END NewQueryDef; PROCEDURE NewRelation* (): _Relation; BEGIN RETURN This_Relation(CtlC.NewObj("{00000109-0000-0010-8000-00AA006D2EA4}")) END NewRelation; PROCEDURE NewUser* (): _User; BEGIN RETURN This_User(CtlC.NewObj("{00000107-0000-0010-8000-00AA006D2EA4}")) END NewUser; PROCEDURE NewGroup* (): _Group; BEGIN RETURN This_Group(CtlC.NewObj("{00000106-0000-0010-8000-00AA006D2EA4}")) END NewGroup; PROCEDURE NewDBEngine* (): _DBEngine; BEGIN RETURN This_DBEngine(CtlC.NewObj("{00000100-0000-0010-8000-00AA006D2EA4}")) END NewDBEngine; PROCEDURE NewPrivDBEngine* (): _DBEngine; BEGIN RETURN This_DBEngine(CtlC.NewObj("{00000101-0000-0010-8000-00AA006D2EA4}")) END NewPrivDBEngine; END CtlDAO36.

Ctl/Mod/DAO36.odc

MODULE CtlExcel9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Excel 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\VBAXL9.CHM, id: 65535 *) (* guid: {00020813-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 1.3 *) IMPORT CtlT, CtlC, CtlOffice, CtlVBIDE; CONST (* Constants *) xlAll* = -4104; xlAutomatic* = -4105; xlBoth* = 1; xlCenter* = -4108; xlChecker* = 9; xlCircle* = 8; xlCorner* = 2; xlCrissCross* = 16; xlCross* = 4; xlDiamond* = 2; xlDistributed* = -4117; xlDoubleAccounting* = 5; xlFixedValue* = 1; xlFormats* = -4122; xlGray16* = 17; xlGray8* = 18; xlGrid* = 15; xlHigh* = -4127; xlInside* = 2; xlJustify* = -4130; xlLightDown* = 13; xlLightHorizontal* = 11; xlLightUp* = 14; xlLightVertical* = 12; xlLow* = -4134; xlManual* = -4135; xlMinusValues* = 3; xlModule* = -4141; xlNextToAxis* = 4; xlNone* = -4142; xlNotes* = -4144; xlOff* = -4146; xlOn* = 1; xlPercent* = 2; xlPlus* = 9; xlPlusValues* = 2; xlSemiGray75* = 10; xlShowLabel* = 4; xlShowLabelAndPercent* = 5; xlShowPercent* = 3; xlShowValue* = 2; xlSimple* = -4154; xlSingle* = 2; xlSingleAccounting* = 4; xlSolid* = 1; xlSquare* = 1; xlStar* = 5; xlStError* = 4; xlToolbarButton* = 2; xlTriangle* = 3; xlGray25* = -4124; xlGray50* = -4125; xlGray75* = -4126; xlBottom* = -4107; xlLeft* = -4131; xlRight* = -4152; xlTop* = -4160; xl3DBar* = -4099; xl3DSurface* = -4103; xlBar* = 2; xlColumn* = 3; xlCombination* = -4111; xlCustom* = -4114; xlDefaultAutoFormat* = -1; xlMaximum* = 2; xlMinimum* = 4; xlOpaque* = 3; xlTransparent* = 2; xlBidi* = -5000; xlLatin* = -5001; xlContext* = -5002; xlLTR* = -5003; xlRTL* = -5004; xlFullScript* = 1; xlPartialScript* = 2; xlMixedScript* = 3; xlMixedAuthorizedScript* = 4; xlVisualCursor* = 2; xlLogicalCursor* = 1; xlSystem* = 1; xlPartial* = 3; xlHindiNumerals* = 3; xlBidiCalendar* = 3; xlGregorian* = 2; xlComplete* = 4; xlScale* = 3; xlClosed* = 3; xlColor1* = 7; xlColor2* = 8; xlColor3* = 9; xlConstants* = 2; xlContents* = 2; xlBelow* = 1; xlCascade* = 7; xlCenterAcrossSelection* = 7; xlChart4* = 2; xlChartSeries* = 17; xlChartShort* = 6; xlChartTitles* = 18; xlClassic1* = 1; xlClassic2* = 2; xlClassic3* = 3; xl3DEffects1* = 13; xl3DEffects2* = 14; xlAbove* = 0; xlAccounting1* = 4; xlAccounting2* = 5; xlAccounting3* = 6; xlAccounting4* = 17; xlAdd* = 2; xlDebugCodePane* = 13; xlDesktop* = 9; xlDirect* = 1; xlDivide* = 5; xlDoubleClosed* = 5; xlDoubleOpen* = 4; xlDoubleQuote* = 1; xlEntireChart* = 20; xlExcelMenus* = 1; xlExtended* = 3; xlFill* = 5; xlFirst* = 0; xlFloating* = 5; xlFormula* = 5; xlGeneral* = 1; xlGridline* = 22; xlIcons* = 1; xlImmediatePane* = 12; xlInteger* = 2; xlLast* = 1; xlLastCell* = 11; xlList1* = 10; xlList2* = 11; xlList3* = 12; xlLocalFormat1* = 15; xlLocalFormat2* = 16; xlLong* = 3; xlLotusHelp* = 2; xlMacrosheetCell* = 7; xlMixed* = 2; xlMultiply* = 4; xlNarrow* = 1; xlNoDocuments* = 3; xlOpen* = 2; xlOutside* = 3; xlReference* = 4; xlSemiautomatic* = 2; xlShort* = 1; xlSingleQuote* = 2; xlStrict* = 2; xlSubtract* = 3; xlTextBox* = 16; xlTiled* = 1; xlTitleBar* = 8; xlToolbar* = 1; xlVisible* = 12; xlWatchPane* = 11; xlWide* = 3; xlWorkbookTab* = 6; xlWorksheet4* = 1; xlWorksheetCell* = 3; xlWorksheetShort* = 5; xlAllExceptBorders* = 6; xlLeftToRight* = 2; xlTopToBottom* = 1; xlVeryHidden* = 2; xlDrawingObject* = 14; (* XlCreator *) xlCreatorCode* = 1480803660; (* XlChartGallery *) xlBuiltIn* = 21; xlUserDefined* = 22; xlAnyGallery* = 23; (* XlColorIndex *) xlColorIndexAutomatic* = -4105; xlColorIndexNone* = -4142; (* XlEndStyleCap *) xlCap* = 1; xlNoCap* = 2; (* XlRowCol *) xlColumns* = 2; xlRows* = 1; (* XlScaleType *) xlScaleLinear* = -4132; xlScaleLogarithmic* = -4133; (* XlDataSeriesType *) xlAutoFill* = 4; xlChronological* = 3; xlGrowth* = 2; xlDataSeriesLinear* = -4132; (* XlAxisCrosses *) xlAxisCrossesAutomatic* = -4105; xlAxisCrossesCustom* = -4114; xlAxisCrossesMaximum* = 2; xlAxisCrossesMinimum* = 4; (* XlAxisGroup *) xlPrimary* = 1; xlSecondary* = 2; (* XlBackground *) xlBackgroundAutomatic* = -4105; xlBackgroundOpaque* = 3; xlBackgroundTransparent* = 2; (* XlWindowState *) xlMaximized* = -4137; xlMinimized* = -4140; xlNormal* = -4143; (* XlAxisType *) xlCategory* = 1; xlSeriesAxis* = 3; xlValue* = 2; (* XlArrowHeadLength *) xlArrowHeadLengthLong* = 3; xlArrowHeadLengthMedium* = -4138; xlArrowHeadLengthShort* = 1; (* XlVAlign *) xlVAlignBottom* = -4107; xlVAlignCenter* = -4108; xlVAlignDistributed* = -4117; xlVAlignJustify* = -4130; xlVAlignTop* = -4160; (* XlTickMark *) xlTickMarkCross* = 4; xlTickMarkInside* = 2; xlTickMarkNone* = -4142; xlTickMarkOutside* = 3; (* XlErrorBarDirection *) xlX* = -4168; xlY* = 1; (* XlErrorBarInclude *) xlErrorBarIncludeBoth* = 1; xlErrorBarIncludeMinusValues* = 3; xlErrorBarIncludeNone* = -4142; xlErrorBarIncludePlusValues* = 2; (* XlDisplayBlanksAs *) xlInterpolated* = 3; xlNotPlotted* = 1; xlZero* = 2; (* XlArrowHeadStyle *) xlArrowHeadStyleClosed* = 3; xlArrowHeadStyleDoubleClosed* = 5; xlArrowHeadStyleDoubleOpen* = 4; xlArrowHeadStyleNone* = -4142; xlArrowHeadStyleOpen* = 2; (* XlArrowHeadWidth *) xlArrowHeadWidthMedium* = -4138; xlArrowHeadWidthNarrow* = 1; xlArrowHeadWidthWide* = 3; (* XlHAlign *) xlHAlignCenter* = -4108; xlHAlignCenterAcrossSelection* = 7; xlHAlignDistributed* = -4117; xlHAlignFill* = 5; xlHAlignGeneral* = 1; xlHAlignJustify* = -4130; xlHAlignLeft* = -4131; xlHAlignRight* = -4152; (* XlTickLabelPosition *) xlTickLabelPositionHigh* = -4127; xlTickLabelPositionLow* = -4134; xlTickLabelPositionNextToAxis* = 4; xlTickLabelPositionNone* = -4142; (* XlLegendPosition *) xlLegendPositionBottom* = -4107; xlLegendPositionCorner* = 2; xlLegendPositionLeft* = -4131; xlLegendPositionRight* = -4152; xlLegendPositionTop* = -4160; (* XlChartPictureType *) xlStackScale* = 3; xlStack* = 2; xlStretch* = 1; (* XlChartPicturePlacement *) xlSides* = 1; xlEnd* = 2; xlEndSides* = 3; xlFront* = 4; xlFrontSides* = 5; xlFrontEnd* = 6; xlAllFaces* = 7; (* XlOrientation *) xlDownward* = -4170; xlHorizontal* = -4128; xlUpward* = -4171; xlVertical* = -4166; (* XlTickLabelOrientation *) xlTickLabelOrientationAutomatic* = -4105; xlTickLabelOrientationDownward* = -4170; xlTickLabelOrientationHorizontal* = -4128; xlTickLabelOrientationUpward* = -4171; xlTickLabelOrientationVertical* = -4166; (* XlBorderWeight *) xlHairline* = 1; xlMedium* = -4138; xlThick* = 4; xlThin* = 2; (* XlDataSeriesDate *) xlDay* = 1; xlMonth* = 3; xlWeekday* = 2; xlYear* = 4; (* XlUnderlineStyle *) xlUnderlineStyleDouble* = -4119; xlUnderlineStyleDoubleAccounting* = 5; xlUnderlineStyleNone* = -4142; xlUnderlineStyleSingle* = 2; xlUnderlineStyleSingleAccounting* = 4; (* XlErrorBarType *) xlErrorBarTypeCustom* = -4114; xlErrorBarTypeFixedValue* = 1; xlErrorBarTypePercent* = 2; xlErrorBarTypeStDev* = -4155; xlErrorBarTypeStError* = 4; (* XlTrendlineType *) xlExponential* = 5; xlLinear* = -4132; xlLogarithmic* = -4133; xlMovingAvg* = 6; xlPolynomial* = 3; xlPower* = 4; (* XlLineStyle *) xlContinuous* = 1; xlDash* = -4115; xlDashDot* = 4; xlDashDotDot* = 5; xlDot* = -4118; xlDouble* = -4119; xlSlantDashDot* = 13; xlLineStyleNone* = -4142; (* XlDataLabelsType *) xlDataLabelsShowNone* = -4142; xlDataLabelsShowValue* = 2; xlDataLabelsShowPercent* = 3; xlDataLabelsShowLabel* = 4; xlDataLabelsShowLabelAndPercent* = 5; xlDataLabelsShowBubbleSizes* = 6; (* XlMarkerStyle *) xlMarkerStyleAutomatic* = -4105; xlMarkerStyleCircle* = 8; xlMarkerStyleDash* = -4115; xlMarkerStyleDiamond* = 2; xlMarkerStyleDot* = -4118; xlMarkerStyleNone* = -4142; xlMarkerStylePicture* = -4147; xlMarkerStylePlus* = 9; xlMarkerStyleSquare* = 1; xlMarkerStyleStar* = 5; xlMarkerStyleTriangle* = 3; xlMarkerStyleX* = -4168; (* XlPictureConvertorType *) xlBMP* = 1; xlCGM* = 7; xlDRW* = 4; xlDXF* = 5; xlEPS* = 8; xlHGL* = 6; xlPCT* = 13; xlPCX* = 10; xlPIC* = 11; xlPLT* = 12; xlTIF* = 9; xlWMF* = 2; xlWPG* = 3; (* XlPattern *) xlPatternAutomatic* = -4105; xlPatternChecker* = 9; xlPatternCrissCross* = 16; xlPatternDown* = -4121; xlPatternGray16* = 17; xlPatternGray25* = -4124; xlPatternGray50* = -4125; xlPatternGray75* = -4126; xlPatternGray8* = 18; xlPatternGrid* = 15; xlPatternHorizontal* = -4128; xlPatternLightDown* = 13; xlPatternLightHorizontal* = 11; xlPatternLightUp* = 14; xlPatternLightVertical* = 12; xlPatternNone* = -4142; xlPatternSemiGray75* = 10; xlPatternSolid* = 1; xlPatternUp* = -4162; xlPatternVertical* = -4166; (* XlChartSplitType *) xlSplitByPosition* = 1; xlSplitByPercentValue* = 3; xlSplitByCustomSplit* = 4; xlSplitByValue* = 2; (* XlDisplayUnit *) xlHundreds* = -2; xlThousands* = -3; xlTenThousands* = -4; xlHundredThousands* = -5; xlMillions* = -6; xlTenMillions* = -7; xlHundredMillions* = -8; xlThousandMillions* = -9; xlMillionMillions* = -10; (* XlDataLabelPosition *) xlLabelPositionCenter* = -4108; xlLabelPositionAbove* = 0; xlLabelPositionBelow* = 1; xlLabelPositionLeft* = -4131; xlLabelPositionRight* = -4152; xlLabelPositionOutsideEnd* = 2; xlLabelPositionInsideEnd* = 3; xlLabelPositionInsideBase* = 4; xlLabelPositionBestFit* = 5; xlLabelPositionMixed* = 6; xlLabelPositionCustom* = 7; (* XlTimeUnit *) xlDays* = 0; xlMonths* = 1; xlYears* = 2; (* XlCategoryType *) xlCategoryScale* = 2; xlTimeScale* = 3; xlAutomaticScale* = -4105; (* XlBarShape *) xlBox* = 0; xlPyramidToPoint* = 1; xlPyramidToMax* = 2; xlCylinder* = 3; xlConeToPoint* = 4; xlConeToMax* = 5; (* XlChartType *) xlColumnClustered* = 51; xlColumnStacked* = 52; xlColumnStacked100* = 53; xl3DColumnClustered* = 54; xl3DColumnStacked* = 55; xl3DColumnStacked100* = 56; xlBarClustered* = 57; xlBarStacked* = 58; xlBarStacked100* = 59; xl3DBarClustered* = 60; xl3DBarStacked* = 61; xl3DBarStacked100* = 62; xlLineStacked* = 63; xlLineStacked100* = 64; xlLineMarkers* = 65; xlLineMarkersStacked* = 66; xlLineMarkersStacked100* = 67; xlPieOfPie* = 68; xlPieExploded* = 69; xl3DPieExploded* = 70; xlBarOfPie* = 71; xlXYScatterSmooth* = 72; xlXYScatterSmoothNoMarkers* = 73; xlXYScatterLines* = 74; xlXYScatterLinesNoMarkers* = 75; xlAreaStacked* = 76; xlAreaStacked100* = 77; xl3DAreaStacked* = 78; xl3DAreaStacked100* = 79; xlDoughnutExploded* = 80; xlRadarMarkers* = 81; xlRadarFilled* = 82; xlSurface* = 83; xlSurfaceWireframe* = 84; xlSurfaceTopView* = 85; xlSurfaceTopViewWireframe* = 86; xlBubble* = 15; xlBubble3DEffect* = 87; xlStockHLC* = 88; xlStockOHLC* = 89; xlStockVHLC* = 90; xlStockVOHLC* = 91; xlCylinderColClustered* = 92; xlCylinderColStacked* = 93; xlCylinderColStacked100* = 94; xlCylinderBarClustered* = 95; xlCylinderBarStacked* = 96; xlCylinderBarStacked100* = 97; xlCylinderCol* = 98; xlConeColClustered* = 99; xlConeColStacked* = 100; xlConeColStacked100* = 101; xlConeBarClustered* = 102; xlConeBarStacked* = 103; xlConeBarStacked100* = 104; xlConeCol* = 105; xlPyramidColClustered* = 106; xlPyramidColStacked* = 107; xlPyramidColStacked100* = 108; xlPyramidBarClustered* = 109; xlPyramidBarStacked* = 110; xlPyramidBarStacked100* = 111; xlPyramidCol* = 112; xl3DColumn* = -4100; xlLine* = 4; xl3DLine* = -4101; xl3DPie* = -4102; xlPie* = 5; xlXYScatter* = -4169; xl3DArea* = -4098; xlArea* = 1; xlDoughnut* = -4120; xlRadar* = -4151; (* XlChartItem *) xlDataLabel* = 0; xlChartArea* = 2; xlSeries* = 3; xlChartTitle* = 4; xlWalls* = 5; xlCorners* = 6; xlDataTable* = 7; xlTrendline* = 8; xlErrorBars* = 9; xlXErrorBars* = 10; xlYErrorBars* = 11; xlLegendEntry* = 12; xlLegendKey* = 13; xlShape* = 14; xlMajorGridlines* = 15; xlMinorGridlines* = 16; xlAxisTitle* = 17; xlUpBars* = 18; xlPlotArea* = 19; xlDownBars* = 20; xlAxis* = 21; xlSeriesLines* = 22; xlFloor* = 23; xlLegend* = 24; xlHiLoLines* = 25; xlDropLines* = 26; xlRadarAxisLabels* = 27; xlNothing* = 28; xlLeaderLines* = 29; xlDisplayUnitLabel* = 30; xlPivotChartFieldButton* = 31; xlPivotChartDropZone* = 32; (* XlSizeRepresents *) xlSizeIsWidth* = 2; xlSizeIsArea* = 1; (* XlInsertShiftDirection *) xlShiftDown* = -4121; xlShiftToRight* = -4161; (* XlDeleteShiftDirection *) xlShiftToLeft* = -4159; xlShiftUp* = -4162; (* XlDirection *) xlDown* = -4121; xlToLeft* = -4159; xlToRight* = -4161; xlUp* = -4162; (* XlConsolidationFunction *) xlAverage* = -4106; xlCount* = -4112; xlCountNums* = -4113; xlMax* = -4136; xlMin* = -4139; xlProduct* = -4149; xlStDev* = -4155; xlStDevP* = -4156; xlSum* = -4157; xlVar* = -4164; xlVarP* = -4165; xlUnknown* = 1000; (* XlSheetType *) xlChart* = -4109; xlDialogSheet* = -4116; xlExcel4IntlMacroSheet* = 4; xlExcel4MacroSheet* = 3; xlWorksheet* = -4167; (* XlLocationInTable *) xlColumnHeader* = -4110; xlColumnItem* = 5; xlDataHeader* = 3; xlDataItem* = 7; xlPageHeader* = 2; xlPageItem* = 6; xlRowHeader* = -4153; xlRowItem* = 4; xlTableBody* = 8; (* XlFindLookIn *) xlFormulas* = -4123; xlComments* = -4144; xlValues* = -4163; (* XlWindowType *) xlChartAsWindow* = 5; xlChartInPlace* = 4; xlClipboard* = 3; xlInfo* = -4129; xlWorkbook* = 1; (* XlPivotFieldDataType *) xlDate* = 2; xlNumber* = -4145; xlText* = -4158; (* XlCopyPictureFormat *) xlBitmap* = 2; xlPicture* = -4147; (* XlPivotTableSourceType *) xlConsolidation* = 3; xlDatabase* = 1; xlExternal* = 2; xlPivotTable* = -4148; (* XlReferenceStyle *) xlA1* = 1; xlR1C1* = -4150; (* XlMSApplication *) xlMicrosoftAccess* = 4; xlMicrosoftFoxPro* = 5; xlMicrosoftMail* = 3; xlMicrosoftPowerPoint* = 2; xlMicrosoftProject* = 6; xlMicrosoftSchedulePlus* = 7; xlMicrosoftWord* = 1; (* XlMouseButton *) xlNoButton* = 0; xlPrimaryButton* = 1; xlSecondaryButton* = 2; (* XlCutCopyMode *) xlCopy* = 1; xlCut* = 2; (* XlFillWith *) xlFillWithAll* = -4104; xlFillWithContents* = 2; xlFillWithFormats* = -4122; (* XlFilterAction *) xlFilterCopy* = 2; xlFilterInPlace* = 1; (* XlOrder *) xlDownThenOver* = 1; xlOverThenDown* = 2; (* XlLinkType *) xlLinkTypeExcelLinks* = 1; xlLinkTypeOLELinks* = 2; (* XlApplyNamesOrder *) xlColumnThenRow* = 2; xlRowThenColumn* = 1; (* XlEnableCancelKey *) xlDisabled* = 0; xlErrorHandler* = 2; xlInterrupt* = 1; (* XlPageBreak *) xlPageBreakAutomatic* = -4105; xlPageBreakManual* = -4135; xlPageBreakNone* = -4142; (* XlOLEType *) xlOLEControl* = 2; xlOLEEmbed* = 1; xlOLELink* = 0; (* XlPageOrientation *) xlLandscape* = 2; xlPortrait* = 1; (* XlLinkInfo *) xlEditionDate* = 2; xlUpdateState* = 1; (* XlCommandUnderlines *) xlCommandUnderlinesAutomatic* = -4105; xlCommandUnderlinesOff* = -4146; xlCommandUnderlinesOn* = 1; (* XlOLEVerb *) xlVerbOpen* = 2; xlVerbPrimary* = 1; (* XlCalculation *) xlCalculationAutomatic* = -4105; xlCalculationManual* = -4135; xlCalculationSemiautomatic* = 2; (* XlFileAccess *) xlReadOnly* = 3; xlReadWrite* = 2; (* XlEditionType *) xlPublisher* = 1; xlSubscriber* = 2; (* XlObjectSize *) xlFitToPage* = 2; xlFullPage* = 3; xlScreenSize* = 1; (* XlLookAt *) xlPart* = 2; xlWhole* = 1; (* XlMailSystem *) xlMAPI* = 1; xlNoMailSystem* = 0; xlPowerTalk* = 2; (* XlLinkInfoType *) xlLinkInfoOLELinks* = 2; xlLinkInfoPublishers* = 5; xlLinkInfoSubscribers* = 6; (* XlCVError *) xlErrDiv0* = 2007; xlErrNA* = 2042; xlErrName* = 2029; xlErrNull* = 2000; xlErrNum* = 2036; xlErrRef* = 2023; xlErrValue* = 2015; (* XlEditionFormat *) xlBIFF* = 2; xlPICT* = 1; xlRTF* = 4; xlVALU* = 8; (* XlLink *) xlExcelLinks* = 1; xlOLELinks* = 2; xlPublishers* = 5; xlSubscribers* = 6; (* XlCellType *) xlCellTypeBlanks* = 4; xlCellTypeConstants* = 2; xlCellTypeFormulas* = -4123; xlCellTypeLastCell* = 11; xlCellTypeComments* = -4144; xlCellTypeVisible* = 12; xlCellTypeAllFormatConditions* = -4172; xlCellTypeSameFormatConditions* = -4173; xlCellTypeAllValidation* = -4174; xlCellTypeSameValidation* = -4175; (* XlArrangeStyle *) xlArrangeStyleCascade* = 7; xlArrangeStyleHorizontal* = -4128; xlArrangeStyleTiled* = 1; xlArrangeStyleVertical* = -4166; (* XlMousePointer *) xlIBeam* = 3; xlDefault* = -4143; xlNorthwestArrow* = 1; xlWait* = 2; (* XlEditionOptionsOption *) xlAutomaticUpdate* = 4; xlCancel* = 1; xlChangeAttributes* = 6; xlManualUpdate* = 5; xlOpenSource* = 3; xlSelect* = 3; xlSendPublisher* = 2; xlUpdateSubscriber* = 2; (* XlAutoFillType *) xlFillCopy* = 1; xlFillDays* = 5; xlFillDefault* = 0; xlFillFormats* = 3; xlFillMonths* = 7; xlFillSeries* = 2; xlFillValues* = 4; xlFillWeekdays* = 6; xlFillYears* = 8; xlGrowthTrend* = 10; xlLinearTrend* = 9; (* XlAutoFilterOperator *) xlAnd* = 1; xlBottom10Items* = 4; xlBottom10Percent* = 6; xlOr* = 2; xlTop10Items* = 3; xlTop10Percent* = 5; (* XlClipboardFormat *) xlClipboardFormatBIFF* = 8; xlClipboardFormatBIFF2* = 18; xlClipboardFormatBIFF3* = 20; xlClipboardFormatBIFF4* = 30; xlClipboardFormatBinary* = 15; xlClipboardFormatBitmap* = 9; xlClipboardFormatCGM* = 13; xlClipboardFormatCSV* = 5; xlClipboardFormatDIF* = 4; xlClipboardFormatDspText* = 12; xlClipboardFormatEmbeddedObject* = 21; xlClipboardFormatEmbedSource* = 22; xlClipboardFormatLink* = 11; xlClipboardFormatLinkSource* = 23; xlClipboardFormatLinkSourceDesc* = 32; xlClipboardFormatMovie* = 24; xlClipboardFormatNative* = 14; xlClipboardFormatObjectDesc* = 31; xlClipboardFormatObjectLink* = 19; xlClipboardFormatOwnerLink* = 17; xlClipboardFormatPICT* = 2; xlClipboardFormatPrintPICT* = 3; xlClipboardFormatRTF* = 7; xlClipboardFormatScreenPICT* = 29; xlClipboardFormatStandardFont* = 28; xlClipboardFormatStandardScale* = 27; xlClipboardFormatSYLK* = 6; xlClipboardFormatTable* = 16; xlClipboardFormatText* = 0; xlClipboardFormatToolFace* = 25; xlClipboardFormatToolFacePICT* = 26; xlClipboardFormatVALU* = 1; xlClipboardFormatWK1* = 10; (* XlFileFormat *) xlAddIn* = 18; xlCSV* = 6; xlCSVMac* = 22; xlCSVMSDOS* = 24; xlCSVWindows* = 23; xlDBF2* = 7; xlDBF3* = 8; xlDBF4* = 11; xlDIF* = 9; xlExcel2* = 16; xlExcel2FarEast* = 27; xlExcel3* = 29; xlExcel4* = 33; xlExcel5* = 39; xlExcel7* = 39; xlExcel9795* = 43; xlExcel4Workbook* = 35; xlIntlAddIn* = 26; xlIntlMacro* = 25; xlWorkbookNormal* = -4143; xlSYLK* = 2; xlTemplate* = 17; xlCurrentPlatformText* = -4158; xlTextMac* = 19; xlTextMSDOS* = 21; xlTextPrinter* = 36; xlTextWindows* = 20; xlWJ2WD1* = 14; xlWK1* = 5; xlWK1ALL* = 31; xlWK1FMT* = 30; xlWK3* = 15; xlWK4* = 38; xlWK3FM3* = 32; xlWKS* = 4; xlWorks2FarEast* = 28; xlWQ1* = 34; xlWJ3* = 40; xlWJ3FJ3* = 41; xlUnicodeText* = 42; xlHtml* = 44; (* XlApplicationInternational *) xl24HourClock* = 33; xl4DigitYears* = 43; xlAlternateArraySeparator* = 16; xlColumnSeparator* = 14; xlCountryCode* = 1; xlCountrySetting* = 2; xlCurrencyBefore* = 37; xlCurrencyCode* = 25; xlCurrencyDigits* = 27; xlCurrencyLeadingZeros* = 40; xlCurrencyMinusSign* = 38; xlCurrencyNegative* = 28; xlCurrencySpaceBefore* = 36; xlCurrencyTrailingZeros* = 39; xlDateOrder* = 32; xlDateSeparator* = 17; xlDayCode* = 21; xlDayLeadingZero* = 42; xlDecimalSeparator* = 3; xlGeneralFormatName* = 26; xlHourCode* = 22; xlLeftBrace* = 12; xlLeftBracket* = 10; xlListSeparator* = 5; xlLowerCaseColumnLetter* = 9; xlLowerCaseRowLetter* = 8; xlMDY* = 44; xlMetric* = 35; xlMinuteCode* = 23; xlMonthCode* = 20; xlMonthLeadingZero* = 41; xlMonthNameChars* = 30; xlNoncurrencyDigits* = 29; xlNonEnglishFunctions* = 34; xlRightBrace* = 13; xlRightBracket* = 11; xlRowSeparator* = 15; xlSecondCode* = 24; xlThousandsSeparator* = 4; xlTimeLeadingZero* = 45; xlTimeSeparator* = 18; xlUpperCaseColumnLetter* = 7; xlUpperCaseRowLetter* = 6; xlWeekdayNameChars* = 31; xlYearCode* = 19; (* XlPageBreakExtent *) xlPageBreakFull* = 1; xlPageBreakPartial* = 2; (* XlCellInsertionMode *) xlOverwriteCells* = 0; xlInsertDeleteCells* = 1; xlInsertEntireRows* = 2; (* XlFormulaLabel *) xlNoLabels* = -4142; xlRowLabels* = 1; xlColumnLabels* = 2; xlMixedLabels* = 3; (* XlHighlightChangesTime *) xlSinceMyLastSave* = 1; xlAllChanges* = 2; xlNotYetReviewed* = 3; (* XlCommentDisplayMode *) xlNoIndicator* = 0; xlCommentIndicatorOnly* = -1; xlCommentAndIndicator* = 1; (* XlFormatConditionType *) xlCellValue* = 1; xlExpression* = 2; (* XlFormatConditionOperator *) xlBetween* = 1; xlNotBetween* = 2; xlEqual* = 3; xlNotEqual* = 4; xlGreater* = 5; xlLess* = 6; xlGreaterEqual* = 7; xlLessEqual* = 8; (* XlEnableSelection *) xlNoRestrictions* = 0; xlUnlockedCells* = 1; xlNoSelection* = -4142; (* XlDVType *) xlValidateInputOnly* = 0; xlValidateWholeNumber* = 1; xlValidateDecimal* = 2; xlValidateList* = 3; xlValidateDate* = 4; xlValidateTime* = 5; xlValidateTextLength* = 6; xlValidateCustom* = 7; (* XlIMEMode *) xlIMEModeNoControl* = 0; xlIMEModeOn* = 1; xlIMEModeOff* = 2; xlIMEModeDisable* = 3; xlIMEModeHiragana* = 4; xlIMEModeKatakana* = 5; xlIMEModeKatakanaHalf* = 6; xlIMEModeAlphaFull* = 7; xlIMEModeAlpha* = 8; xlIMEModeHangulFull* = 9; xlIMEModeHangul* = 10; (* XlDVAlertStyle *) xlValidAlertStop* = 1; xlValidAlertWarning* = 2; xlValidAlertInformation* = 3; (* XlChartLocation *) xlLocationAsNewSheet* = 1; xlLocationAsObject* = 2; xlLocationAutomatic* = 3; (* XlPaperSize *) xlPaper10x14* = 16; xlPaper11x17* = 17; xlPaperA3* = 8; xlPaperA4* = 9; xlPaperA4Small* = 10; xlPaperA5* = 11; xlPaperB4* = 12; xlPaperB5* = 13; xlPaperCsheet* = 24; xlPaperDsheet* = 25; xlPaperEnvelope10* = 20; xlPaperEnvelope11* = 21; xlPaperEnvelope12* = 22; xlPaperEnvelope14* = 23; xlPaperEnvelope9* = 19; xlPaperEnvelopeB4* = 33; xlPaperEnvelopeB5* = 34; xlPaperEnvelopeB6* = 35; xlPaperEnvelopeC3* = 29; xlPaperEnvelopeC4* = 30; xlPaperEnvelopeC5* = 28; xlPaperEnvelopeC6* = 31; xlPaperEnvelopeC65* = 32; xlPaperEnvelopeDL* = 27; xlPaperEnvelopeItaly* = 36; xlPaperEnvelopeMonarch* = 37; xlPaperEnvelopePersonal* = 38; xlPaperEsheet* = 26; xlPaperExecutive* = 7; xlPaperFanfoldLegalGerman* = 41; xlPaperFanfoldStdGerman* = 40; xlPaperFanfoldUS* = 39; xlPaperFolio* = 14; xlPaperLedger* = 4; xlPaperLegal* = 5; xlPaperLetter* = 1; xlPaperLetterSmall* = 2; xlPaperNote* = 18; xlPaperQuarto* = 15; xlPaperStatement* = 6; xlPaperTabloid* = 3; xlPaperUser* = 256; (* XlPasteSpecialOperation *) xlPasteSpecialOperationAdd* = 2; xlPasteSpecialOperationDivide* = 5; xlPasteSpecialOperationMultiply* = 4; xlPasteSpecialOperationNone* = -4142; xlPasteSpecialOperationSubtract* = 3; (* XlPasteType *) xlPasteAll* = -4104; xlPasteAllExceptBorders* = 7; xlPasteFormats* = -4122; xlPasteFormulas* = -4123; xlPasteComments* = -4144; xlPasteValues* = -4163; (* XlPhoneticCharacterType *) xlKatakanaHalf* = 0; xlKatakana* = 1; xlHiragana* = 2; xlNoConversion* = 3; (* XlPhoneticAlignment *) xlPhoneticAlignNoControl* = 0; xlPhoneticAlignLeft* = 1; xlPhoneticAlignCenter* = 2; xlPhoneticAlignDistributed* = 3; (* XlPictureAppearance *) xlPrinter* = 2; xlScreen* = 1; (* XlPivotFieldOrientation *) xlColumnField* = 2; xlDataField* = 4; xlHidden* = 0; xlPageField* = 3; xlRowField* = 1; (* XlPivotFieldCalculation *) xlDifferenceFrom* = 2; xlIndex* = 9; xlNoAdditionalCalculation* = -4143; xlPercentDifferenceFrom* = 4; xlPercentOf* = 3; xlPercentOfColumn* = 7; xlPercentOfRow* = 6; xlPercentOfTotal* = 8; xlRunningTotal* = 5; (* XlPlacement *) xlFreeFloating* = 3; xlMove* = 2; xlMoveAndSize* = 1; (* XlPlatform *) xlMacintosh* = 1; xlMSDOS* = 3; xlWindows* = 2; (* XlPrintLocation *) xlPrintSheetEnd* = 1; xlPrintInPlace* = 16; xlPrintNoComments* = -4142; (* XlPriority *) xlPriorityHigh* = -4127; xlPriorityLow* = -4134; xlPriorityNormal* = -4143; (* XlPTSelectionMode *) xlLabelOnly* = 1; xlDataAndLabel* = 0; xlDataOnly* = 2; xlOrigin* = 3; xlButton* = 15; xlBlanks* = 4; xlFirstRow* = 256; (* XlRangeAutoFormat *) xlRangeAutoFormat3DEffects1* = 13; xlRangeAutoFormat3DEffects2* = 14; xlRangeAutoFormatAccounting1* = 4; xlRangeAutoFormatAccounting2* = 5; xlRangeAutoFormatAccounting3* = 6; xlRangeAutoFormatAccounting4* = 17; xlRangeAutoFormatClassic1* = 1; xlRangeAutoFormatClassic2* = 2; xlRangeAutoFormatClassic3* = 3; xlRangeAutoFormatColor1* = 7; xlRangeAutoFormatColor2* = 8; xlRangeAutoFormatColor3* = 9; xlRangeAutoFormatList1* = 10; xlRangeAutoFormatList2* = 11; xlRangeAutoFormatList3* = 12; xlRangeAutoFormatLocalFormat1* = 15; xlRangeAutoFormatLocalFormat2* = 16; xlRangeAutoFormatLocalFormat3* = 19; xlRangeAutoFormatLocalFormat4* = 20; xlRangeAutoFormatReport1* = 21; xlRangeAutoFormatReport2* = 22; xlRangeAutoFormatReport3* = 23; xlRangeAutoFormatReport4* = 24; xlRangeAutoFormatReport5* = 25; xlRangeAutoFormatReport6* = 26; xlRangeAutoFormatReport7* = 27; xlRangeAutoFormatReport8* = 28; xlRangeAutoFormatReport9* = 29; xlRangeAutoFormatReport10* = 30; xlRangeAutoFormatClassicPivotTable* = 31; xlRangeAutoFormatTable1* = 32; xlRangeAutoFormatTable2* = 33; xlRangeAutoFormatTable3* = 34; xlRangeAutoFormatTable4* = 35; xlRangeAutoFormatTable5* = 36; xlRangeAutoFormatTable6* = 37; xlRangeAutoFormatTable7* = 38; xlRangeAutoFormatTable8* = 39; xlRangeAutoFormatTable9* = 40; xlRangeAutoFormatTable10* = 41; xlRangeAutoFormatPTNone* = 42; xlRangeAutoFormatNone* = -4142; xlRangeAutoFormatSimple* = -4154; (* XlReferenceType *) xlAbsolute* = 1; xlAbsRowRelColumn* = 2; xlRelative* = 4; xlRelRowAbsColumn* = 3; (* XlLayoutFormType *) xlTabular* = 0; xlOutline* = 1; (* XlRoutingSlipDelivery *) xlAllAtOnce* = 2; xlOneAfterAnother* = 1; (* XlRoutingSlipStatus *) xlNotYetRouted* = 0; xlRoutingComplete* = 2; xlRoutingInProgress* = 1; (* XlRunAutoMacro *) xlAutoActivate* = 3; xlAutoClose* = 2; xlAutoDeactivate* = 4; xlAutoOpen* = 1; (* XlSaveAction *) xlDoNotSaveChanges* = 2; xlSaveChanges* = 1; (* XlSaveAsAccessMode *) xlExclusive* = 3; xlNoChange* = 1; xlShared* = 2; (* XlSaveConflictResolution *) xlLocalSessionChanges* = 2; xlOtherSessionChanges* = 3; xlUserResolution* = 1; (* XlSearchDirection *) xlNext* = 1; xlPrevious* = 2; (* XlSearchOrder *) xlByColumns* = 2; xlByRows* = 1; (* XlSheetVisibility *) xlSheetVisible* = -1; xlSheetHidden* = 0; xlSheetVeryHidden* = 2; (* XlSortMethod *) xlPinYin* = 1; xlStroke* = 2; (* XlSortMethodOld *) xlCodePage* = 2; xlSyllabary* = 1; (* XlSortOrder *) xlAscending* = 1; xlDescending* = 2; (* XlSortOrientation *) xlSortRows* = 2; xlSortColumns* = 1; (* XlSortType *) xlSortLabels* = 2; xlSortValues* = 1; (* XlSpecialCellsValue *) xlErrors* = 16; xlLogical* = 4; xlNumbers* = 1; xlTextValues* = 2; (* XlSubscribeToFormat *) xlSubscribeToPicture* = -4147; xlSubscribeToText* = -4158; (* XlSummaryRow *) xlSummaryAbove* = 0; xlSummaryBelow* = 1; (* XlSummaryColumn *) xlSummaryOnLeft* = -4131; xlSummaryOnRight* = -4152; (* XlSummaryReportType *) xlSummaryPivotTable* = -4148; xlStandardSummary* = 1; (* XlTabPosition *) xlTabPositionFirst* = 0; xlTabPositionLast* = 1; (* XlTextParsingType *) xlDelimited* = 1; xlFixedWidth* = 2; (* XlTextQualifier *) xlTextQualifierDoubleQuote* = 1; xlTextQualifierNone* = -4142; xlTextQualifierSingleQuote* = 2; (* XlWBATemplate *) xlWBATChart* = -4109; xlWBATExcel4IntlMacroSheet* = 4; xlWBATExcel4MacroSheet* = 3; xlWBATWorksheet* = -4167; (* XlWindowView *) xlNormalView* = 1; xlPageBreakPreview* = 2; (* XlXLMMacroType *) xlCommand* = 2; xlFunction* = 1; xlNotXLM* = 3; (* XlYesNoGuess *) xlGuess* = 0; xlNo* = 2; xlYes* = 1; (* XlBordersIndex *) xlInsideHorizontal* = 12; xlInsideVertical* = 11; xlDiagonalDown* = 5; xlDiagonalUp* = 6; xlEdgeBottom* = 9; xlEdgeLeft* = 7; xlEdgeRight* = 10; xlEdgeTop* = 8; (* XlToolbarProtection *) xlNoButtonChanges* = 1; xlNoChanges* = 4; xlNoDockingChanges* = 3; xlToolbarProtectionNone* = -4143; xlNoShapeChanges* = 2; (* XlBuiltInDialog *) xlDialogOpen* = 1; xlDialogOpenLinks* = 2; xlDialogSaveAs* = 5; xlDialogFileDelete* = 6; xlDialogPageSetup* = 7; xlDialogPrint* = 8; xlDialogPrinterSetup* = 9; xlDialogArrangeAll* = 12; xlDialogWindowSize* = 13; xlDialogWindowMove* = 14; xlDialogRun* = 17; xlDialogSetPrintTitles* = 23; xlDialogFont* = 26; xlDialogDisplay* = 27; xlDialogProtectDocument* = 28; xlDialogCalculation* = 32; xlDialogExtract* = 35; xlDialogDataDelete* = 36; xlDialogSort* = 39; xlDialogDataSeries* = 40; xlDialogTable* = 41; xlDialogFormatNumber* = 42; xlDialogAlignment* = 43; xlDialogStyle* = 44; xlDialogBorder* = 45; xlDialogCellProtection* = 46; xlDialogColumnWidth* = 47; xlDialogClear* = 52; xlDialogPasteSpecial* = 53; xlDialogEditDelete* = 54; xlDialogInsert* = 55; xlDialogPasteNames* = 58; xlDialogDefineName* = 61; xlDialogCreateNames* = 62; xlDialogFormulaGoto* = 63; xlDialogFormulaFind* = 64; xlDialogGalleryArea* = 67; xlDialogGalleryBar* = 68; xlDialogGalleryColumn* = 69; xlDialogGalleryLine* = 70; xlDialogGalleryPie* = 71; xlDialogGalleryScatter* = 72; xlDialogCombination* = 73; xlDialogGridlines* = 76; xlDialogAxes* = 78; xlDialogAttachText* = 80; xlDialogPatterns* = 84; xlDialogMainChart* = 85; xlDialogOverlay* = 86; xlDialogScale* = 87; xlDialogFormatLegend* = 88; xlDialogFormatText* = 89; xlDialogParse* = 91; xlDialogUnhide* = 94; xlDialogWorkspace* = 95; xlDialogActivate* = 103; xlDialogCopyPicture* = 108; xlDialogDeleteName* = 110; xlDialogDeleteFormat* = 111; xlDialogNew* = 119; xlDialogRowHeight* = 127; xlDialogFormatMove* = 128; xlDialogFormatSize* = 129; xlDialogFormulaReplace* = 130; xlDialogSelectSpecial* = 132; xlDialogApplyNames* = 133; xlDialogReplaceFont* = 134; xlDialogSplit* = 137; xlDialogOutline* = 142; xlDialogSaveWorkbook* = 145; xlDialogCopyChart* = 147; xlDialogFormatFont* = 150; xlDialogNote* = 154; xlDialogSetUpdateStatus* = 159; xlDialogColorPalette* = 161; xlDialogChangeLink* = 166; xlDialogAppMove* = 170; xlDialogAppSize* = 171; xlDialogMainChartType* = 185; xlDialogOverlayChartType* = 186; xlDialogOpenMail* = 188; xlDialogSendMail* = 189; xlDialogStandardFont* = 190; xlDialogConsolidate* = 191; xlDialogSortSpecial* = 192; xlDialogGallery3dArea* = 193; xlDialogGallery3dColumn* = 194; xlDialogGallery3dLine* = 195; xlDialogGallery3dPie* = 196; xlDialogView3d* = 197; xlDialogGoalSeek* = 198; xlDialogWorkgroup* = 199; xlDialogFillGroup* = 200; xlDialogUpdateLink* = 201; xlDialogPromote* = 202; xlDialogDemote* = 203; xlDialogShowDetail* = 204; xlDialogObjectProperties* = 207; xlDialogSaveNewObject* = 208; xlDialogApplyStyle* = 212; xlDialogAssignToObject* = 213; xlDialogObjectProtection* = 214; xlDialogCreatePublisher* = 217; xlDialogSubscribeTo* = 218; xlDialogShowToolbar* = 220; xlDialogPrintPreview* = 222; xlDialogEditColor* = 223; xlDialogFormatMain* = 225; xlDialogFormatOverlay* = 226; xlDialogEditSeries* = 228; xlDialogDefineStyle* = 229; xlDialogGalleryRadar* = 249; xlDialogEditionOptions* = 251; xlDialogZoom* = 256; xlDialogInsertObject* = 259; xlDialogSize* = 261; xlDialogMove* = 262; xlDialogFormatAuto* = 269; xlDialogGallery3dBar* = 272; xlDialogGallery3dSurface* = 273; xlDialogCustomizeToolbar* = 276; xlDialogWorkbookAdd* = 281; xlDialogWorkbookMove* = 282; xlDialogWorkbookCopy* = 283; xlDialogWorkbookOptions* = 284; xlDialogSaveWorkspace* = 285; xlDialogChartWizard* = 288; xlDialogAssignToTool* = 293; xlDialogPlacement* = 300; xlDialogFillWorkgroup* = 301; xlDialogWorkbookNew* = 302; xlDialogScenarioCells* = 305; xlDialogScenarioAdd* = 307; xlDialogScenarioEdit* = 308; xlDialogScenarioSummary* = 311; xlDialogPivotTableWizard* = 312; xlDialogPivotFieldProperties* = 313; xlDialogOptionsCalculation* = 318; xlDialogOptionsEdit* = 319; xlDialogOptionsView* = 320; xlDialogAddinManager* = 321; xlDialogMenuEditor* = 322; xlDialogAttachToolbars* = 323; xlDialogOptionsChart* = 325; xlDialogVbaInsertFile* = 328; xlDialogVbaProcedureDefinition* = 330; xlDialogRoutingSlip* = 336; xlDialogMailLogon* = 339; xlDialogInsertPicture* = 342; xlDialogGalleryDoughnut* = 344; xlDialogChartTrend* = 350; xlDialogWorkbookInsert* = 354; xlDialogOptionsTransition* = 355; xlDialogOptionsGeneral* = 356; xlDialogFilterAdvanced* = 370; xlDialogMailNextLetter* = 378; xlDialogDataLabel* = 379; xlDialogInsertTitle* = 380; xlDialogFontProperties* = 381; xlDialogMacroOptions* = 382; xlDialogWorkbookUnhide* = 384; xlDialogWorkbookName* = 386; xlDialogGalleryCustom* = 388; xlDialogAddChartAutoformat* = 390; xlDialogChartAddData* = 392; xlDialogTabOrder* = 394; xlDialogSubtotalCreate* = 398; xlDialogWorkbookTabSplit* = 415; xlDialogWorkbookProtect* = 417; xlDialogScrollbarProperties* = 420; xlDialogPivotShowPages* = 421; xlDialogTextToColumns* = 422; xlDialogFormatCharttype* = 423; xlDialogPivotFieldGroup* = 433; xlDialogPivotFieldUngroup* = 434; xlDialogCheckboxProperties* = 435; xlDialogLabelProperties* = 436; xlDialogListboxProperties* = 437; xlDialogEditboxProperties* = 438; xlDialogOpenText* = 441; xlDialogPushbuttonProperties* = 445; xlDialogFilter* = 447; xlDialogFunctionWizard* = 450; xlDialogSaveCopyAs* = 456; xlDialogOptionsListsAdd* = 458; xlDialogSeriesAxes* = 460; xlDialogSeriesX* = 461; xlDialogSeriesY* = 462; xlDialogErrorbarX* = 463; xlDialogErrorbarY* = 464; xlDialogFormatChart* = 465; xlDialogSeriesOrder* = 466; xlDialogMailEditMailer* = 470; xlDialogStandardWidth* = 472; xlDialogScenarioMerge* = 473; xlDialogProperties* = 474; xlDialogSummaryInfo* = 474; xlDialogFindFile* = 475; xlDialogActiveCellFont* = 476; xlDialogVbaMakeAddin* = 478; xlDialogFileSharing* = 481; xlDialogAutoCorrect* = 485; xlDialogCustomViews* = 493; xlDialogInsertNameLabel* = 496; xlDialogSeriesShape* = 504; xlDialogChartOptionsDataLabels* = 505; xlDialogChartOptionsDataTable* = 506; xlDialogSetBackgroundPicture* = 509; xlDialogDataValidation* = 525; xlDialogChartType* = 526; xlDialogChartLocation* = 527; _xlDialogPhonetic* = 538; xlDialogChartSourceData* = 540; _xlDialogChartSourceData* = 541; xlDialogSeriesOptions* = 557; xlDialogPivotTableOptions* = 567; xlDialogPivotSolveOrder* = 568; xlDialogPivotCalculatedField* = 570; xlDialogPivotCalculatedItem* = 572; xlDialogConditionalFormatting* = 583; xlDialogInsertHyperlink* = 596; xlDialogProtectSharing* = 620; xlDialogOptionsME* = 647; xlDialogPublishAsWebPage* = 653; xlDialogPhonetic* = 656; xlDialogNewWebQuery* = 667; xlDialogImportTextFile* = 666; xlDialogExternalDataProperties* = 530; xlDialogWebOptionsGeneral* = 683; xlDialogWebOptionsFiles* = 684; xlDialogWebOptionsPictures* = 685; xlDialogWebOptionsEncoding* = 686; xlDialogWebOptionsFonts* = 687; xlDialogPivotClientServerSet* = 689; (* XlParameterType *) xlPrompt* = 0; xlConstant* = 1; xlRange* = 2; (* XlParameterDataType *) xlParamTypeUnknown* = 0; xlParamTypeChar* = 1; xlParamTypeNumeric* = 2; xlParamTypeDecimal* = 3; xlParamTypeInteger* = 4; xlParamTypeSmallInt* = 5; xlParamTypeFloat* = 6; xlParamTypeReal* = 7; xlParamTypeDouble* = 8; xlParamTypeVarChar* = 12; xlParamTypeDate* = 9; xlParamTypeTime* = 10; xlParamTypeTimestamp* = 11; xlParamTypeLongVarChar* = -1; xlParamTypeBinary* = -2; xlParamTypeVarBinary* = -3; xlParamTypeLongVarBinary* = -4; xlParamTypeBigInt* = -5; xlParamTypeTinyInt* = -6; xlParamTypeBit* = -7; xlParamTypeWChar* = -8; (* XlFormControl *) xlButtonControl* = 0; xlCheckBox* = 1; xlDropDown* = 2; xlEditBox* = 3; xlGroupBox* = 4; xlLabel* = 5; xlListBox* = 6; xlOptionButton* = 7; xlScrollBar* = 8; xlSpinner* = 9; (* XlSourceType *) xlSourceSheet* = 1; xlSourcePrintArea* = 2; xlSourceAutoFilter* = 3; xlSourceRange* = 4; xlSourceChart* = 5; xlSourcePivotTable* = 6; xlSourceQuery* = 7; (* XlHtmlType *) xlHtmlStatic* = 0; xlHtmlCalc* = 1; xlHtmlList* = 2; xlHtmlChart* = 3; (* xlPivotFormatType *) xlReport1* = 0; xlReport2* = 1; xlReport3* = 2; xlReport4* = 3; xlReport5* = 4; xlReport6* = 5; xlReport7* = 6; xlReport8* = 7; xlReport9* = 8; xlReport10* = 9; xlTable1* = 10; xlTable2* = 11; xlTable3* = 12; xlTable4* = 13; xlTable5* = 14; xlTable6* = 15; xlTable7* = 16; xlTable8* = 17; xlTable9* = 18; xlTable10* = 19; xlPTClassic* = 20; xlPTNone* = 21; (* XlCmdType *) xlCmdCube* = 1; xlCmdSql* = 2; xlCmdTable* = 3; xlCmdDefault* = 4; (* xlColumnDataType *) xlGeneralFormat* = 1; xlTextFormat* = 2; xlMDYFormat* = 3; xlDMYFormat* = 4; xlYMDFormat* = 5; xlMYDFormat* = 6; xlDYMFormat* = 7; xlYDMFormat* = 8; xlSkipColumn* = 9; xlEMDFormat* = 10; (* xlQueryType *) xlODBCQuery* = 1; xlDAORecordSet* = 2; xlWebQuery* = 4; xlOLEDBQuery* = 5; xlTextImport* = 6; xlADORecordset* = 7; (* xlWebSelectionType *) xlEntirePage* = 1; xlAllTables* = 2; xlSpecifiedTables* = 3; (* XlCubeFieldType *) xlHierarchy* = 1; xlMeasure* = 2; (* xlWebFormatting *) xlWebFormattingAll* = 1; xlWebFormattingRTF* = 2; xlWebFormattingNone* = 3; (* xlDisplayDrawingObjects *) xlDisplayShapes* = -4104; xlHide* = 3; xlPlaceholders* = 2; (* xLSubtototalLocationType *) xlAtTop* = 1; xlAtBottom* = 2; TYPE Adjustments* = POINTER TO RECORD (CtlT.Object) END; CalloutFormat* = POINTER TO RECORD (CtlT.Object) END; ColorFormat* = POINTER TO RECORD (CtlT.Object) END; LineFormat* = POINTER TO RECORD (CtlT.Object) END; ShapeNode* = POINTER TO RECORD (CtlT.Object) END; ShapeNodes* = POINTER TO RECORD (CtlT.Object) END; PictureFormat* = POINTER TO RECORD (CtlT.Object) END; ShadowFormat* = POINTER TO RECORD (CtlT.Object) END; TextEffectFormat* = POINTER TO RECORD (CtlT.Object) END; ThreeDFormat* = POINTER TO RECORD (CtlT.Object) END; FillFormat* = POINTER TO RECORD (CtlT.Object) END; Constants* = INTEGER; XlCreator* = INTEGER; XlChartGallery* = INTEGER; XlColorIndex* = INTEGER; XlEndStyleCap* = INTEGER; XlRowCol* = INTEGER; XlScaleType* = INTEGER; XlDataSeriesType* = INTEGER; XlAxisCrosses* = INTEGER; XlAxisGroup* = INTEGER; XlBackground* = INTEGER; XlWindowState* = INTEGER; XlAxisType* = INTEGER; XlArrowHeadLength* = INTEGER; XlVAlign* = INTEGER; XlTickMark* = INTEGER; XlErrorBarDirection* = INTEGER; XlErrorBarInclude* = INTEGER; XlDisplayBlanksAs* = INTEGER; XlArrowHeadStyle* = INTEGER; XlArrowHeadWidth* = INTEGER; XlHAlign* = INTEGER; XlTickLabelPosition* = INTEGER; XlLegendPosition* = INTEGER; XlChartPictureType* = INTEGER; XlChartPicturePlacement* = INTEGER; XlOrientation* = INTEGER; XlTickLabelOrientation* = INTEGER; XlBorderWeight* = INTEGER; XlDataSeriesDate* = INTEGER; XlUnderlineStyle* = INTEGER; XlErrorBarType* = INTEGER; XlTrendlineType* = INTEGER; XlLineStyle* = INTEGER; XlDataLabelsType* = INTEGER; XlMarkerStyle* = INTEGER; XlPictureConvertorType* = INTEGER; XlPattern* = INTEGER; XlChartSplitType* = INTEGER; XlDisplayUnit* = INTEGER; XlDataLabelPosition* = INTEGER; XlTimeUnit* = INTEGER; XlCategoryType* = INTEGER; XlBarShape* = INTEGER; XlChartType* = INTEGER; XlChartItem* = INTEGER; XlSizeRepresents* = INTEGER; XlInsertShiftDirection* = INTEGER; XlDeleteShiftDirection* = INTEGER; XlDirection* = INTEGER; XlConsolidationFunction* = INTEGER; XlSheetType* = INTEGER; XlLocationInTable* = INTEGER; XlFindLookIn* = INTEGER; XlWindowType* = INTEGER; XlPivotFieldDataType* = INTEGER; XlCopyPictureFormat* = INTEGER; XlPivotTableSourceType* = INTEGER; XlReferenceStyle* = INTEGER; XlMSApplication* = INTEGER; XlMouseButton* = INTEGER; XlCutCopyMode* = INTEGER; XlFillWith* = INTEGER; XlFilterAction* = INTEGER; XlOrder* = INTEGER; XlLinkType* = INTEGER; XlApplyNamesOrder* = INTEGER; XlEnableCancelKey* = INTEGER; XlPageBreak* = INTEGER; XlOLEType* = INTEGER; XlPageOrientation* = INTEGER; XlLinkInfo* = INTEGER; XlCommandUnderlines* = INTEGER; XlOLEVerb* = INTEGER; XlCalculation* = INTEGER; XlFileAccess* = INTEGER; XlEditionType* = INTEGER; XlObjectSize* = INTEGER; XlLookAt* = INTEGER; XlMailSystem* = INTEGER; XlLinkInfoType* = INTEGER; XlCVError* = INTEGER; XlEditionFormat* = INTEGER; XlLink* = INTEGER; XlCellType* = INTEGER; XlArrangeStyle* = INTEGER; XlMousePointer* = INTEGER; XlEditionOptionsOption* = INTEGER; XlAutoFillType* = INTEGER; XlAutoFilterOperator* = INTEGER; XlClipboardFormat* = INTEGER; XlFileFormat* = INTEGER; XlApplicationInternational* = INTEGER; XlPageBreakExtent* = INTEGER; XlCellInsertionMode* = INTEGER; XlFormulaLabel* = INTEGER; XlHighlightChangesTime* = INTEGER; XlCommentDisplayMode* = INTEGER; XlFormatConditionType* = INTEGER; XlFormatConditionOperator* = INTEGER; XlEnableSelection* = INTEGER; XlDVType* = INTEGER; XlIMEMode* = INTEGER; XlDVAlertStyle* = INTEGER; XlChartLocation* = INTEGER; XlPaperSize* = INTEGER; XlPasteSpecialOperation* = INTEGER; XlPasteType* = INTEGER; XlPhoneticCharacterType* = INTEGER; XlPhoneticAlignment* = INTEGER; XlPictureAppearance* = INTEGER; XlPivotFieldOrientation* = INTEGER; XlPivotFieldCalculation* = INTEGER; XlPlacement* = INTEGER; XlPlatform* = INTEGER; XlPrintLocation* = INTEGER; XlPriority* = INTEGER; XlPTSelectionMode* = INTEGER; XlRangeAutoFormat* = INTEGER; XlReferenceType* = INTEGER; XlLayoutFormType* = INTEGER; XlRoutingSlipDelivery* = INTEGER; XlRoutingSlipStatus* = INTEGER; XlRunAutoMacro* = INTEGER; XlSaveAction* = INTEGER; XlSaveAsAccessMode* = INTEGER; XlSaveConflictResolution* = INTEGER; XlSearchDirection* = INTEGER; XlSearchOrder* = INTEGER; XlSheetVisibility* = INTEGER; XlSortMethod* = INTEGER; XlSortMethodOld* = INTEGER; XlSortOrder* = INTEGER; XlSortOrientation* = INTEGER; XlSortType* = INTEGER; XlSpecialCellsValue* = INTEGER; XlSubscribeToFormat* = INTEGER; XlSummaryRow* = INTEGER; XlSummaryColumn* = INTEGER; XlSummaryReportType* = INTEGER; XlTabPosition* = INTEGER; XlTextParsingType* = INTEGER; XlTextQualifier* = INTEGER; XlWBATemplate* = INTEGER; XlWindowView* = INTEGER; XlXLMMacroType* = INTEGER; XlYesNoGuess* = INTEGER; XlBordersIndex* = INTEGER; XlToolbarProtection* = INTEGER; XlBuiltInDialog* = INTEGER; XlParameterType* = INTEGER; XlParameterDataType* = INTEGER; XlFormControl* = INTEGER; XlSourceType* = INTEGER; XlHtmlType* = INTEGER; xlPivotFormatType* = INTEGER; XlCmdType* = INTEGER; xlColumnDataType* = INTEGER; xlQueryType* = INTEGER; xlWebSelectionType* = INTEGER; XlCubeFieldType* = INTEGER; xlWebFormatting* = INTEGER; xlDisplayDrawingObjects* = INTEGER; xLSubtototalLocationType* = INTEGER; _Application* = POINTER TO RECORD (CtlT.Object) END; _Chart* = POINTER TO RECORD (CtlT.Object) END; Sheets* = POINTER TO RECORD (CtlT.Object) END; _Worksheet* = POINTER TO RECORD (CtlT.Object) END; _Global* = POINTER TO RECORD (CtlT.Object) END; _Workbook* = POINTER TO RECORD (CtlT.Object) END; Workbooks* = POINTER TO RECORD (CtlT.Object) END; PublishObject* = POINTER TO RECORD (CtlT.Object) END; DefaultWebOptions* = POINTER TO RECORD (CtlT.Object) END; WebOptions* = POINTER TO RECORD (CtlT.Object) END; TreeviewControl* = POINTER TO RECORD (CtlT.Object) END; CubeField* = POINTER TO RECORD (CtlT.Object) END; CubeFields* = POINTER TO RECORD (CtlT.Object) END; Font* = POINTER TO RECORD (CtlT.Object) END; Window* = POINTER TO RECORD (CtlT.Object) END; Windows* = POINTER TO RECORD (CtlT.Object) END; AppEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WorksheetFunction* = POINTER TO RECORD (CtlT.Object) END; Range* = POINTER TO RECORD (CtlT.Object) END; ChartEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; VPageBreak* = POINTER TO RECORD (CtlT.Object) END; HPageBreak* = POINTER TO RECORD (CtlT.Object) END; HPageBreaks* = POINTER TO RECORD (CtlT.Object) END; VPageBreaks* = POINTER TO RECORD (CtlT.Object) END; RecentFile* = POINTER TO RECORD (CtlT.Object) END; RecentFiles* = POINTER TO RECORD (CtlT.Object) END; DocEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Style* = POINTER TO RECORD (CtlT.Object) END; Styles* = POINTER TO RECORD (CtlT.Object) END; Borders* = POINTER TO RECORD (CtlT.Object) END; AddIn* = POINTER TO RECORD (CtlT.Object) END; AddIns* = POINTER TO RECORD (CtlT.Object) END; Toolbar* = POINTER TO RECORD (CtlT.Object) END; Toolbars* = POINTER TO RECORD (CtlT.Object) END; ToolbarButton* = POINTER TO RECORD (CtlT.Object) END; ToolbarButtons* = POINTER TO RECORD (CtlT.Object) END; Areas* = POINTER TO RECORD (CtlT.Object) END; WorkbookEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; MenuBars* = POINTER TO RECORD (CtlT.Object) END; MenuBar* = POINTER TO RECORD (CtlT.Object) END; Menus* = POINTER TO RECORD (CtlT.Object) END; Menu* = POINTER TO RECORD (CtlT.Object) END; MenuItems* = POINTER TO RECORD (CtlT.Object) END; MenuItem* = POINTER TO RECORD (CtlT.Object) END; Charts* = POINTER TO RECORD (CtlT.Object) END; DrawingObjects* = POINTER TO RECORD (CtlT.Object) END; PivotCache* = POINTER TO RECORD (CtlT.Object) END; PivotCaches* = POINTER TO RECORD (CtlT.Object) END; PivotFormula* = POINTER TO RECORD (CtlT.Object) END; PivotFormulas* = POINTER TO RECORD (CtlT.Object) END; PivotTable* = POINTER TO RECORD (CtlT.Object) END; PivotTables* = POINTER TO RECORD (CtlT.Object) END; PivotField* = POINTER TO RECORD (CtlT.Object) END; PivotFields* = POINTER TO RECORD (CtlT.Object) END; CalculatedFields* = POINTER TO RECORD (CtlT.Object) END; PivotItem* = POINTER TO RECORD (CtlT.Object) END; PivotItems* = POINTER TO RECORD (CtlT.Object) END; CalculatedItems* = POINTER TO RECORD (CtlT.Object) END; Characters* = POINTER TO RECORD (CtlT.Object) END; Dialogs* = POINTER TO RECORD (CtlT.Object) END; Dialog* = POINTER TO RECORD (CtlT.Object) END; SoundNote* = POINTER TO RECORD (CtlT.Object) END; Button* = POINTER TO RECORD (CtlT.Object) END; Buttons* = POINTER TO RECORD (CtlT.Object) END; CheckBox* = POINTER TO RECORD (CtlT.Object) END; CheckBoxes* = POINTER TO RECORD (CtlT.Object) END; OptionButton* = POINTER TO RECORD (CtlT.Object) END; OptionButtons* = POINTER TO RECORD (CtlT.Object) END; EditBox* = POINTER TO RECORD (CtlT.Object) END; EditBoxes* = POINTER TO RECORD (CtlT.Object) END; ScrollBar* = POINTER TO RECORD (CtlT.Object) END; ScrollBars* = POINTER TO RECORD (CtlT.Object) END; ListBox* = POINTER TO RECORD (CtlT.Object) END; ListBoxes* = POINTER TO RECORD (CtlT.Object) END; GroupBox* = POINTER TO RECORD (CtlT.Object) END; GroupBoxes* = POINTER TO RECORD (CtlT.Object) END; DropDown* = POINTER TO RECORD (CtlT.Object) END; DropDowns* = POINTER TO RECORD (CtlT.Object) END; Spinner* = POINTER TO RECORD (CtlT.Object) END; Spinners* = POINTER TO RECORD (CtlT.Object) END; DialogFrame* = POINTER TO RECORD (CtlT.Object) END; Label* = POINTER TO RECORD (CtlT.Object) END; Labels* = POINTER TO RECORD (CtlT.Object) END; Panes* = POINTER TO RECORD (CtlT.Object) END; Pane* = POINTER TO RECORD (CtlT.Object) END; Scenarios* = POINTER TO RECORD (CtlT.Object) END; Scenario* = POINTER TO RECORD (CtlT.Object) END; GroupObject* = POINTER TO RECORD (CtlT.Object) END; GroupObjects* = POINTER TO RECORD (CtlT.Object) END; Line* = POINTER TO RECORD (CtlT.Object) END; Lines* = POINTER TO RECORD (CtlT.Object) END; Rectangle* = POINTER TO RECORD (CtlT.Object) END; Rectangles* = POINTER TO RECORD (CtlT.Object) END; Oval* = POINTER TO RECORD (CtlT.Object) END; Ovals* = POINTER TO RECORD (CtlT.Object) END; Arc* = POINTER TO RECORD (CtlT.Object) END; Arcs* = POINTER TO RECORD (CtlT.Object) END; OLEObjectEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _OLEObject* = POINTER TO RECORD (CtlT.Object) END; OLEObjects* = POINTER TO RECORD (CtlT.Object) END; TextBox* = POINTER TO RECORD (CtlT.Object) END; TextBoxes* = POINTER TO RECORD (CtlT.Object) END; Picture* = POINTER TO RECORD (CtlT.Object) END; Pictures* = POINTER TO RECORD (CtlT.Object) END; Drawing* = POINTER TO RECORD (CtlT.Object) END; Drawings* = POINTER TO RECORD (CtlT.Object) END; RoutingSlip* = POINTER TO RECORD (CtlT.Object) END; Outline* = POINTER TO RECORD (CtlT.Object) END; Module* = POINTER TO RECORD (CtlT.Object) END; Modules* = POINTER TO RECORD (CtlT.Object) END; DialogSheet* = POINTER TO RECORD (CtlT.Object) END; DialogSheets* = POINTER TO RECORD (CtlT.Object) END; Worksheets* = POINTER TO RECORD (CtlT.Object) END; PageSetup* = POINTER TO RECORD (CtlT.Object) END; Names* = POINTER TO RECORD (CtlT.Object) END; Name* = POINTER TO RECORD (CtlT.Object) END; ChartObject* = POINTER TO RECORD (CtlT.Object) END; ChartObjects* = POINTER TO RECORD (CtlT.Object) END; Mailer* = POINTER TO RECORD (CtlT.Object) END; CustomViews* = POINTER TO RECORD (CtlT.Object) END; CustomView* = POINTER TO RECORD (CtlT.Object) END; FormatConditions* = POINTER TO RECORD (CtlT.Object) END; FormatCondition* = POINTER TO RECORD (CtlT.Object) END; Comments* = POINTER TO RECORD (CtlT.Object) END; Comment* = POINTER TO RECORD (CtlT.Object) END; RefreshEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _QueryTable* = POINTER TO RECORD (CtlT.Object) END; QueryTables* = POINTER TO RECORD (CtlT.Object) END; Parameter* = POINTER TO RECORD (CtlT.Object) END; Parameters* = POINTER TO RECORD (CtlT.Object) END; ODBCError* = POINTER TO RECORD (CtlT.Object) END; ODBCErrors* = POINTER TO RECORD (CtlT.Object) END; Validation* = POINTER TO RECORD (CtlT.Object) END; Hyperlinks* = POINTER TO RECORD (CtlT.Object) END; Hyperlink* = POINTER TO RECORD (CtlT.Object) END; AutoFilter* = POINTER TO RECORD (CtlT.Object) END; Filters* = POINTER TO RECORD (CtlT.Object) END; Filter* = POINTER TO RECORD (CtlT.Object) END; AutoCorrect* = POINTER TO RECORD (CtlT.Object) END; Border* = POINTER TO RECORD (CtlT.Object) END; Interior* = POINTER TO RECORD (CtlT.Object) END; ChartFillFormat* = POINTER TO RECORD (CtlT.Object) END; ChartColorFormat* = POINTER TO RECORD (CtlT.Object) END; Axis* = POINTER TO RECORD (CtlT.Object) END; ChartTitle* = POINTER TO RECORD (CtlT.Object) END; AxisTitle* = POINTER TO RECORD (CtlT.Object) END; ChartGroup* = POINTER TO RECORD (CtlT.Object) END; ChartGroups* = POINTER TO RECORD (CtlT.Object) END; Axes* = POINTER TO RECORD (CtlT.Object) END; Points* = POINTER TO RECORD (CtlT.Object) END; Point* = POINTER TO RECORD (CtlT.Object) END; Series* = POINTER TO RECORD (CtlT.Object) END; SeriesCollection* = POINTER TO RECORD (CtlT.Object) END; DataLabel* = POINTER TO RECORD (CtlT.Object) END; DataLabels* = POINTER TO RECORD (CtlT.Object) END; LegendEntry* = POINTER TO RECORD (CtlT.Object) END; LegendEntries* = POINTER TO RECORD (CtlT.Object) END; LegendKey* = POINTER TO RECORD (CtlT.Object) END; Trendlines* = POINTER TO RECORD (CtlT.Object) END; Trendline* = POINTER TO RECORD (CtlT.Object) END; Corners* = POINTER TO RECORD (CtlT.Object) END; SeriesLines* = POINTER TO RECORD (CtlT.Object) END; HiLoLines* = POINTER TO RECORD (CtlT.Object) END; Gridlines* = POINTER TO RECORD (CtlT.Object) END; DropLines* = POINTER TO RECORD (CtlT.Object) END; LeaderLines* = POINTER TO RECORD (CtlT.Object) END; UpBars* = POINTER TO RECORD (CtlT.Object) END; DownBars* = POINTER TO RECORD (CtlT.Object) END; Floor* = POINTER TO RECORD (CtlT.Object) END; Walls* = POINTER TO RECORD (CtlT.Object) END; TickLabels* = POINTER TO RECORD (CtlT.Object) END; PlotArea* = POINTER TO RECORD (CtlT.Object) END; ChartArea* = POINTER TO RECORD (CtlT.Object) END; Legend* = POINTER TO RECORD (CtlT.Object) END; ErrorBars* = POINTER TO RECORD (CtlT.Object) END; DataTable* = POINTER TO RECORD (CtlT.Object) END; Phonetic* = POINTER TO RECORD (CtlT.Object) END; Shape* = POINTER TO RECORD (CtlT.Object) END; Shapes* = POINTER TO RECORD (CtlT.Object) END; ShapeRange* = POINTER TO RECORD (CtlT.Object) END; GroupShapes* = POINTER TO RECORD (CtlT.Object) END; TextFrame* = POINTER TO RECORD (CtlT.Object) END; ConnectorFormat* = POINTER TO RECORD (CtlT.Object) END; FreeformBuilder* = POINTER TO RECORD (CtlT.Object) END; ControlFormat* = POINTER TO RECORD (CtlT.Object) END; OLEFormat* = POINTER TO RECORD (CtlT.Object) END; LinkFormat* = POINTER TO RECORD (CtlT.Object) END; PublishObjects* = POINTER TO RECORD (CtlT.Object) END; OLEDBError* = POINTER TO RECORD (CtlT.Object) END; OLEDBErrors* = POINTER TO RECORD (CtlT.Object) END; Phonetics* = POINTER TO RECORD (CtlT.Object) END; PivotLayout* = POINTER TO RECORD (CtlT.Object) END; DisplayUnitLabel* = POINTER TO RECORD (CtlT.Object) END; QueryTable* = _QueryTable; Application* = _Application; Chart* = _Chart; Worksheet* = _Worksheet; Global* = _Global; Workbook* = _Workbook; OLEObject* = _OLEObject; PROCEDURE ThisAdjustments* (v: CtlT.Any): Adjustments; VAR new: Adjustments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0310-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAdjustments; PROCEDURE IsAdjustments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0310-0000-0000-C000-000000000046}") END IsAdjustments; PROCEDURE ThisCalloutFormat* (v: CtlT.Any): CalloutFormat; VAR new: CalloutFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0311-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCalloutFormat; PROCEDURE IsCalloutFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0311-0000-0000-C000-000000000046}") END IsCalloutFormat; PROCEDURE ThisColorFormat* (v: CtlT.Any): ColorFormat; VAR new: ColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0312-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisColorFormat; PROCEDURE IsColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0312-0000-0000-C000-000000000046}") END IsColorFormat; PROCEDURE ThisLineFormat* (v: CtlT.Any): LineFormat; VAR new: LineFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0317-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLineFormat; PROCEDURE IsLineFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0317-0000-0000-C000-000000000046}") END IsLineFormat; PROCEDURE ThisShapeNode* (v: CtlT.Any): ShapeNode; VAR new: ShapeNode; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0318-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNode; PROCEDURE IsShapeNode* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0318-0000-0000-C000-000000000046}") END IsShapeNode; PROCEDURE ThisShapeNodes* (v: CtlT.Any): ShapeNodes; VAR new: ShapeNodes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0319-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNodes; PROCEDURE IsShapeNodes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0319-0000-0000-C000-000000000046}") END IsShapeNodes; PROCEDURE ThisPictureFormat* (v: CtlT.Any): PictureFormat; VAR new: PictureFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPictureFormat; PROCEDURE IsPictureFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031A-0000-0000-C000-000000000046}") END IsPictureFormat; PROCEDURE ThisShadowFormat* (v: CtlT.Any): ShadowFormat; VAR new: ShadowFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShadowFormat; PROCEDURE IsShadowFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031B-0000-0000-C000-000000000046}") END IsShadowFormat; PROCEDURE ThisTextEffectFormat* (v: CtlT.Any): TextEffectFormat; VAR new: TextEffectFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextEffectFormat; PROCEDURE IsTextEffectFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031F-0000-0000-C000-000000000046}") END IsTextEffectFormat; PROCEDURE ThisThreeDFormat* (v: CtlT.Any): ThreeDFormat; VAR new: ThreeDFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0321-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisThreeDFormat; PROCEDURE IsThreeDFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0321-0000-0000-C000-000000000046}") END IsThreeDFormat; PROCEDURE ThisFillFormat* (v: CtlT.Any): FillFormat; VAR new: FillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0314-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFillFormat; PROCEDURE IsFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0314-0000-0000-C000-000000000046}") END IsFillFormat; PROCEDURE This_Application* (v: CtlT.Any): _Application; VAR new: _Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Application; PROCEDURE Is_Application* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D5-0000-0000-C000-000000000046}") END Is_Application; PROCEDURE This_Chart* (v: CtlT.Any): _Chart; VAR new: _Chart; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Chart; PROCEDURE Is_Chart* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D6-0000-0000-C000-000000000046}") END Is_Chart; PROCEDURE ThisSheets* (v: CtlT.Any): Sheets; VAR new: Sheets; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSheets; PROCEDURE IsSheets* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D7-0000-0000-C000-000000000046}") END IsSheets; PROCEDURE This_Worksheet* (v: CtlT.Any): _Worksheet; VAR new: _Worksheet; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Worksheet; PROCEDURE Is_Worksheet* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D8-0000-0000-C000-000000000046}") END Is_Worksheet; PROCEDURE This_Global* (v: CtlT.Any): _Global; VAR new: _Global; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Global; PROCEDURE Is_Global* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D9-0000-0000-C000-000000000046}") END Is_Global; PROCEDURE This_Workbook* (v: CtlT.Any): _Workbook; VAR new: _Workbook; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208DA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Workbook; PROCEDURE Is_Workbook* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208DA-0000-0000-C000-000000000046}") END Is_Workbook; PROCEDURE ThisWorkbooks* (v: CtlT.Any): Workbooks; VAR new: Workbooks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208DB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWorkbooks; PROCEDURE IsWorkbooks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208DB-0000-0000-C000-000000000046}") END IsWorkbooks; PROCEDURE ThisPublishObject* (v: CtlT.Any): PublishObject; VAR new: PublishObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024444-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPublishObject; PROCEDURE IsPublishObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024444-0000-0000-C000-000000000046}") END IsPublishObject; PROCEDURE ThisDefaultWebOptions* (v: CtlT.Any): DefaultWebOptions; VAR new: DefaultWebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024448-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDefaultWebOptions; PROCEDURE IsDefaultWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024448-0000-0000-C000-000000000046}") END IsDefaultWebOptions; PROCEDURE ThisWebOptions* (v: CtlT.Any): WebOptions; VAR new: WebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024449-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWebOptions; PROCEDURE IsWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024449-0000-0000-C000-000000000046}") END IsWebOptions; PROCEDURE ThisTreeviewControl* (v: CtlT.Any): TreeviewControl; VAR new: TreeviewControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002444B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTreeviewControl; PROCEDURE IsTreeviewControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002444B-0000-0000-C000-000000000046}") END IsTreeviewControl; PROCEDURE ThisCubeField* (v: CtlT.Any): CubeField; VAR new: CubeField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002444C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCubeField; PROCEDURE IsCubeField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002444C-0000-0000-C000-000000000046}") END IsCubeField; PROCEDURE ThisCubeFields* (v: CtlT.Any): CubeFields; VAR new: CubeFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002444D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCubeFields; PROCEDURE IsCubeFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002444D-0000-0000-C000-000000000046}") END IsCubeFields; PROCEDURE ThisFont* (v: CtlT.Any): Font; VAR new: Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002084D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFont; PROCEDURE IsFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002084D-0000-0000-C000-000000000046}") END IsFont; PROCEDURE ThisWindow* (v: CtlT.Any): Window; VAR new: Window; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020893-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWindow; PROCEDURE IsWindow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020893-0000-0000-C000-000000000046}") END IsWindow; PROCEDURE ThisWindows* (v: CtlT.Any): Windows; VAR new: Windows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020892-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWindows; PROCEDURE IsWindows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020892-0000-0000-C000-000000000046}") END IsWindows; PROCEDURE ThisWorksheetFunction* (v: CtlT.Any): WorksheetFunction; VAR new: WorksheetFunction; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020845-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWorksheetFunction; PROCEDURE IsWorksheetFunction* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020845-0000-0000-C000-000000000046}") END IsWorksheetFunction; PROCEDURE ThisRange* (v: CtlT.Any): Range; VAR new: Range; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020846-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRange; PROCEDURE IsRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020846-0000-0000-C000-000000000046}") END IsRange; PROCEDURE ThisVPageBreak* (v: CtlT.Any): VPageBreak; VAR new: VPageBreak; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024402-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVPageBreak; PROCEDURE IsVPageBreak* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024402-0000-0000-C000-000000000046}") END IsVPageBreak; PROCEDURE ThisHPageBreak* (v: CtlT.Any): HPageBreak; VAR new: HPageBreak; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024401-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHPageBreak; PROCEDURE IsHPageBreak* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024401-0000-0000-C000-000000000046}") END IsHPageBreak; PROCEDURE ThisHPageBreaks* (v: CtlT.Any): HPageBreaks; VAR new: HPageBreaks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024404-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHPageBreaks; PROCEDURE IsHPageBreaks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024404-0000-0000-C000-000000000046}") END IsHPageBreaks; PROCEDURE ThisVPageBreaks* (v: CtlT.Any): VPageBreaks; VAR new: VPageBreaks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024405-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVPageBreaks; PROCEDURE IsVPageBreaks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024405-0000-0000-C000-000000000046}") END IsVPageBreaks; PROCEDURE ThisRecentFile* (v: CtlT.Any): RecentFile; VAR new: RecentFile; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024407-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecentFile; PROCEDURE IsRecentFile* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024407-0000-0000-C000-000000000046}") END IsRecentFile; PROCEDURE ThisRecentFiles* (v: CtlT.Any): RecentFiles; VAR new: RecentFiles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024406-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecentFiles; PROCEDURE IsRecentFiles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024406-0000-0000-C000-000000000046}") END IsRecentFiles; PROCEDURE ThisStyle* (v: CtlT.Any): Style; VAR new: Style; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020852-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisStyle; PROCEDURE IsStyle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020852-0000-0000-C000-000000000046}") END IsStyle; PROCEDURE ThisStyles* (v: CtlT.Any): Styles; VAR new: Styles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020853-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisStyles; PROCEDURE IsStyles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020853-0000-0000-C000-000000000046}") END IsStyles; PROCEDURE ThisBorders* (v: CtlT.Any): Borders; VAR new: Borders; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020855-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBorders; PROCEDURE IsBorders* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020855-0000-0000-C000-000000000046}") END IsBorders; PROCEDURE ThisAddIn* (v: CtlT.Any): AddIn; VAR new: AddIn; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020857-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddIn; PROCEDURE IsAddIn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020857-0000-0000-C000-000000000046}") END IsAddIn; PROCEDURE ThisAddIns* (v: CtlT.Any): AddIns; VAR new: AddIns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020858-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddIns; PROCEDURE IsAddIns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020858-0000-0000-C000-000000000046}") END IsAddIns; PROCEDURE ThisToolbar* (v: CtlT.Any): Toolbar; VAR new: Toolbar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisToolbar; PROCEDURE IsToolbar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085C-0000-0000-C000-000000000046}") END IsToolbar; PROCEDURE ThisToolbars* (v: CtlT.Any): Toolbars; VAR new: Toolbars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisToolbars; PROCEDURE IsToolbars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085D-0000-0000-C000-000000000046}") END IsToolbars; PROCEDURE ThisToolbarButton* (v: CtlT.Any): ToolbarButton; VAR new: ToolbarButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisToolbarButton; PROCEDURE IsToolbarButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085E-0000-0000-C000-000000000046}") END IsToolbarButton; PROCEDURE ThisToolbarButtons* (v: CtlT.Any): ToolbarButtons; VAR new: ToolbarButtons; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisToolbarButtons; PROCEDURE IsToolbarButtons* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085F-0000-0000-C000-000000000046}") END IsToolbarButtons; PROCEDURE ThisAreas* (v: CtlT.Any): Areas; VAR new: Areas; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020860-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAreas; PROCEDURE IsAreas* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020860-0000-0000-C000-000000000046}") END IsAreas; PROCEDURE ThisMenuBars* (v: CtlT.Any): MenuBars; VAR new: MenuBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020863-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenuBars; PROCEDURE IsMenuBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020863-0000-0000-C000-000000000046}") END IsMenuBars; PROCEDURE ThisMenuBar* (v: CtlT.Any): MenuBar; VAR new: MenuBar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020864-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenuBar; PROCEDURE IsMenuBar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020864-0000-0000-C000-000000000046}") END IsMenuBar; PROCEDURE ThisMenus* (v: CtlT.Any): Menus; VAR new: Menus; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020865-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenus; PROCEDURE IsMenus* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020865-0000-0000-C000-000000000046}") END IsMenus; PROCEDURE ThisMenu* (v: CtlT.Any): Menu; VAR new: Menu; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020866-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenu; PROCEDURE IsMenu* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020866-0000-0000-C000-000000000046}") END IsMenu; PROCEDURE ThisMenuItems* (v: CtlT.Any): MenuItems; VAR new: MenuItems; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020867-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenuItems; PROCEDURE IsMenuItems* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020867-0000-0000-C000-000000000046}") END IsMenuItems; PROCEDURE ThisMenuItem* (v: CtlT.Any): MenuItem; VAR new: MenuItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020868-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMenuItem; PROCEDURE IsMenuItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020868-0000-0000-C000-000000000046}") END IsMenuItem; PROCEDURE ThisCharts* (v: CtlT.Any): Charts; VAR new: Charts; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002086D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCharts; PROCEDURE IsCharts* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002086D-0000-0000-C000-000000000046}") END IsCharts; PROCEDURE ThisDrawingObjects* (v: CtlT.Any): DrawingObjects; VAR new: DrawingObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002086F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDrawingObjects; PROCEDURE IsDrawingObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002086F-0000-0000-C000-000000000046}") END IsDrawingObjects; PROCEDURE ThisPivotCache* (v: CtlT.Any): PivotCache; VAR new: PivotCache; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotCache; PROCEDURE IsPivotCache* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441C-0000-0000-C000-000000000046}") END IsPivotCache; PROCEDURE ThisPivotCaches* (v: CtlT.Any): PivotCaches; VAR new: PivotCaches; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotCaches; PROCEDURE IsPivotCaches* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441D-0000-0000-C000-000000000046}") END IsPivotCaches; PROCEDURE ThisPivotFormula* (v: CtlT.Any): PivotFormula; VAR new: PivotFormula; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotFormula; PROCEDURE IsPivotFormula* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441E-0000-0000-C000-000000000046}") END IsPivotFormula; PROCEDURE ThisPivotFormulas* (v: CtlT.Any): PivotFormulas; VAR new: PivotFormulas; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotFormulas; PROCEDURE IsPivotFormulas* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441F-0000-0000-C000-000000000046}") END IsPivotFormulas; PROCEDURE ThisPivotTable* (v: CtlT.Any): PivotTable; VAR new: PivotTable; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020872-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotTable; PROCEDURE IsPivotTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020872-0000-0000-C000-000000000046}") END IsPivotTable; PROCEDURE ThisPivotTables* (v: CtlT.Any): PivotTables; VAR new: PivotTables; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020873-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotTables; PROCEDURE IsPivotTables* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020873-0000-0000-C000-000000000046}") END IsPivotTables; PROCEDURE ThisPivotField* (v: CtlT.Any): PivotField; VAR new: PivotField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020874-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotField; PROCEDURE IsPivotField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020874-0000-0000-C000-000000000046}") END IsPivotField; PROCEDURE ThisPivotFields* (v: CtlT.Any): PivotFields; VAR new: PivotFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020875-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotFields; PROCEDURE IsPivotFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020875-0000-0000-C000-000000000046}") END IsPivotFields; PROCEDURE ThisCalculatedFields* (v: CtlT.Any): CalculatedFields; VAR new: CalculatedFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024420-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCalculatedFields; PROCEDURE IsCalculatedFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024420-0000-0000-C000-000000000046}") END IsCalculatedFields; PROCEDURE ThisPivotItem* (v: CtlT.Any): PivotItem; VAR new: PivotItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020876-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotItem; PROCEDURE IsPivotItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020876-0000-0000-C000-000000000046}") END IsPivotItem; PROCEDURE ThisPivotItems* (v: CtlT.Any): PivotItems; VAR new: PivotItems; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020877-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotItems; PROCEDURE IsPivotItems* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020877-0000-0000-C000-000000000046}") END IsPivotItems; PROCEDURE ThisCalculatedItems* (v: CtlT.Any): CalculatedItems; VAR new: CalculatedItems; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024421-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCalculatedItems; PROCEDURE IsCalculatedItems* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024421-0000-0000-C000-000000000046}") END IsCalculatedItems; PROCEDURE ThisCharacters* (v: CtlT.Any): Characters; VAR new: Characters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020878-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCharacters; PROCEDURE IsCharacters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020878-0000-0000-C000-000000000046}") END IsCharacters; PROCEDURE ThisDialogs* (v: CtlT.Any): Dialogs; VAR new: Dialogs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020879-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialogs; PROCEDURE IsDialogs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020879-0000-0000-C000-000000000046}") END IsDialogs; PROCEDURE ThisDialog* (v: CtlT.Any): Dialog; VAR new: Dialog; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002087A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialog; PROCEDURE IsDialog* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002087A-0000-0000-C000-000000000046}") END IsDialog; PROCEDURE ThisSoundNote* (v: CtlT.Any): SoundNote; VAR new: SoundNote; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002087B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSoundNote; PROCEDURE IsSoundNote* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002087B-0000-0000-C000-000000000046}") END IsSoundNote; PROCEDURE ThisButton* (v: CtlT.Any): Button; VAR new: Button; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002087D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisButton; PROCEDURE IsButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002087D-0000-0000-C000-000000000046}") END IsButton; PROCEDURE ThisButtons* (v: CtlT.Any): Buttons; VAR new: Buttons; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002087E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisButtons; PROCEDURE IsButtons* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002087E-0000-0000-C000-000000000046}") END IsButtons; PROCEDURE ThisCheckBox* (v: CtlT.Any): CheckBox; VAR new: CheckBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002087F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCheckBox; PROCEDURE IsCheckBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002087F-0000-0000-C000-000000000046}") END IsCheckBox; PROCEDURE ThisCheckBoxes* (v: CtlT.Any): CheckBoxes; VAR new: CheckBoxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020880-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCheckBoxes; PROCEDURE IsCheckBoxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020880-0000-0000-C000-000000000046}") END IsCheckBoxes; PROCEDURE ThisOptionButton* (v: CtlT.Any): OptionButton; VAR new: OptionButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020881-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOptionButton; PROCEDURE IsOptionButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020881-0000-0000-C000-000000000046}") END IsOptionButton; PROCEDURE ThisOptionButtons* (v: CtlT.Any): OptionButtons; VAR new: OptionButtons; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020882-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOptionButtons; PROCEDURE IsOptionButtons* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020882-0000-0000-C000-000000000046}") END IsOptionButtons; PROCEDURE ThisEditBox* (v: CtlT.Any): EditBox; VAR new: EditBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020883-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEditBox; PROCEDURE IsEditBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020883-0000-0000-C000-000000000046}") END IsEditBox; PROCEDURE ThisEditBoxes* (v: CtlT.Any): EditBoxes; VAR new: EditBoxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020884-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEditBoxes; PROCEDURE IsEditBoxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020884-0000-0000-C000-000000000046}") END IsEditBoxes; PROCEDURE ThisScrollBar* (v: CtlT.Any): ScrollBar; VAR new: ScrollBar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020885-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScrollBar; PROCEDURE IsScrollBar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020885-0000-0000-C000-000000000046}") END IsScrollBar; PROCEDURE ThisScrollBars* (v: CtlT.Any): ScrollBars; VAR new: ScrollBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020886-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScrollBars; PROCEDURE IsScrollBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020886-0000-0000-C000-000000000046}") END IsScrollBars; PROCEDURE ThisListBox* (v: CtlT.Any): ListBox; VAR new: ListBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020887-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListBox; PROCEDURE IsListBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020887-0000-0000-C000-000000000046}") END IsListBox; PROCEDURE ThisListBoxes* (v: CtlT.Any): ListBoxes; VAR new: ListBoxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020888-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListBoxes; PROCEDURE IsListBoxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020888-0000-0000-C000-000000000046}") END IsListBoxes; PROCEDURE ThisGroupBox* (v: CtlT.Any): GroupBox; VAR new: GroupBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020889-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupBox; PROCEDURE IsGroupBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020889-0000-0000-C000-000000000046}") END IsGroupBox; PROCEDURE ThisGroupBoxes* (v: CtlT.Any): GroupBoxes; VAR new: GroupBoxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupBoxes; PROCEDURE IsGroupBoxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088A-0000-0000-C000-000000000046}") END IsGroupBoxes; PROCEDURE ThisDropDown* (v: CtlT.Any): DropDown; VAR new: DropDown; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropDown; PROCEDURE IsDropDown* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088B-0000-0000-C000-000000000046}") END IsDropDown; PROCEDURE ThisDropDowns* (v: CtlT.Any): DropDowns; VAR new: DropDowns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropDowns; PROCEDURE IsDropDowns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088C-0000-0000-C000-000000000046}") END IsDropDowns; PROCEDURE ThisSpinner* (v: CtlT.Any): Spinner; VAR new: Spinner; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSpinner; PROCEDURE IsSpinner* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088D-0000-0000-C000-000000000046}") END IsSpinner; PROCEDURE ThisSpinners* (v: CtlT.Any): Spinners; VAR new: Spinners; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSpinners; PROCEDURE IsSpinners* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088E-0000-0000-C000-000000000046}") END IsSpinners; PROCEDURE ThisDialogFrame* (v: CtlT.Any): DialogFrame; VAR new: DialogFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002088F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialogFrame; PROCEDURE IsDialogFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002088F-0000-0000-C000-000000000046}") END IsDialogFrame; PROCEDURE ThisLabel* (v: CtlT.Any): Label; VAR new: Label; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020890-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLabel; PROCEDURE IsLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020890-0000-0000-C000-000000000046}") END IsLabel; PROCEDURE ThisLabels* (v: CtlT.Any): Labels; VAR new: Labels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020891-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLabels; PROCEDURE IsLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020891-0000-0000-C000-000000000046}") END IsLabels; PROCEDURE ThisPanes* (v: CtlT.Any): Panes; VAR new: Panes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020894-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPanes; PROCEDURE IsPanes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020894-0000-0000-C000-000000000046}") END IsPanes; PROCEDURE ThisPane* (v: CtlT.Any): Pane; VAR new: Pane; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020895-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPane; PROCEDURE IsPane* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020895-0000-0000-C000-000000000046}") END IsPane; PROCEDURE ThisScenarios* (v: CtlT.Any): Scenarios; VAR new: Scenarios; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020896-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScenarios; PROCEDURE IsScenarios* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020896-0000-0000-C000-000000000046}") END IsScenarios; PROCEDURE ThisScenario* (v: CtlT.Any): Scenario; VAR new: Scenario; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020897-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScenario; PROCEDURE IsScenario* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020897-0000-0000-C000-000000000046}") END IsScenario; PROCEDURE ThisGroupObject* (v: CtlT.Any): GroupObject; VAR new: GroupObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020898-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupObject; PROCEDURE IsGroupObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020898-0000-0000-C000-000000000046}") END IsGroupObject; PROCEDURE ThisGroupObjects* (v: CtlT.Any): GroupObjects; VAR new: GroupObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020899-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupObjects; PROCEDURE IsGroupObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020899-0000-0000-C000-000000000046}") END IsGroupObjects; PROCEDURE ThisLine* (v: CtlT.Any): Line; VAR new: Line; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLine; PROCEDURE IsLine* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089A-0000-0000-C000-000000000046}") END IsLine; PROCEDURE ThisLines* (v: CtlT.Any): Lines; VAR new: Lines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLines; PROCEDURE IsLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089B-0000-0000-C000-000000000046}") END IsLines; PROCEDURE ThisRectangle* (v: CtlT.Any): Rectangle; VAR new: Rectangle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRectangle; PROCEDURE IsRectangle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089C-0000-0000-C000-000000000046}") END IsRectangle; PROCEDURE ThisRectangles* (v: CtlT.Any): Rectangles; VAR new: Rectangles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRectangles; PROCEDURE IsRectangles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089D-0000-0000-C000-000000000046}") END IsRectangles; PROCEDURE ThisOval* (v: CtlT.Any): Oval; VAR new: Oval; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOval; PROCEDURE IsOval* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089E-0000-0000-C000-000000000046}") END IsOval; PROCEDURE ThisOvals* (v: CtlT.Any): Ovals; VAR new: Ovals; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002089F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOvals; PROCEDURE IsOvals* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002089F-0000-0000-C000-000000000046}") END IsOvals; PROCEDURE ThisArc* (v: CtlT.Any): Arc; VAR new: Arc; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisArc; PROCEDURE IsArc* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A0-0000-0000-C000-000000000046}") END IsArc; PROCEDURE ThisArcs* (v: CtlT.Any): Arcs; VAR new: Arcs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisArcs; PROCEDURE IsArcs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A1-0000-0000-C000-000000000046}") END IsArcs; PROCEDURE This_OLEObject* (v: CtlT.Any): _OLEObject; VAR new: _OLEObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_OLEObject; PROCEDURE Is_OLEObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A2-0000-0000-C000-000000000046}") END Is_OLEObject; PROCEDURE ThisOLEObjects* (v: CtlT.Any): OLEObjects; VAR new: OLEObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOLEObjects; PROCEDURE IsOLEObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A3-0000-0000-C000-000000000046}") END IsOLEObjects; PROCEDURE ThisTextBox* (v: CtlT.Any): TextBox; VAR new: TextBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextBox; PROCEDURE IsTextBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A4-0000-0000-C000-000000000046}") END IsTextBox; PROCEDURE ThisTextBoxes* (v: CtlT.Any): TextBoxes; VAR new: TextBoxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextBoxes; PROCEDURE IsTextBoxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A5-0000-0000-C000-000000000046}") END IsTextBoxes; PROCEDURE ThisPicture* (v: CtlT.Any): Picture; VAR new: Picture; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPicture; PROCEDURE IsPicture* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A6-0000-0000-C000-000000000046}") END IsPicture; PROCEDURE ThisPictures* (v: CtlT.Any): Pictures; VAR new: Pictures; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPictures; PROCEDURE IsPictures* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A7-0000-0000-C000-000000000046}") END IsPictures; PROCEDURE ThisDrawing* (v: CtlT.Any): Drawing; VAR new: Drawing; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDrawing; PROCEDURE IsDrawing* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A8-0000-0000-C000-000000000046}") END IsDrawing; PROCEDURE ThisDrawings* (v: CtlT.Any): Drawings; VAR new: Drawings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208A9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDrawings; PROCEDURE IsDrawings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208A9-0000-0000-C000-000000000046}") END IsDrawings; PROCEDURE ThisRoutingSlip* (v: CtlT.Any): RoutingSlip; VAR new: RoutingSlip; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208AA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRoutingSlip; PROCEDURE IsRoutingSlip* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208AA-0000-0000-C000-000000000046}") END IsRoutingSlip; PROCEDURE ThisOutline* (v: CtlT.Any): Outline; VAR new: Outline; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208AB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOutline; PROCEDURE IsOutline* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208AB-0000-0000-C000-000000000046}") END IsOutline; PROCEDURE ThisModule* (v: CtlT.Any): Module; VAR new: Module; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208AD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisModule; PROCEDURE IsModule* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208AD-0000-0000-C000-000000000046}") END IsModule; PROCEDURE ThisModules* (v: CtlT.Any): Modules; VAR new: Modules; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208AE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisModules; PROCEDURE IsModules* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208AE-0000-0000-C000-000000000046}") END IsModules; PROCEDURE ThisDialogSheet* (v: CtlT.Any): DialogSheet; VAR new: DialogSheet; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208AF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialogSheet; PROCEDURE IsDialogSheet* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208AF-0000-0000-C000-000000000046}") END IsDialogSheet; PROCEDURE ThisDialogSheets* (v: CtlT.Any): DialogSheets; VAR new: DialogSheets; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialogSheets; PROCEDURE IsDialogSheets* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B0-0000-0000-C000-000000000046}") END IsDialogSheets; PROCEDURE ThisWorksheets* (v: CtlT.Any): Worksheets; VAR new: Worksheets; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWorksheets; PROCEDURE IsWorksheets* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B1-0000-0000-C000-000000000046}") END IsWorksheets; PROCEDURE ThisPageSetup* (v: CtlT.Any): PageSetup; VAR new: PageSetup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPageSetup; PROCEDURE IsPageSetup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B4-0000-0000-C000-000000000046}") END IsPageSetup; PROCEDURE ThisNames* (v: CtlT.Any): Names; VAR new: Names; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisNames; PROCEDURE IsNames* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B8-0000-0000-C000-000000000046}") END IsNames; PROCEDURE ThisName* (v: CtlT.Any): Name; VAR new: Name; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisName; PROCEDURE IsName* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B9-0000-0000-C000-000000000046}") END IsName; PROCEDURE ThisChartObject* (v: CtlT.Any): ChartObject; VAR new: ChartObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208CF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartObject; PROCEDURE IsChartObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208CF-0000-0000-C000-000000000046}") END IsChartObject; PROCEDURE ThisChartObjects* (v: CtlT.Any): ChartObjects; VAR new: ChartObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartObjects; PROCEDURE IsChartObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D0-0000-0000-C000-000000000046}") END IsChartObjects; PROCEDURE ThisMailer* (v: CtlT.Any): Mailer; VAR new: Mailer; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailer; PROCEDURE IsMailer* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D1-0000-0000-C000-000000000046}") END IsMailer; PROCEDURE ThisCustomViews* (v: CtlT.Any): CustomViews; VAR new: CustomViews; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024422-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCustomViews; PROCEDURE IsCustomViews* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024422-0000-0000-C000-000000000046}") END IsCustomViews; PROCEDURE ThisCustomView* (v: CtlT.Any): CustomView; VAR new: CustomView; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024423-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCustomView; PROCEDURE IsCustomView* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024423-0000-0000-C000-000000000046}") END IsCustomView; PROCEDURE ThisFormatConditions* (v: CtlT.Any): FormatConditions; VAR new: FormatConditions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024424-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFormatConditions; PROCEDURE IsFormatConditions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024424-0000-0000-C000-000000000046}") END IsFormatConditions; PROCEDURE ThisFormatCondition* (v: CtlT.Any): FormatCondition; VAR new: FormatCondition; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024425-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFormatCondition; PROCEDURE IsFormatCondition* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024425-0000-0000-C000-000000000046}") END IsFormatCondition; PROCEDURE ThisComments* (v: CtlT.Any): Comments; VAR new: Comments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024426-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisComments; PROCEDURE IsComments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024426-0000-0000-C000-000000000046}") END IsComments; PROCEDURE ThisComment* (v: CtlT.Any): Comment; VAR new: Comment; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024427-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisComment; PROCEDURE IsComment* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024427-0000-0000-C000-000000000046}") END IsComment; PROCEDURE This_QueryTable* (v: CtlT.Any): _QueryTable; VAR new: _QueryTable; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024428-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_QueryTable; PROCEDURE Is_QueryTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024428-0000-0000-C000-000000000046}") END Is_QueryTable; PROCEDURE ThisQueryTables* (v: CtlT.Any): QueryTables; VAR new: QueryTables; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024429-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisQueryTables; PROCEDURE IsQueryTables* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024429-0000-0000-C000-000000000046}") END IsQueryTables; PROCEDURE ThisParameter* (v: CtlT.Any): Parameter; VAR new: Parameter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002442A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisParameter; PROCEDURE IsParameter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002442A-0000-0000-C000-000000000046}") END IsParameter; PROCEDURE ThisParameters* (v: CtlT.Any): Parameters; VAR new: Parameters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002442B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisParameters; PROCEDURE IsParameters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002442B-0000-0000-C000-000000000046}") END IsParameters; PROCEDURE ThisODBCError* (v: CtlT.Any): ODBCError; VAR new: ODBCError; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002442C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisODBCError; PROCEDURE IsODBCError* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002442C-0000-0000-C000-000000000046}") END IsODBCError; PROCEDURE ThisODBCErrors* (v: CtlT.Any): ODBCErrors; VAR new: ODBCErrors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002442D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisODBCErrors; PROCEDURE IsODBCErrors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002442D-0000-0000-C000-000000000046}") END IsODBCErrors; PROCEDURE ThisValidation* (v: CtlT.Any): Validation; VAR new: Validation; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002442F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisValidation; PROCEDURE IsValidation* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002442F-0000-0000-C000-000000000046}") END IsValidation; PROCEDURE ThisHyperlinks* (v: CtlT.Any): Hyperlinks; VAR new: Hyperlinks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024430-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHyperlinks; PROCEDURE IsHyperlinks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024430-0000-0000-C000-000000000046}") END IsHyperlinks; PROCEDURE ThisHyperlink* (v: CtlT.Any): Hyperlink; VAR new: Hyperlink; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024431-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHyperlink; PROCEDURE IsHyperlink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024431-0000-0000-C000-000000000046}") END IsHyperlink; PROCEDURE ThisAutoFilter* (v: CtlT.Any): AutoFilter; VAR new: AutoFilter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024432-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoFilter; PROCEDURE IsAutoFilter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024432-0000-0000-C000-000000000046}") END IsAutoFilter; PROCEDURE ThisFilters* (v: CtlT.Any): Filters; VAR new: Filters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024433-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFilters; PROCEDURE IsFilters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024433-0000-0000-C000-000000000046}") END IsFilters; PROCEDURE ThisFilter* (v: CtlT.Any): Filter; VAR new: Filter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024434-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFilter; PROCEDURE IsFilter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024434-0000-0000-C000-000000000046}") END IsFilter; PROCEDURE ThisAutoCorrect* (v: CtlT.Any): AutoCorrect; VAR new: AutoCorrect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCorrect; PROCEDURE IsAutoCorrect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D4-0000-0000-C000-000000000046}") END IsAutoCorrect; PROCEDURE ThisBorder* (v: CtlT.Any): Border; VAR new: Border; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020854-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBorder; PROCEDURE IsBorder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020854-0000-0000-C000-000000000046}") END IsBorder; PROCEDURE ThisInterior* (v: CtlT.Any): Interior; VAR new: Interior; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020870-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisInterior; PROCEDURE IsInterior* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020870-0000-0000-C000-000000000046}") END IsInterior; PROCEDURE ThisChartFillFormat* (v: CtlT.Any): ChartFillFormat; VAR new: ChartFillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024435-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartFillFormat; PROCEDURE IsChartFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024435-0000-0000-C000-000000000046}") END IsChartFillFormat; PROCEDURE ThisChartColorFormat* (v: CtlT.Any): ChartColorFormat; VAR new: ChartColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024436-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartColorFormat; PROCEDURE IsChartColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024436-0000-0000-C000-000000000046}") END IsChartColorFormat; PROCEDURE ThisAxis* (v: CtlT.Any): Axis; VAR new: Axis; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020848-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxis; PROCEDURE IsAxis* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020848-0000-0000-C000-000000000046}") END IsAxis; PROCEDURE ThisChartTitle* (v: CtlT.Any): ChartTitle; VAR new: ChartTitle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020849-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartTitle; PROCEDURE IsChartTitle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020849-0000-0000-C000-000000000046}") END IsChartTitle; PROCEDURE ThisAxisTitle* (v: CtlT.Any): AxisTitle; VAR new: AxisTitle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002084A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxisTitle; PROCEDURE IsAxisTitle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002084A-0000-0000-C000-000000000046}") END IsAxisTitle; PROCEDURE ThisChartGroup* (v: CtlT.Any): ChartGroup; VAR new: ChartGroup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020859-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartGroup; PROCEDURE IsChartGroup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020859-0000-0000-C000-000000000046}") END IsChartGroup; PROCEDURE ThisChartGroups* (v: CtlT.Any): ChartGroups; VAR new: ChartGroups; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartGroups; PROCEDURE IsChartGroups* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085A-0000-0000-C000-000000000046}") END IsChartGroups; PROCEDURE ThisAxes* (v: CtlT.Any): Axes; VAR new: Axes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002085B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxes; PROCEDURE IsAxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002085B-0000-0000-C000-000000000046}") END IsAxes; PROCEDURE ThisPoints* (v: CtlT.Any): Points; VAR new: Points; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020869-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPoints; PROCEDURE IsPoints* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020869-0000-0000-C000-000000000046}") END IsPoints; PROCEDURE ThisPoint* (v: CtlT.Any): Point; VAR new: Point; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002086A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPoint; PROCEDURE IsPoint* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002086A-0000-0000-C000-000000000046}") END IsPoint; PROCEDURE ThisSeries* (v: CtlT.Any): Series; VAR new: Series; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002086B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeries; PROCEDURE IsSeries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002086B-0000-0000-C000-000000000046}") END IsSeries; PROCEDURE ThisSeriesCollection* (v: CtlT.Any): SeriesCollection; VAR new: SeriesCollection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002086C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeriesCollection; PROCEDURE IsSeriesCollection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002086C-0000-0000-C000-000000000046}") END IsSeriesCollection; PROCEDURE ThisDataLabel* (v: CtlT.Any): DataLabel; VAR new: DataLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataLabel; PROCEDURE IsDataLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B2-0000-0000-C000-000000000046}") END IsDataLabel; PROCEDURE ThisDataLabels* (v: CtlT.Any): DataLabels; VAR new: DataLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208B3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataLabels; PROCEDURE IsDataLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208B3-0000-0000-C000-000000000046}") END IsDataLabels; PROCEDURE ThisLegendEntry* (v: CtlT.Any): LegendEntry; VAR new: LegendEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208BA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendEntry; PROCEDURE IsLegendEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208BA-0000-0000-C000-000000000046}") END IsLegendEntry; PROCEDURE ThisLegendEntries* (v: CtlT.Any): LegendEntries; VAR new: LegendEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208BB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendEntries; PROCEDURE IsLegendEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208BB-0000-0000-C000-000000000046}") END IsLegendEntries; PROCEDURE ThisLegendKey* (v: CtlT.Any): LegendKey; VAR new: LegendKey; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208BC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendKey; PROCEDURE IsLegendKey* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208BC-0000-0000-C000-000000000046}") END IsLegendKey; PROCEDURE ThisTrendlines* (v: CtlT.Any): Trendlines; VAR new: Trendlines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208BD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTrendlines; PROCEDURE IsTrendlines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208BD-0000-0000-C000-000000000046}") END IsTrendlines; PROCEDURE ThisTrendline* (v: CtlT.Any): Trendline; VAR new: Trendline; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208BE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTrendline; PROCEDURE IsTrendline* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208BE-0000-0000-C000-000000000046}") END IsTrendline; PROCEDURE ThisCorners* (v: CtlT.Any): Corners; VAR new: Corners; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCorners; PROCEDURE IsCorners* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C0-0000-0000-C000-000000000046}") END IsCorners; PROCEDURE ThisSeriesLines* (v: CtlT.Any): SeriesLines; VAR new: SeriesLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeriesLines; PROCEDURE IsSeriesLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C1-0000-0000-C000-000000000046}") END IsSeriesLines; PROCEDURE ThisHiLoLines* (v: CtlT.Any): HiLoLines; VAR new: HiLoLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHiLoLines; PROCEDURE IsHiLoLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C2-0000-0000-C000-000000000046}") END IsHiLoLines; PROCEDURE ThisGridlines* (v: CtlT.Any): Gridlines; VAR new: Gridlines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGridlines; PROCEDURE IsGridlines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C3-0000-0000-C000-000000000046}") END IsGridlines; PROCEDURE ThisDropLines* (v: CtlT.Any): DropLines; VAR new: DropLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropLines; PROCEDURE IsDropLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C4-0000-0000-C000-000000000046}") END IsDropLines; PROCEDURE ThisLeaderLines* (v: CtlT.Any): LeaderLines; VAR new: LeaderLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024437-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLeaderLines; PROCEDURE IsLeaderLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024437-0000-0000-C000-000000000046}") END IsLeaderLines; PROCEDURE ThisUpBars* (v: CtlT.Any): UpBars; VAR new: UpBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisUpBars; PROCEDURE IsUpBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C5-0000-0000-C000-000000000046}") END IsUpBars; PROCEDURE ThisDownBars* (v: CtlT.Any): DownBars; VAR new: DownBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDownBars; PROCEDURE IsDownBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C6-0000-0000-C000-000000000046}") END IsDownBars; PROCEDURE ThisFloor* (v: CtlT.Any): Floor; VAR new: Floor; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFloor; PROCEDURE IsFloor* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C7-0000-0000-C000-000000000046}") END IsFloor; PROCEDURE ThisWalls* (v: CtlT.Any): Walls; VAR new: Walls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWalls; PROCEDURE IsWalls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C8-0000-0000-C000-000000000046}") END IsWalls; PROCEDURE ThisTickLabels* (v: CtlT.Any): TickLabels; VAR new: TickLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208C9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTickLabels; PROCEDURE IsTickLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208C9-0000-0000-C000-000000000046}") END IsTickLabels; PROCEDURE ThisPlotArea* (v: CtlT.Any): PlotArea; VAR new: PlotArea; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208CB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPlotArea; PROCEDURE IsPlotArea* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208CB-0000-0000-C000-000000000046}") END IsPlotArea; PROCEDURE ThisChartArea* (v: CtlT.Any): ChartArea; VAR new: ChartArea; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208CC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartArea; PROCEDURE IsChartArea* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208CC-0000-0000-C000-000000000046}") END IsChartArea; PROCEDURE ThisLegend* (v: CtlT.Any): Legend; VAR new: Legend; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208CD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegend; PROCEDURE IsLegend* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208CD-0000-0000-C000-000000000046}") END IsLegend; PROCEDURE ThisErrorBars* (v: CtlT.Any): ErrorBars; VAR new: ErrorBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208CE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisErrorBars; PROCEDURE IsErrorBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208CE-0000-0000-C000-000000000046}") END IsErrorBars; PROCEDURE ThisDataTable* (v: CtlT.Any): DataTable; VAR new: DataTable; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020843-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataTable; PROCEDURE IsDataTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020843-0000-0000-C000-000000000046}") END IsDataTable; PROCEDURE ThisPhonetic* (v: CtlT.Any): Phonetic; VAR new: Phonetic; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024438-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPhonetic; PROCEDURE IsPhonetic* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024438-0000-0000-C000-000000000046}") END IsPhonetic; PROCEDURE ThisShape* (v: CtlT.Any): Shape; VAR new: Shape; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024439-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShape; PROCEDURE IsShape* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024439-0000-0000-C000-000000000046}") END IsShape; PROCEDURE ThisShapes* (v: CtlT.Any): Shapes; VAR new: Shapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapes; PROCEDURE IsShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443A-0000-0000-C000-000000000046}") END IsShapes; PROCEDURE ThisShapeRange* (v: CtlT.Any): ShapeRange; VAR new: ShapeRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeRange; PROCEDURE IsShapeRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443B-0000-0000-C000-000000000046}") END IsShapeRange; PROCEDURE ThisGroupShapes* (v: CtlT.Any): GroupShapes; VAR new: GroupShapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupShapes; PROCEDURE IsGroupShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443C-0000-0000-C000-000000000046}") END IsGroupShapes; PROCEDURE ThisTextFrame* (v: CtlT.Any): TextFrame; VAR new: TextFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextFrame; PROCEDURE IsTextFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443D-0000-0000-C000-000000000046}") END IsTextFrame; PROCEDURE ThisConnectorFormat* (v: CtlT.Any): ConnectorFormat; VAR new: ConnectorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisConnectorFormat; PROCEDURE IsConnectorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443E-0000-0000-C000-000000000046}") END IsConnectorFormat; PROCEDURE ThisFreeformBuilder* (v: CtlT.Any): FreeformBuilder; VAR new: FreeformBuilder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002443F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFreeformBuilder; PROCEDURE IsFreeformBuilder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002443F-0000-0000-C000-000000000046}") END IsFreeformBuilder; PROCEDURE ThisControlFormat* (v: CtlT.Any): ControlFormat; VAR new: ControlFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024440-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisControlFormat; PROCEDURE IsControlFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024440-0000-0000-C000-000000000046}") END IsControlFormat; PROCEDURE ThisOLEFormat* (v: CtlT.Any): OLEFormat; VAR new: OLEFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024441-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOLEFormat; PROCEDURE IsOLEFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024441-0000-0000-C000-000000000046}") END IsOLEFormat; PROCEDURE ThisLinkFormat* (v: CtlT.Any): LinkFormat; VAR new: LinkFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024442-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLinkFormat; PROCEDURE IsLinkFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024442-0000-0000-C000-000000000046}") END IsLinkFormat; PROCEDURE ThisPublishObjects* (v: CtlT.Any): PublishObjects; VAR new: PublishObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024443-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPublishObjects; PROCEDURE IsPublishObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024443-0000-0000-C000-000000000046}") END IsPublishObjects; PROCEDURE ThisOLEDBError* (v: CtlT.Any): OLEDBError; VAR new: OLEDBError; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024445-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOLEDBError; PROCEDURE IsOLEDBError* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024445-0000-0000-C000-000000000046}") END IsOLEDBError; PROCEDURE ThisOLEDBErrors* (v: CtlT.Any): OLEDBErrors; VAR new: OLEDBErrors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024446-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOLEDBErrors; PROCEDURE IsOLEDBErrors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024446-0000-0000-C000-000000000046}") END IsOLEDBErrors; PROCEDURE ThisPhonetics* (v: CtlT.Any): Phonetics; VAR new: Phonetics; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024447-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPhonetics; PROCEDURE IsPhonetics* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024447-0000-0000-C000-000000000046}") END IsPhonetics; PROCEDURE ThisPivotLayout* (v: CtlT.Any): PivotLayout; VAR new: PivotLayout; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002444A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPivotLayout; PROCEDURE IsPivotLayout* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002444A-0000-0000-C000-000000000046}") END IsPivotLayout; PROCEDURE ThisDisplayUnitLabel* (v: CtlT.Any): DisplayUnitLabel; VAR new: DisplayUnitLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002084C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDisplayUnitLabel; PROCEDURE IsDisplayUnitLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002084C-0000-0000-C000-000000000046}") END IsDisplayUnitLabel; (* ---------- Adjustments, dual, nonextensible ---------- *) PROCEDURE (this: Adjustments) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Adjustments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Adjustments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Adjustments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Adjustments) Item* (Index: INTEGER): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarSReal(ret) END Item; PROCEDURE (this: Adjustments) PUTItem* (Index: INTEGER; p2: SHORTREAL), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.SRealVar(p2, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUTItem; (* ---------- CalloutFormat, dual, nonextensible ---------- *) PROCEDURE (this: CalloutFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: CalloutFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: CalloutFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: CalloutFormat) AutomaticLength* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END AutomaticLength; PROCEDURE (this: CalloutFormat) CustomDrop* (Drop: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Drop, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END CustomDrop; PROCEDURE (this: CalloutFormat) CustomLength* (Length: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Length, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END CustomLength; PROCEDURE (this: CalloutFormat) PresetDrop* (DropType: CtlOffice.MsoCalloutDropType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(DropType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetDrop; PROCEDURE (this: CalloutFormat) Accent* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Accent; PROCEDURE (this: CalloutFormat) PUTAccent* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAccent; PROCEDURE (this: CalloutFormat) Angle* (): CtlOffice.MsoCalloutAngleType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Angle; PROCEDURE (this: CalloutFormat) PUTAngle* (p1: CtlOffice.MsoCalloutAngleType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAngle; PROCEDURE (this: CalloutFormat) AutoAttach* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END AutoAttach; PROCEDURE (this: CalloutFormat) PUTAutoAttach* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTAutoAttach; PROCEDURE (this: CalloutFormat) AutoLength* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END AutoLength; PROCEDURE (this: CalloutFormat) Border* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Border; PROCEDURE (this: CalloutFormat) PUTBorder* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTBorder; PROCEDURE (this: CalloutFormat) Drop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END Drop; PROCEDURE (this: CalloutFormat) DropType* (): CtlOffice.MsoCalloutDropType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END DropType; PROCEDURE (this: CalloutFormat) Gap* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END Gap; PROCEDURE (this: CalloutFormat) PUTGap* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTGap; PROCEDURE (this: CalloutFormat) Length* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END Length; PROCEDURE (this: CalloutFormat) Type* (): CtlOffice.MsoCalloutType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Type; PROCEDURE (this: CalloutFormat) PUTType* (p1: CtlOffice.MsoCalloutType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTType; (* ---------- ColorFormat, dual, nonextensible ---------- *) PROCEDURE (this: ColorFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ColorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ColorFormat) RGB* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END RGB; PROCEDURE (this: ColorFormat) PUTRGB* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTRGB; PROCEDURE (this: ColorFormat) SchemeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END SchemeColor; PROCEDURE (this: ColorFormat) PUTSchemeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTSchemeColor; PROCEDURE (this: ColorFormat) Type* (): CtlOffice.MsoColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Type; (* ---------- LineFormat, dual, nonextensible ---------- *) PROCEDURE (this: LineFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: LineFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: LineFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: LineFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: LineFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: LineFormat) BeginArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END BeginArrowheadLength; PROCEDURE (this: LineFormat) PUTBeginArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTBeginArrowheadLength; PROCEDURE (this: LineFormat) BeginArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginArrowheadStyle; PROCEDURE (this: LineFormat) PUTBeginArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBeginArrowheadStyle; PROCEDURE (this: LineFormat) BeginArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END BeginArrowheadWidth; PROCEDURE (this: LineFormat) PUTBeginArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTBeginArrowheadWidth; PROCEDURE (this: LineFormat) DashStyle* (): CtlOffice.MsoLineDashStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END DashStyle; PROCEDURE (this: LineFormat) PUTDashStyle* (p1: CtlOffice.MsoLineDashStyle), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTDashStyle; PROCEDURE (this: LineFormat) EndArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndArrowheadLength; PROCEDURE (this: LineFormat) PUTEndArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTEndArrowheadLength; PROCEDURE (this: LineFormat) EndArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END EndArrowheadStyle; PROCEDURE (this: LineFormat) PUTEndArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTEndArrowheadStyle; PROCEDURE (this: LineFormat) EndArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END EndArrowheadWidth; PROCEDURE (this: LineFormat) PUTEndArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTEndArrowheadWidth; PROCEDURE (this: LineFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 108)) END ForeColor; PROCEDURE (this: LineFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 108, p1) END PUTForeColor; PROCEDURE (this: LineFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Pattern; PROCEDURE (this: LineFormat) PUTPattern* (p1: CtlOffice.MsoPatternType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTPattern; PROCEDURE (this: LineFormat) Style* (): CtlOffice.MsoLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END Style; PROCEDURE (this: LineFormat) PUTStyle* (p1: CtlOffice.MsoLineStyle), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTStyle; PROCEDURE (this: LineFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: LineFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: LineFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Visible; PROCEDURE (this: LineFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 112, p1) END PUTVisible; PROCEDURE (this: LineFormat) Weight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END Weight; PROCEDURE (this: LineFormat) PUTWeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTWeight; (* ---------- ShapeNode, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNode) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShapeNode) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShapeNode) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNode) EditingType* (): CtlOffice.MsoEditingType, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EditingType; PROCEDURE (this: ShapeNode) Points* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Points; PROCEDURE (this: ShapeNode) SegmentType* (): CtlOffice.MsoSegmentType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SegmentType; (* ---------- ShapeNodes, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNodes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShapeNodes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShapeNodes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNodes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeNodes) Item* (Index: CtlT.Any): ShapeNode, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShapeNode(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeNodes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeNodes) Delete* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Delete; PROCEDURE (this: ShapeNodes) Insert* (Index: INTEGER; SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[8]); CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Insert; PROCEDURE (this: ShapeNodes) SetEditingType* (Index: INTEGER; EditingType: CtlOffice.MsoEditingType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(EditingType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetEditingType; PROCEDURE (this: ShapeNodes) SetPosition* (Index: INTEGER; X1: SHORTREAL; Y1: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetPosition; PROCEDURE (this: ShapeNodes) SetSegmentType* (Index: INTEGER; SegmentType: CtlOffice.MsoSegmentType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(SegmentType, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END SetSegmentType; (* ---------- PictureFormat, dual, nonextensible ---------- *) PROCEDURE (this: PictureFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: PictureFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: PictureFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: PictureFormat) IncrementBrightness* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementBrightness; PROCEDURE (this: PictureFormat) IncrementContrast* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementContrast; PROCEDURE (this: PictureFormat) Brightness* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Brightness; PROCEDURE (this: PictureFormat) PUTBrightness* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTBrightness; PROCEDURE (this: PictureFormat) ColorType* (): CtlOffice.MsoPictureColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END ColorType; PROCEDURE (this: PictureFormat) PUTColorType* (p1: CtlOffice.MsoPictureColorType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTColorType; PROCEDURE (this: PictureFormat) Contrast* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Contrast; PROCEDURE (this: PictureFormat) PUTContrast* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTContrast; PROCEDURE (this: PictureFormat) CropBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END CropBottom; PROCEDURE (this: PictureFormat) PUTCropBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTCropBottom; PROCEDURE (this: PictureFormat) CropLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END CropLeft; PROCEDURE (this: PictureFormat) PUTCropLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTCropLeft; PROCEDURE (this: PictureFormat) CropRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END CropRight; PROCEDURE (this: PictureFormat) PUTCropRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTCropRight; PROCEDURE (this: PictureFormat) CropTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END CropTop; PROCEDURE (this: PictureFormat) PUTCropTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTCropTop; PROCEDURE (this: PictureFormat) TransparencyColor* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END TransparencyColor; PROCEDURE (this: PictureFormat) PUTTransparencyColor* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTTransparencyColor; PROCEDURE (this: PictureFormat) TransparentBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END TransparentBackground; PROCEDURE (this: PictureFormat) PUTTransparentBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTTransparentBackground; (* ---------- ShadowFormat, dual, nonextensible ---------- *) PROCEDURE (this: ShadowFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShadowFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShadowFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShadowFormat) IncrementOffsetX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementOffsetX; PROCEDURE (this: ShadowFormat) IncrementOffsetY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementOffsetY; PROCEDURE (this: ShadowFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END ForeColor; PROCEDURE (this: ShadowFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTForeColor; PROCEDURE (this: ShadowFormat) Obscured* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Obscured; PROCEDURE (this: ShadowFormat) PUTObscured* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTObscured; PROCEDURE (this: ShadowFormat) OffsetX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END OffsetX; PROCEDURE (this: ShadowFormat) PUTOffsetX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTOffsetX; PROCEDURE (this: ShadowFormat) OffsetY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END OffsetY; PROCEDURE (this: ShadowFormat) PUTOffsetY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTOffsetY; PROCEDURE (this: ShadowFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END Transparency; PROCEDURE (this: ShadowFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTTransparency; PROCEDURE (this: ShadowFormat) Type* (): CtlOffice.MsoShadowType, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Type; PROCEDURE (this: ShadowFormat) PUTType* (p1: CtlOffice.MsoShadowType), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTType; PROCEDURE (this: ShadowFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Visible; PROCEDURE (this: ShadowFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTVisible; (* ---------- TextEffectFormat, dual, nonextensible ---------- *) PROCEDURE (this: TextEffectFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: TextEffectFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: TextEffectFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextEffectFormat) ToggleVerticalText* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END ToggleVerticalText; PROCEDURE (this: TextEffectFormat) Alignment* (): CtlOffice.MsoTextEffectAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Alignment; PROCEDURE (this: TextEffectFormat) PUTAlignment* (p1: CtlOffice.MsoTextEffectAlignment), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAlignment; PROCEDURE (this: TextEffectFormat) FontBold* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END FontBold; PROCEDURE (this: TextEffectFormat) PUTFontBold* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTFontBold; PROCEDURE (this: TextEffectFormat) FontItalic* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END FontItalic; PROCEDURE (this: TextEffectFormat) PUTFontItalic* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTFontItalic; PROCEDURE (this: TextEffectFormat) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END FontName; PROCEDURE (this: TextEffectFormat) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTFontName; PROCEDURE (this: TextEffectFormat) FontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END FontSize; PROCEDURE (this: TextEffectFormat) PUTFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTFontSize; PROCEDURE (this: TextEffectFormat) KernedPairs* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END KernedPairs; PROCEDURE (this: TextEffectFormat) PUTKernedPairs* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTKernedPairs; PROCEDURE (this: TextEffectFormat) NormalizedHeight* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END NormalizedHeight; PROCEDURE (this: TextEffectFormat) PUTNormalizedHeight* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTNormalizedHeight; PROCEDURE (this: TextEffectFormat) PresetShape* (): CtlOffice.MsoPresetTextEffectShape, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetShape; PROCEDURE (this: TextEffectFormat) PUTPresetShape* (p1: CtlOffice.MsoPresetTextEffectShape), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetShape; PROCEDURE (this: TextEffectFormat) PresetTextEffect* (): CtlOffice.MsoPresetTextEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTextEffect; PROCEDURE (this: TextEffectFormat) PUTPresetTextEffect* (p1: CtlOffice.MsoPresetTextEffect), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTPresetTextEffect; PROCEDURE (this: TextEffectFormat) RotatedChars* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END RotatedChars; PROCEDURE (this: TextEffectFormat) PUTRotatedChars* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTRotatedChars; PROCEDURE (this: TextEffectFormat) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Text; PROCEDURE (this: TextEffectFormat) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTText; PROCEDURE (this: TextEffectFormat) Tracking* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Tracking; PROCEDURE (this: TextEffectFormat) PUTTracking* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTracking; (* ---------- ThreeDFormat, dual, nonextensible ---------- *) PROCEDURE (this: ThreeDFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ThreeDFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ThreeDFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ThreeDFormat) IncrementRotationX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementRotationX; PROCEDURE (this: ThreeDFormat) IncrementRotationY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementRotationY; PROCEDURE (this: ThreeDFormat) ResetRotation* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END ResetRotation; PROCEDURE (this: ThreeDFormat) SetThreeDFormat* (PresetThreeDFormat: CtlOffice.MsoPresetThreeDFormat), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetThreeDFormat, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetThreeDFormat; PROCEDURE (this: ThreeDFormat) SetExtrusionDirection* (PresetExtrusionDirection: CtlOffice.MsoPresetExtrusionDirection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetExtrusionDirection, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetExtrusionDirection; PROCEDURE (this: ThreeDFormat) Depth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Depth; PROCEDURE (this: ThreeDFormat) PUTDepth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTDepth; PROCEDURE (this: ThreeDFormat) ExtrusionColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ExtrusionColor; PROCEDURE (this: ThreeDFormat) ExtrusionColorType* (): CtlOffice.MsoExtrusionColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END ExtrusionColorType; PROCEDURE (this: ThreeDFormat) PUTExtrusionColorType* (p1: CtlOffice.MsoExtrusionColorType), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTExtrusionColorType; PROCEDURE (this: ThreeDFormat) Perspective* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END Perspective; PROCEDURE (this: ThreeDFormat) PUTPerspective* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTPerspective; PROCEDURE (this: ThreeDFormat) PresetExtrusionDirection* (): CtlOffice.MsoPresetExtrusionDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PresetExtrusionDirection; PROCEDURE (this: ThreeDFormat) PresetLightingDirection* (): CtlOffice.MsoPresetLightingDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END PresetLightingDirection; PROCEDURE (this: ThreeDFormat) PUTPresetLightingDirection* (p1: CtlOffice.MsoPresetLightingDirection), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTPresetLightingDirection; PROCEDURE (this: ThreeDFormat) PresetLightingSoftness* (): CtlOffice.MsoPresetLightingSoftness, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END PresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PUTPresetLightingSoftness* (p1: CtlOffice.MsoPresetLightingSoftness), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTPresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PresetMaterial* (): CtlOffice.MsoPresetMaterial, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetMaterial; PROCEDURE (this: ThreeDFormat) PUTPresetMaterial* (p1: CtlOffice.MsoPresetMaterial), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetMaterial; PROCEDURE (this: ThreeDFormat) PresetThreeDFormat* (): CtlOffice.MsoPresetThreeDFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetThreeDFormat; PROCEDURE (this: ThreeDFormat) RotationX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END RotationX; PROCEDURE (this: ThreeDFormat) PUTRotationX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTRotationX; PROCEDURE (this: ThreeDFormat) RotationY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 110) END RotationY; PROCEDURE (this: ThreeDFormat) PUTRotationY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 110, p1) END PUTRotationY; PROCEDURE (this: ThreeDFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END Visible; PROCEDURE (this: ThreeDFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTVisible; (* ---------- FillFormat, dual, nonextensible ---------- *) PROCEDURE (this: FillFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: FillFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: FillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FillFormat) Background* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Background; PROCEDURE (this: FillFormat) OneColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END OneColorGradient; PROCEDURE (this: FillFormat) Patterned* (Pattern: CtlOffice.MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Patterned; PROCEDURE (this: FillFormat) PresetGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; PresetGradientType: CtlOffice.MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetGradient; PROCEDURE (this: FillFormat) PresetTextured* (PresetTexture: CtlOffice.MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END PresetTextured; PROCEDURE (this: FillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 15, NIL); END Solid; PROCEDURE (this: FillFormat) TwoColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END TwoColorGradient; PROCEDURE (this: FillFormat) UserPicture* (PictureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PictureFile, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END UserPicture; PROCEDURE (this: FillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END UserTextured; PROCEDURE (this: FillFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: FillFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: FillFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ForeColor; PROCEDURE (this: FillFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 101, p1) END PUTForeColor; PROCEDURE (this: FillFormat) GradientColorType* (): CtlOffice.MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END GradientColorType; PROCEDURE (this: FillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END GradientDegree; PROCEDURE (this: FillFormat) GradientStyle* (): CtlOffice.MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END GradientStyle; PROCEDURE (this: FillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END GradientVariant; PROCEDURE (this: FillFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Pattern; PROCEDURE (this: FillFormat) PresetGradientType* (): CtlOffice.MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetGradientType; PROCEDURE (this: FillFormat) PresetTexture* (): CtlOffice.MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTexture; PROCEDURE (this: FillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END TextureName; PROCEDURE (this: FillFormat) TextureType* (): CtlOffice.MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END TextureType; PROCEDURE (this: FillFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: FillFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: FillFormat) Type* (): CtlOffice.MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Type; PROCEDURE (this: FillFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Visible; PROCEDURE (this: FillFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTVisible; (* ---------- _Application, dual ---------- *) PROCEDURE (this: _Application) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Application) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Application) Parent* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: _Application) ActiveCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 305)) END ActiveCell; PROCEDURE (this: _Application) ActiveChart* (): Chart, NEW; BEGIN RETURN This_Chart(CtlC.GetAny(this, 183)) END ActiveChart; PROCEDURE (this: _Application) ActiveDialog* (): DialogSheet, NEW; BEGIN RETURN ThisDialogSheet(CtlC.GetAny(this, 815)) END ActiveDialog; PROCEDURE (this: _Application) ActiveMenuBar* (): MenuBar, NEW; BEGIN RETURN ThisMenuBar(CtlC.GetAny(this, 758)) END ActiveMenuBar; PROCEDURE (this: _Application) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 306) END ActivePrinter; PROCEDURE (this: _Application) PUTActivePrinter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 306, p1) END PUTActivePrinter; PROCEDURE (this: _Application) ActiveSheet* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 307) END ActiveSheet; PROCEDURE (this: _Application) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 759)) END ActiveWindow; PROCEDURE (this: _Application) ActiveWorkbook* (): Workbook, NEW; BEGIN RETURN This_Workbook(CtlC.GetAny(this, 308)) END ActiveWorkbook; PROCEDURE (this: _Application) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 549)) END AddIns; PROCEDURE (this: _Application) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 1438)) END Assistant; PROCEDURE (this: _Application) Calculate* (), NEW; BEGIN CtlC.CallMethod(this, 279, NIL); END Calculate; PROCEDURE (this: _Application) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: _Application) Charts* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 121)) END Charts; PROCEDURE (this: _Application) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: _Application) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 1439)) END CommandBars; PROCEDURE (this: _Application) DDEAppReturnCode* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 332) END DDEAppReturnCode; PROCEDURE (this: _Application) DDEExecute* (Channel: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 333, arg, NIL); END DDEExecute; PROCEDURE (this: _Application) DDEInitiate* (App: ARRAY OF CHAR; Topic: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(App, arg[1]); CtlC.StrVar(Topic, arg[0]); CtlC.CallParMethod(this, 334, arg, ret); RETURN CtlC.VarInt(ret) END DDEInitiate; PROCEDURE (this: _Application) DDEPoke* (Channel: INTEGER; Item: CtlT.Any; Data: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[2]); CtlC.AnyVar(Item, arg[1]); CtlC.AnyVar(Data, arg[0]); CtlC.CallParMethod(this, 335, arg, NIL); END DDEPoke; PROCEDURE (this: _Application) DDERequest* (Channel: INTEGER; Item: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Item, arg[0]); CtlC.CallParMethod(this, 336, arg, ret); RETURN CtlC.VarAny(ret) END DDERequest; PROCEDURE (this: _Application) DDETerminate* (Channel: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[0]); CtlC.CallParMethod(this, 337, arg, NIL); END DDETerminate; PROCEDURE (this: _Application) DialogSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 764)) END DialogSheets; PROCEDURE (this: _Application) Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: _Application) _Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Application) ExecuteExcel4Macro* (String: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 350, arg, ret); RETURN CtlC.VarAny(ret) END ExecuteExcel4Macro; PROCEDURE (this: _Application) Intersect* (Arg1: Range; Arg2: Range; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): Range, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[29]); CtlC.ObjVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 766, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Intersect; PROCEDURE (this: _Application) MenuBars* (): MenuBars, NEW; BEGIN RETURN ThisMenuBars(CtlC.GetAny(this, 589)) END MenuBars; PROCEDURE (this: _Application) Modules* (): Modules, NEW; BEGIN RETURN ThisModules(CtlC.GetAny(this, 582)) END Modules; PROCEDURE (this: _Application) Names* (): Names, NEW; BEGIN RETURN ThisNames(CtlC.GetAny(this, 442)) END Names; PROCEDURE (this: _Application) Range* (Cell1: CtlT.Any; (* optional *) Cell2: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cell1, arg[1]); CtlC.AnyVar(Cell2, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: _Application) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: _Application) Run* ((* optional *) Macro: CtlT.Any; Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Macro, arg[30]); CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 259, arg, ret); RETURN CtlC.VarAny(ret) END Run; PROCEDURE (this: _Application) _Run2* ((* optional *) Macro: CtlT.Any; Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Macro, arg[30]); CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 806, arg, ret); RETURN CtlC.VarAny(ret) END _Run2; PROCEDURE (this: _Application) Selection* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 147) END Selection; PROCEDURE (this: _Application) SendKeys* (Keys: CtlT.Any; (* optional *) Wait: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Keys, arg[1]); CtlC.AnyVar(Wait, arg[0]); CtlC.CallParMethod(this, 383, arg, NIL); END SendKeys; PROCEDURE (this: _Application) Sheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 485)) END Sheets; PROCEDURE (this: _Application) ShortcutMenus* (Index: INTEGER): Menu, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 776, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END ShortcutMenus; PROCEDURE (this: _Application) ThisWorkbook* (): Workbook, NEW; BEGIN RETURN This_Workbook(CtlC.GetAny(this, 778)) END ThisWorkbook; PROCEDURE (this: _Application) Toolbars* (): Toolbars, NEW; BEGIN RETURN ThisToolbars(CtlC.GetAny(this, 552)) END Toolbars; PROCEDURE (this: _Application) Union* (Arg1: Range; Arg2: Range; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): Range, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[29]); CtlC.ObjVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 779, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Union; PROCEDURE (this: _Application) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 430)) END Windows; PROCEDURE (this: _Application) Workbooks* (): Workbooks, NEW; BEGIN RETURN ThisWorkbooks(CtlC.GetAny(this, 572)) END Workbooks; PROCEDURE (this: _Application) WorksheetFunction* (): WorksheetFunction, NEW; BEGIN RETURN ThisWorksheetFunction(CtlC.GetAny(this, 1440)) END WorksheetFunction; PROCEDURE (this: _Application) Worksheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 494)) END Worksheets; PROCEDURE (this: _Application) Excel4IntlMacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 581)) END Excel4IntlMacroSheets; PROCEDURE (this: _Application) Excel4MacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 579)) END Excel4MacroSheets; PROCEDURE (this: _Application) ActivateMicrosoftApp* (Index: XlMSApplication), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 1095, arg, NIL); END ActivateMicrosoftApp; PROCEDURE (this: _Application) AddChartAutoFormat* (Chart: CtlT.Any; Name: ARRAY OF CHAR; (* optional *) Description: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Chart, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Description, arg[0]); CtlC.CallParMethod(this, 216, arg, NIL); END AddChartAutoFormat; PROCEDURE (this: _Application) AddCustomList* (ListArray: CtlT.Any; (* optional *) ByRow: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(ListArray, arg[1]); CtlC.AnyVar(ByRow, arg[0]); CtlC.CallParMethod(this, 780, arg, NIL); END AddCustomList; PROCEDURE (this: _Application) AlertBeforeOverwriting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 930) END AlertBeforeOverwriting; PROCEDURE (this: _Application) PUTAlertBeforeOverwriting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 930, p1) END PUTAlertBeforeOverwriting; PROCEDURE (this: _Application) AltStartupPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 313) END AltStartupPath; PROCEDURE (this: _Application) PUTAltStartupPath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 313, p1) END PUTAltStartupPath; PROCEDURE (this: _Application) AskToUpdateLinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 992) END AskToUpdateLinks; PROCEDURE (this: _Application) PUTAskToUpdateLinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 992, p1) END PUTAskToUpdateLinks; PROCEDURE (this: _Application) EnableAnimations* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1180) END EnableAnimations; PROCEDURE (this: _Application) PUTEnableAnimations* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1180, p1) END PUTEnableAnimations; PROCEDURE (this: _Application) AutoCorrect* (): AutoCorrect, NEW; BEGIN RETURN ThisAutoCorrect(CtlC.GetAny(this, 1145)) END AutoCorrect; PROCEDURE (this: _Application) Build* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 314) END Build; PROCEDURE (this: _Application) CalculateBeforeSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 315) END CalculateBeforeSave; PROCEDURE (this: _Application) PUTCalculateBeforeSave* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 315, p1) END PUTCalculateBeforeSave; PROCEDURE (this: _Application) Calculation* (): XlCalculation, NEW; BEGIN RETURN CtlC.GetInt(this, 316) END Calculation; PROCEDURE (this: _Application) PUTCalculation* (p1: XlCalculation), NEW; BEGIN CtlC.PutInt(this, 316, p1) END PUTCalculation; PROCEDURE (this: _Application) Caller* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 317, arg, ret); RETURN CtlC.VarAny(ret) END Caller; PROCEDURE (this: _Application) CanPlaySounds* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 318) END CanPlaySounds; PROCEDURE (this: _Application) CanRecordSounds* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 319) END CanRecordSounds; PROCEDURE (this: _Application) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: _Application) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: _Application) CellDragAndDrop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 320) END CellDragAndDrop; PROCEDURE (this: _Application) PUTCellDragAndDrop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 320, p1) END PUTCellDragAndDrop; PROCEDURE (this: _Application) CentimetersToPoints* (Centimeters: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Centimeters, arg[0]); CtlC.CallParMethod(this, 1086, arg, ret); RETURN CtlC.VarReal(ret) END CentimetersToPoints; PROCEDURE (this: _Application) CheckSpelling* (Word: ARRAY OF CHAR; (* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[2]); CtlC.AnyVar(CustomDictionary, arg[1]); CtlC.AnyVar(IgnoreUppercase, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarBool(ret) END CheckSpelling; PROCEDURE (this: _Application) ClipboardFormats* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 321, arg, ret); RETURN CtlC.VarAny(ret) END ClipboardFormats; PROCEDURE (this: _Application) DisplayClipboardWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 322) END DisplayClipboardWindow; PROCEDURE (this: _Application) PUTDisplayClipboardWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 322, p1) END PUTDisplayClipboardWindow; PROCEDURE (this: _Application) ColorButtons* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 365) END ColorButtons; PROCEDURE (this: _Application) PUTColorButtons* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 365, p1) END PUTColorButtons; PROCEDURE (this: _Application) CommandUnderlines* (): XlCommandUnderlines, NEW; BEGIN RETURN CtlC.GetInt(this, 323) END CommandUnderlines; PROCEDURE (this: _Application) PUTCommandUnderlines* (p1: XlCommandUnderlines), NEW; BEGIN CtlC.PutInt(this, 323, p1) END PUTCommandUnderlines; PROCEDURE (this: _Application) ConstrainNumeric* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 324) END ConstrainNumeric; PROCEDURE (this: _Application) PUTConstrainNumeric* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 324, p1) END PUTConstrainNumeric; PROCEDURE (this: _Application) ConvertFormula* (Formula: CtlT.Any; FromReferenceStyle: XlReferenceStyle; (* optional *) ToReferenceStyle: CtlT.Any; ToAbsolute: CtlT.Any; RelativeTo: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Formula, arg[4]); CtlC.IntVar(FromReferenceStyle, arg[3]); CtlC.AnyVar(ToReferenceStyle, arg[2]); CtlC.AnyVar(ToAbsolute, arg[1]); CtlC.AnyVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 325, arg, ret); RETURN CtlC.VarAny(ret) END ConvertFormula; PROCEDURE (this: _Application) CopyObjectsWithCells* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 991) END CopyObjectsWithCells; PROCEDURE (this: _Application) PUTCopyObjectsWithCells* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 991, p1) END PUTCopyObjectsWithCells; PROCEDURE (this: _Application) Cursor* (): XlMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, 1161) END Cursor; PROCEDURE (this: _Application) PUTCursor* (p1: XlMousePointer), NEW; BEGIN CtlC.PutInt(this, 1161, p1) END PUTCursor; PROCEDURE (this: _Application) CustomListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 787) END CustomListCount; PROCEDURE (this: _Application) CutCopyMode* (): XlCutCopyMode, NEW; BEGIN RETURN CtlC.GetInt(this, 330) END CutCopyMode; PROCEDURE (this: _Application) PUTCutCopyMode* (p1: XlCutCopyMode), NEW; BEGIN CtlC.PutInt(this, 330, p1) END PUTCutCopyMode; PROCEDURE (this: _Application) DataEntryMode* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 331) END DataEntryMode; PROCEDURE (this: _Application) PUTDataEntryMode* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 331, p1) END PUTDataEntryMode; PROCEDURE (this: _Application) Dummy1* (), NEW; BEGIN CtlC.CallMethod(this, 1782, NIL); END Dummy1; PROCEDURE (this: _Application) Dummy2* (), NEW; BEGIN CtlC.CallMethod(this, 1783, NIL); END Dummy2; PROCEDURE (this: _Application) Dummy3* (), NEW; BEGIN CtlC.CallMethod(this, 1784, NIL); END Dummy3; PROCEDURE (this: _Application) Dummy4* (), NEW; BEGIN CtlC.CallMethod(this, 1785, NIL); END Dummy4; PROCEDURE (this: _Application) Dummy5* (), NEW; BEGIN CtlC.CallMethod(this, 1786, NIL); END Dummy5; PROCEDURE (this: _Application) Dummy6* (), NEW; BEGIN CtlC.CallMethod(this, 1787, NIL); END Dummy6; PROCEDURE (this: _Application) Dummy7* (), NEW; BEGIN CtlC.CallMethod(this, 1788, NIL); END Dummy7; PROCEDURE (this: _Application) Dummy8* (), NEW; BEGIN CtlC.CallMethod(this, 1789, NIL); END Dummy8; PROCEDURE (this: _Application) Dummy9* (), NEW; BEGIN CtlC.CallMethod(this, 1790, NIL); END Dummy9; PROCEDURE (this: _Application) Dummy10* (), NEW; BEGIN CtlC.CallMethod(this, 1791, NIL); END Dummy10; PROCEDURE (this: _Application) Dummy11* (), NEW; BEGIN CtlC.CallMethod(this, 1792, NIL); END Dummy11; PROCEDURE (this: _Application) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: _Application) DefaultFilePath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1038) END DefaultFilePath; PROCEDURE (this: _Application) PUTDefaultFilePath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1038, p1) END PUTDefaultFilePath; PROCEDURE (this: _Application) DeleteChartAutoFormat* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 217, arg, NIL); END DeleteChartAutoFormat; PROCEDURE (this: _Application) DeleteCustomList* (ListNum: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ListNum, arg[0]); CtlC.CallParMethod(this, 783, arg, NIL); END DeleteCustomList; PROCEDURE (this: _Application) Dialogs* (): Dialogs, NEW; BEGIN RETURN ThisDialogs(CtlC.GetAny(this, 761)) END Dialogs; PROCEDURE (this: _Application) DisplayAlerts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 343) END DisplayAlerts; PROCEDURE (this: _Application) PUTDisplayAlerts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 343, p1) END PUTDisplayAlerts; PROCEDURE (this: _Application) DisplayFormulaBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 344) END DisplayFormulaBar; PROCEDURE (this: _Application) PUTDisplayFormulaBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 344, p1) END PUTDisplayFormulaBar; PROCEDURE (this: _Application) DisplayFullScreen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1061) END DisplayFullScreen; PROCEDURE (this: _Application) PUTDisplayFullScreen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1061, p1) END PUTDisplayFullScreen; PROCEDURE (this: _Application) DisplayNoteIndicator* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 345) END DisplayNoteIndicator; PROCEDURE (this: _Application) PUTDisplayNoteIndicator* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 345, p1) END PUTDisplayNoteIndicator; PROCEDURE (this: _Application) DisplayCommentIndicator* (): XlCommentDisplayMode, NEW; BEGIN RETURN CtlC.GetInt(this, 1196) END DisplayCommentIndicator; PROCEDURE (this: _Application) PUTDisplayCommentIndicator* (p1: XlCommentDisplayMode), NEW; BEGIN CtlC.PutInt(this, 1196, p1) END PUTDisplayCommentIndicator; PROCEDURE (this: _Application) DisplayExcel4Menus* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 927) END DisplayExcel4Menus; PROCEDURE (this: _Application) PUTDisplayExcel4Menus* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 927, p1) END PUTDisplayExcel4Menus; PROCEDURE (this: _Application) DisplayRecentFiles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 926) END DisplayRecentFiles; PROCEDURE (this: _Application) PUTDisplayRecentFiles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 926, p1) END PUTDisplayRecentFiles; PROCEDURE (this: _Application) DisplayScrollBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 346) END DisplayScrollBars; PROCEDURE (this: _Application) PUTDisplayScrollBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 346, p1) END PUTDisplayScrollBars; PROCEDURE (this: _Application) DisplayStatusBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 347) END DisplayStatusBar; PROCEDURE (this: _Application) PUTDisplayStatusBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 347, p1) END PUTDisplayStatusBar; PROCEDURE (this: _Application) DoubleClick* (), NEW; BEGIN CtlC.CallMethod(this, 349, NIL); END DoubleClick; PROCEDURE (this: _Application) EditDirectlyInCell* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 929) END EditDirectlyInCell; PROCEDURE (this: _Application) PUTEditDirectlyInCell* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 929, p1) END PUTEditDirectlyInCell; PROCEDURE (this: _Application) EnableAutoComplete* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1179) END EnableAutoComplete; PROCEDURE (this: _Application) PUTEnableAutoComplete* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1179, p1) END PUTEnableAutoComplete; PROCEDURE (this: _Application) EnableCancelKey* (): XlEnableCancelKey, NEW; BEGIN RETURN CtlC.GetInt(this, 1096) END EnableCancelKey; PROCEDURE (this: _Application) PUTEnableCancelKey* (p1: XlEnableCancelKey), NEW; BEGIN CtlC.PutInt(this, 1096, p1) END PUTEnableCancelKey; PROCEDURE (this: _Application) EnableSound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1197) END EnableSound; PROCEDURE (this: _Application) PUTEnableSound* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1197, p1) END PUTEnableSound; PROCEDURE (this: _Application) EnableTipWizard* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1064) END EnableTipWizard; PROCEDURE (this: _Application) PUTEnableTipWizard* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1064, p1) END PUTEnableTipWizard; PROCEDURE (this: _Application) FileConverters* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallGetMethod(this, 931, arg, ret); RETURN CtlC.VarAny(ret) END FileConverters; PROCEDURE (this: _Application) FileSearch* (): CtlOffice.FileSearch, NEW; BEGIN RETURN CtlOffice.ThisFileSearch(CtlC.GetAny(this, 1200)) END FileSearch; PROCEDURE (this: _Application) FileFind* (): CtlOffice.IFind, NEW; BEGIN RETURN CtlOffice.ThisIFind(CtlC.GetAny(this, 1201)) END FileFind; PROCEDURE (this: _Application) _FindFile* (), NEW; BEGIN CtlC.CallMethod(this, 1068, NIL); END _FindFile; PROCEDURE (this: _Application) FixedDecimal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 351) END FixedDecimal; PROCEDURE (this: _Application) PUTFixedDecimal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 351, p1) END PUTFixedDecimal; PROCEDURE (this: _Application) FixedDecimalPlaces* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 352) END FixedDecimalPlaces; PROCEDURE (this: _Application) PUTFixedDecimalPlaces* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 352, p1) END PUTFixedDecimalPlaces; PROCEDURE (this: _Application) GetCustomListContents* (ListNum: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ListNum, arg[0]); CtlC.CallParMethod(this, 786, arg, ret); RETURN CtlC.VarAny(ret) END GetCustomListContents; PROCEDURE (this: _Application) GetCustomListNum* (ListArray: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ListArray, arg[0]); CtlC.CallParMethod(this, 785, arg, ret); RETURN CtlC.VarInt(ret) END GetCustomListNum; PROCEDURE (this: _Application) GetOpenFilename* ((* optional *) FileFilter: CtlT.Any; FilterIndex: CtlT.Any; Title: CtlT.Any; ButtonText: CtlT.Any; MultiSelect: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FileFilter, arg[4]); CtlC.AnyVar(FilterIndex, arg[3]); CtlC.AnyVar(Title, arg[2]); CtlC.AnyVar(ButtonText, arg[1]); CtlC.AnyVar(MultiSelect, arg[0]); CtlC.CallParMethod(this, 1075, arg, ret); RETURN CtlC.VarAny(ret) END GetOpenFilename; PROCEDURE (this: _Application) GetSaveAsFilename* ((* optional *) InitialFilename: CtlT.Any; FileFilter: CtlT.Any; FilterIndex: CtlT.Any; Title: CtlT.Any; ButtonText: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(InitialFilename, arg[4]); CtlC.AnyVar(FileFilter, arg[3]); CtlC.AnyVar(FilterIndex, arg[2]); CtlC.AnyVar(Title, arg[1]); CtlC.AnyVar(ButtonText, arg[0]); CtlC.CallParMethod(this, 1076, arg, ret); RETURN CtlC.VarAny(ret) END GetSaveAsFilename; PROCEDURE (this: _Application) Goto* ((* optional *) Reference: CtlT.Any; Scroll: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Reference, arg[1]); CtlC.AnyVar(Scroll, arg[0]); CtlC.CallParMethod(this, 475, arg, NIL); END Goto; PROCEDURE (this: _Application) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: _Application) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: _Application) Help* ((* optional *) HelpFile: CtlT.Any; HelpContextID: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(HelpFile, arg[1]); CtlC.AnyVar(HelpContextID, arg[0]); CtlC.CallParMethod(this, 354, arg, NIL); END Help; PROCEDURE (this: _Application) IgnoreRemoteRequests* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 356) END IgnoreRemoteRequests; PROCEDURE (this: _Application) PUTIgnoreRemoteRequests* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 356, p1) END PUTIgnoreRemoteRequests; PROCEDURE (this: _Application) InchesToPoints* (Inches: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Inches, arg[0]); CtlC.CallParMethod(this, 1087, arg, ret); RETURN CtlC.VarReal(ret) END InchesToPoints; PROCEDURE (this: _Application) InputBox* (Prompt: ARRAY OF CHAR; (* optional *) Title: CtlT.Any; Default: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; HelpFile: CtlT.Any; HelpContextID: CtlT.Any; Type: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Prompt, arg[7]); CtlC.AnyVar(Title, arg[6]); CtlC.AnyVar(Default, arg[5]); CtlC.AnyVar(Left, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(HelpFile, arg[2]); CtlC.AnyVar(HelpContextID, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 357, arg, ret); RETURN CtlC.VarAny(ret) END InputBox; PROCEDURE (this: _Application) Interactive* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 361) END Interactive; PROCEDURE (this: _Application) PUTInteractive* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 361, p1) END PUTInteractive; PROCEDURE (this: _Application) International* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 362, arg, ret); RETURN CtlC.VarAny(ret) END International; PROCEDURE (this: _Application) Iteration* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 363) END Iteration; PROCEDURE (this: _Application) PUTIteration* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 363, p1) END PUTIteration; PROCEDURE (this: _Application) LargeButtons* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 364) END LargeButtons; PROCEDURE (this: _Application) PUTLargeButtons* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 364, p1) END PUTLargeButtons; PROCEDURE (this: _Application) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: _Application) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: _Application) LibraryPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 366) END LibraryPath; PROCEDURE (this: _Application) MacroOptions* ((* optional *) Macro: CtlT.Any; Description: CtlT.Any; HasMenu: CtlT.Any; MenuText: CtlT.Any; HasShortcutKey: CtlT.Any; ShortcutKey: CtlT.Any; Category: CtlT.Any; StatusBar: CtlT.Any; HelpContextID: CtlT.Any; HelpFile: CtlT.Any), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.AnyVar(Macro, arg[9]); CtlC.AnyVar(Description, arg[8]); CtlC.AnyVar(HasMenu, arg[7]); CtlC.AnyVar(MenuText, arg[6]); CtlC.AnyVar(HasShortcutKey, arg[5]); CtlC.AnyVar(ShortcutKey, arg[4]); CtlC.AnyVar(Category, arg[3]); CtlC.AnyVar(StatusBar, arg[2]); CtlC.AnyVar(HelpContextID, arg[1]); CtlC.AnyVar(HelpFile, arg[0]); CtlC.CallParMethod(this, 1135, arg, NIL); END MacroOptions; PROCEDURE (this: _Application) MailLogoff* (), NEW; BEGIN CtlC.CallMethod(this, 945, NIL); END MailLogoff; PROCEDURE (this: _Application) MailLogon* ((* optional *) Name: CtlT.Any; Password: CtlT.Any; DownloadNewMail: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[2]); CtlC.AnyVar(Password, arg[1]); CtlC.AnyVar(DownloadNewMail, arg[0]); CtlC.CallParMethod(this, 943, arg, NIL); END MailLogon; PROCEDURE (this: _Application) MailSession* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 942) END MailSession; PROCEDURE (this: _Application) MailSystem* (): XlMailSystem, NEW; BEGIN RETURN CtlC.GetInt(this, 971) END MailSystem; PROCEDURE (this: _Application) MathCoprocessorAvailable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 367) END MathCoprocessorAvailable; PROCEDURE (this: _Application) MaxChange* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 368) END MaxChange; PROCEDURE (this: _Application) PUTMaxChange* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 368, p1) END PUTMaxChange; PROCEDURE (this: _Application) MaxIterations* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 369) END MaxIterations; PROCEDURE (this: _Application) PUTMaxIterations* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 369, p1) END PUTMaxIterations; PROCEDURE (this: _Application) MemoryFree* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 370) END MemoryFree; PROCEDURE (this: _Application) MemoryTotal* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 371) END MemoryTotal; PROCEDURE (this: _Application) MemoryUsed* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 372) END MemoryUsed; PROCEDURE (this: _Application) MouseAvailable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 373) END MouseAvailable; PROCEDURE (this: _Application) MoveAfterReturn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 374) END MoveAfterReturn; PROCEDURE (this: _Application) PUTMoveAfterReturn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 374, p1) END PUTMoveAfterReturn; PROCEDURE (this: _Application) MoveAfterReturnDirection* (): XlDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 1144) END MoveAfterReturnDirection; PROCEDURE (this: _Application) PUTMoveAfterReturnDirection* (p1: XlDirection), NEW; BEGIN CtlC.PutInt(this, 1144, p1) END PUTMoveAfterReturnDirection; PROCEDURE (this: _Application) RecentFiles* (): RecentFiles, NEW; BEGIN RETURN ThisRecentFiles(CtlC.GetAny(this, 1202)) END RecentFiles; PROCEDURE (this: _Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: _Application) NextLetter* (): Workbook, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 972, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END NextLetter; PROCEDURE (this: _Application) NetworkTemplatesPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 388) END NetworkTemplatesPath; PROCEDURE (this: _Application) ODBCErrors* (): ODBCErrors, NEW; BEGIN RETURN ThisODBCErrors(CtlC.GetAny(this, 1203)) END ODBCErrors; PROCEDURE (this: _Application) ODBCTimeout* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1204) END ODBCTimeout; PROCEDURE (this: _Application) PUTODBCTimeout* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1204, p1) END PUTODBCTimeout; PROCEDURE (this: _Application) OnCalculate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 625) END OnCalculate; PROCEDURE (this: _Application) PUTOnCalculate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 625, p1) END PUTOnCalculate; PROCEDURE (this: _Application) OnData* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 629) END OnData; PROCEDURE (this: _Application) PUTOnData* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 629, p1) END PUTOnData; PROCEDURE (this: _Application) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 628) END OnDoubleClick; PROCEDURE (this: _Application) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 628, p1) END PUTOnDoubleClick; PROCEDURE (this: _Application) OnEntry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 627) END OnEntry; PROCEDURE (this: _Application) PUTOnEntry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 627, p1) END PUTOnEntry; PROCEDURE (this: _Application) OnKey* (Key: ARRAY OF CHAR; (* optional *) Procedure: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Key, arg[1]); CtlC.AnyVar(Procedure, arg[0]); CtlC.CallParMethod(this, 626, arg, NIL); END OnKey; PROCEDURE (this: _Application) OnRepeat* (Text: ARRAY OF CHAR; Procedure: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.StrVar(Procedure, arg[0]); CtlC.CallParMethod(this, 769, arg, NIL); END OnRepeat; PROCEDURE (this: _Application) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: _Application) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: _Application) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: _Application) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: _Application) OnTime* (EarliestTime: CtlT.Any; Procedure: ARRAY OF CHAR; (* optional *) LatestTime: CtlT.Any; Schedule: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(EarliestTime, arg[3]); CtlC.StrVar(Procedure, arg[2]); CtlC.AnyVar(LatestTime, arg[1]); CtlC.AnyVar(Schedule, arg[0]); CtlC.CallParMethod(this, 624, arg, NIL); END OnTime; PROCEDURE (this: _Application) OnUndo* (Text: ARRAY OF CHAR; Procedure: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.StrVar(Procedure, arg[0]); CtlC.CallParMethod(this, 770, arg, NIL); END OnUndo; PROCEDURE (this: _Application) OnWindow* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 623) END OnWindow; PROCEDURE (this: _Application) PUTOnWindow* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 623, p1) END PUTOnWindow; PROCEDURE (this: _Application) OperatingSystem* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 375) END OperatingSystem; PROCEDURE (this: _Application) OrganizationName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 376) END OrganizationName; PROCEDURE (this: _Application) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 291) END Path; PROCEDURE (this: _Application) PathSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 377) END PathSeparator; PROCEDURE (this: _Application) PreviousSelections* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 378, arg, ret); RETURN CtlC.VarAny(ret) END PreviousSelections; PROCEDURE (this: _Application) PivotTableSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1205) END PivotTableSelection; PROCEDURE (this: _Application) PUTPivotTableSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1205, p1) END PUTPivotTableSelection; PROCEDURE (this: _Application) PromptForSummaryInfo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1062) END PromptForSummaryInfo; PROCEDURE (this: _Application) PUTPromptForSummaryInfo* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1062, p1) END PUTPromptForSummaryInfo; PROCEDURE (this: _Application) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END Quit; PROCEDURE (this: _Application) RecordMacro* ((* optional *) BasicCode: CtlT.Any; XlmCode: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(BasicCode, arg[1]); CtlC.AnyVar(XlmCode, arg[0]); CtlC.CallParMethod(this, 773, arg, NIL); END RecordMacro; PROCEDURE (this: _Application) RecordRelative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 379) END RecordRelative; PROCEDURE (this: _Application) ReferenceStyle* (): XlReferenceStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 380) END ReferenceStyle; PROCEDURE (this: _Application) PUTReferenceStyle* (p1: XlReferenceStyle), NEW; BEGIN CtlC.PutInt(this, 380, p1) END PUTReferenceStyle; PROCEDURE (this: _Application) RegisteredFunctions* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallGetMethod(this, 775, arg, ret); RETURN CtlC.VarAny(ret) END RegisteredFunctions; PROCEDURE (this: _Application) RegisterXLL* (Filename: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[0]); CtlC.CallParMethod(this, 30, arg, ret); RETURN CtlC.VarBool(ret) END RegisterXLL; PROCEDURE (this: _Application) Repeat* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END Repeat; PROCEDURE (this: _Application) ResetTipWizard* (), NEW; BEGIN CtlC.CallMethod(this, 928, NIL); END ResetTipWizard; PROCEDURE (this: _Application) RollZoom* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1206) END RollZoom; PROCEDURE (this: _Application) PUTRollZoom* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1206, p1) END PUTRollZoom; PROCEDURE (this: _Application) Save* ((* optional *) Filename: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[0]); CtlC.CallParMethod(this, 283, arg, NIL); END Save; PROCEDURE (this: _Application) SaveWorkspace* ((* optional *) Filename: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[0]); CtlC.CallParMethod(this, 212, arg, NIL); END SaveWorkspace; PROCEDURE (this: _Application) ScreenUpdating* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 382) END ScreenUpdating; PROCEDURE (this: _Application) PUTScreenUpdating* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 382, p1) END PUTScreenUpdating; PROCEDURE (this: _Application) SetDefaultChart* ((* optional *) FormatName: CtlT.Any; Gallery: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FormatName, arg[1]); CtlC.AnyVar(Gallery, arg[0]); CtlC.CallParMethod(this, 219, arg, NIL); END SetDefaultChart; PROCEDURE (this: _Application) SheetsInNewWorkbook* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 993) END SheetsInNewWorkbook; PROCEDURE (this: _Application) PUTSheetsInNewWorkbook* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 993, p1) END PUTSheetsInNewWorkbook; PROCEDURE (this: _Application) ShowChartTipNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1207) END ShowChartTipNames; PROCEDURE (this: _Application) PUTShowChartTipNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1207, p1) END PUTShowChartTipNames; PROCEDURE (this: _Application) ShowChartTipValues* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1208) END ShowChartTipValues; PROCEDURE (this: _Application) PUTShowChartTipValues* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1208, p1) END PUTShowChartTipValues; PROCEDURE (this: _Application) StandardFont* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 924) END StandardFont; PROCEDURE (this: _Application) PUTStandardFont* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 924, p1) END PUTStandardFont; PROCEDURE (this: _Application) StandardFontSize* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 925) END StandardFontSize; PROCEDURE (this: _Application) PUTStandardFontSize* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 925, p1) END PUTStandardFontSize; PROCEDURE (this: _Application) StartupPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 385) END StartupPath; PROCEDURE (this: _Application) StatusBar* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 386) END StatusBar; PROCEDURE (this: _Application) PUTStatusBar* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 386, p1) END PUTStatusBar; PROCEDURE (this: _Application) TemplatesPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 381) END TemplatesPath; PROCEDURE (this: _Application) ShowToolTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 387) END ShowToolTips; PROCEDURE (this: _Application) PUTShowToolTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 387, p1) END PUTShowToolTips; PROCEDURE (this: _Application) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: _Application) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: _Application) DefaultSaveFormat* (): XlFileFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 1209) END DefaultSaveFormat; PROCEDURE (this: _Application) PUTDefaultSaveFormat* (p1: XlFileFormat), NEW; BEGIN CtlC.PutInt(this, 1209, p1) END PUTDefaultSaveFormat; PROCEDURE (this: _Application) TransitionMenuKey* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 310) END TransitionMenuKey; PROCEDURE (this: _Application) PUTTransitionMenuKey* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 310, p1) END PUTTransitionMenuKey; PROCEDURE (this: _Application) TransitionMenuKeyAction* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 311) END TransitionMenuKeyAction; PROCEDURE (this: _Application) PUTTransitionMenuKeyAction* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 311, p1) END PUTTransitionMenuKeyAction; PROCEDURE (this: _Application) TransitionNavigKeys* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 312) END TransitionNavigKeys; PROCEDURE (this: _Application) PUTTransitionNavigKeys* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 312, p1) END PUTTransitionNavigKeys; PROCEDURE (this: _Application) Undo* (), NEW; BEGIN CtlC.CallMethod(this, 303, NIL); END Undo; PROCEDURE (this: _Application) UsableHeight* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 389) END UsableHeight; PROCEDURE (this: _Application) UsableWidth* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 390) END UsableWidth; PROCEDURE (this: _Application) UserControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1210) END UserControl; PROCEDURE (this: _Application) PUTUserControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1210, p1) END PUTUserControl; PROCEDURE (this: _Application) UserName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 391) END UserName; PROCEDURE (this: _Application) PUTUserName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 391, p1) END PUTUserName; PROCEDURE (this: _Application) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: _Application) VBE* (): CtlVBIDE.VBE, NEW; BEGIN RETURN CtlVBIDE.ThisVBE(CtlC.GetAny(this, 1211)) END VBE; PROCEDURE (this: _Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 392) END Version; PROCEDURE (this: _Application) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: _Application) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: _Application) Volatile* ((* optional *) Volatile: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Volatile, arg[0]); CtlC.CallParMethod(this, 788, arg, NIL); END Volatile; PROCEDURE (this: _Application) _Wait* (Time: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Time, arg[0]); CtlC.CallParMethod(this, 393, arg, NIL); END _Wait; PROCEDURE (this: _Application) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: _Application) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: _Application) WindowsForPens* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 395) END WindowsForPens; PROCEDURE (this: _Application) WindowState* (): XlWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 396) END WindowState; PROCEDURE (this: _Application) PUTWindowState* (p1: XlWindowState), NEW; BEGIN CtlC.PutInt(this, 396, p1) END PUTWindowState; PROCEDURE (this: _Application) UILanguage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END UILanguage; PROCEDURE (this: _Application) PUTUILanguage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTUILanguage; PROCEDURE (this: _Application) DefaultSheetDirection* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 229) END DefaultSheetDirection; PROCEDURE (this: _Application) PUTDefaultSheetDirection* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 229, p1) END PUTDefaultSheetDirection; PROCEDURE (this: _Application) CursorMovement* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 232) END CursorMovement; PROCEDURE (this: _Application) PUTCursorMovement* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 232, p1) END PUTCursorMovement; PROCEDURE (this: _Application) ControlCharacters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 233) END ControlCharacters; PROCEDURE (this: _Application) PUTControlCharacters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 233, p1) END PUTControlCharacters; PROCEDURE (this: _Application) _WSFunction* ((* optional *) Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 169, arg, ret); RETURN CtlC.VarAny(ret) END _WSFunction; PROCEDURE (this: _Application) EnableEvents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1212) END EnableEvents; PROCEDURE (this: _Application) PUTEnableEvents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1212, p1) END PUTEnableEvents; PROCEDURE (this: _Application) DisplayInfoWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1213) END DisplayInfoWindow; PROCEDURE (this: _Application) PUTDisplayInfoWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1213, p1) END PUTDisplayInfoWindow; PROCEDURE (this: _Application) Wait* (Time: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Time, arg[0]); CtlC.CallParMethod(this, 1770, arg, ret); RETURN CtlC.VarBool(ret) END Wait; PROCEDURE (this: _Application) ExtendList* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1793) END ExtendList; PROCEDURE (this: _Application) PUTExtendList* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1793, p1) END PUTExtendList; PROCEDURE (this: _Application) OLEDBErrors* (): OLEDBErrors, NEW; BEGIN RETURN ThisOLEDBErrors(CtlC.GetAny(this, 1794)) END OLEDBErrors; PROCEDURE (this: _Application) GetPhonetic* ((* optional *) Text: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[0]); CtlC.CallParMethod(this, 1795, arg, ret); RETURN CtlC.VarStr(ret) END GetPhonetic; PROCEDURE (this: _Application) COMAddIns* (): CtlOffice.COMAddIns, NEW; BEGIN RETURN CtlOffice.ThisCOMAddIns(CtlC.GetAny(this, 1796)) END COMAddIns; PROCEDURE (this: _Application) DefaultWebOptions* (): DefaultWebOptions, NEW; BEGIN RETURN ThisDefaultWebOptions(CtlC.GetAny(this, 1797)) END DefaultWebOptions; PROCEDURE (this: _Application) ProductCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1798) END ProductCode; PROCEDURE (this: _Application) UserLibraryPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1799) END UserLibraryPath; PROCEDURE (this: _Application) AutoPercentEntry* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1800) END AutoPercentEntry; PROCEDURE (this: _Application) PUTAutoPercentEntry* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1800, p1) END PUTAutoPercentEntry; PROCEDURE (this: _Application) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 1801)) END LanguageSettings; PROCEDURE (this: _Application) Dummy101* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1802) END Dummy101; PROCEDURE (this: _Application) Dummy12* (), NEW; BEGIN CtlC.CallMethod(this, 1803, NIL); END Dummy12; PROCEDURE (this: _Application) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 1804)) END AnswerWizard; PROCEDURE (this: _Application) CalculateFull* (), NEW; BEGIN CtlC.CallMethod(this, 1805, NIL); END CalculateFull; PROCEDURE (this: _Application) FindFile* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1771, ret); RETURN CtlC.VarBool(ret) END FindFile; PROCEDURE (this: _Application) CalculationVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1806) END CalculationVersion; PROCEDURE (this: _Application) ShowWindowsInTaskbar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1807) END ShowWindowsInTaskbar; PROCEDURE (this: _Application) PUTShowWindowsInTaskbar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1807, p1) END PUTShowWindowsInTaskbar; PROCEDURE (this: _Application) FeatureInstall* (): CtlOffice.MsoFeatureInstall, NEW; BEGIN RETURN CtlC.GetInt(this, 1808) END FeatureInstall; PROCEDURE (this: _Application) PUTFeatureInstall* (p1: CtlOffice.MsoFeatureInstall), NEW; BEGIN CtlC.PutInt(this, 1808, p1) END PUTFeatureInstall; (* ---------- _Chart, dual, nonextensible ---------- *) PROCEDURE (this: _Chart) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Chart) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Chart) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: _Chart) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: _Chart) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: _Chart) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: _Chart) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1373) END CodeName; PROCEDURE (this: _Chart) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: _Chart) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: _Chart) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: _Chart) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: _Chart) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: _Chart) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: _Chart) Next* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 502) END Next; PROCEDURE (this: _Chart) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 628) END OnDoubleClick; PROCEDURE (this: _Chart) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 628, p1) END PUTOnDoubleClick; PROCEDURE (this: _Chart) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: _Chart) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: _Chart) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: _Chart) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: _Chart) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 998)) END PageSetup; PROCEDURE (this: _Chart) Previous* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 503) END Previous; PROCEDURE (this: _Chart) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: _Chart) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: _Chart) Protect* ((* optional *) Password: CtlT.Any; DrawingObjects: CtlT.Any; Contents: CtlT.Any; Scenarios: CtlT.Any; UserInterfaceOnly: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[4]); CtlC.AnyVar(DrawingObjects, arg[3]); CtlC.AnyVar(Contents, arg[2]); CtlC.AnyVar(Scenarios, arg[1]); CtlC.AnyVar(UserInterfaceOnly, arg[0]); CtlC.CallParMethod(this, 282, arg, NIL); END Protect; PROCEDURE (this: _Chart) ProtectContents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 292) END ProtectContents; PROCEDURE (this: _Chart) ProtectDrawingObjects* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 293) END ProtectDrawingObjects; PROCEDURE (this: _Chart) ProtectionMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1159) END ProtectionMode; PROCEDURE (this: _Chart) SaveAs* (Filename: ARRAY OF CHAR; (* optional *) FileFormat: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; AddToMru: CtlT.Any; TextCodepage: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[8]); CtlC.AnyVar(FileFormat, arg[7]); CtlC.AnyVar(Password, arg[6]); CtlC.AnyVar(WriteResPassword, arg[5]); CtlC.AnyVar(ReadOnlyRecommended, arg[4]); CtlC.AnyVar(CreateBackup, arg[3]); CtlC.AnyVar(AddToMru, arg[2]); CtlC.AnyVar(TextCodepage, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: _Chart) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: _Chart) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 285, arg, NIL); END Unprotect; PROCEDURE (this: _Chart) Visible* (): XlSheetVisibility, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: _Chart) PUTVisible* (p1: XlSheetVisibility), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: _Chart) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 1377)) END Shapes; PROCEDURE (this: _Chart) ApplyDataLabels* (Type: XlDataLabelsType; (* optional *) LegendKey: CtlT.Any; AutoText: CtlT.Any; HasLeaderLines: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(LegendKey, arg[2]); CtlC.AnyVar(AutoText, arg[1]); CtlC.AnyVar(HasLeaderLines, arg[0]); CtlC.CallParMethod(this, 151, arg, NIL); END ApplyDataLabels; PROCEDURE (this: _Chart) Arcs* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 760, arg, ret); RETURN CtlC.VarObj(ret) END Arcs; PROCEDURE (this: _Chart) Area3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 17)) END Area3DGroup; PROCEDURE (this: _Chart) AreaGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 9, arg, ret); RETURN CtlC.VarObj(ret) END AreaGroups; PROCEDURE (this: _Chart) AutoFormat* (Gallery: INTEGER; (* optional *) Format: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Gallery, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 114, arg, NIL); END AutoFormat; PROCEDURE (this: _Chart) AutoScaling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 107) END AutoScaling; PROCEDURE (this: _Chart) PUTAutoScaling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 107, p1) END PUTAutoScaling; PROCEDURE (this: _Chart) Axes* (Type: CtlT.Any; AxisGroup: XlAxisGroup): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[1]); CtlC.IntVar(AxisGroup, arg[0]); CtlC.CallParMethod(this, 23, arg, ret); RETURN CtlC.VarObj(ret) END Axes; PROCEDURE (this: _Chart) SetBackgroundPicture* (Filename: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[0]); CtlC.CallParMethod(this, 1188, arg, NIL); END SetBackgroundPicture; PROCEDURE (this: _Chart) Bar3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 18)) END Bar3DGroup; PROCEDURE (this: _Chart) BarGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN CtlC.VarObj(ret) END BarGroups; PROCEDURE (this: _Chart) Buttons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 557, arg, ret); RETURN CtlC.VarObj(ret) END Buttons; PROCEDURE (this: _Chart) ChartArea* (): ChartArea, NEW; BEGIN RETURN ThisChartArea(CtlC.GetAny(this, 80)) END ChartArea; PROCEDURE (this: _Chart) ChartGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 8, arg, ret); RETURN CtlC.VarObj(ret) END ChartGroups; PROCEDURE (this: _Chart) ChartObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1060, arg, ret); RETURN CtlC.VarObj(ret) END ChartObjects; PROCEDURE (this: _Chart) ChartTitle* (): ChartTitle, NEW; BEGIN RETURN ThisChartTitle(CtlC.GetAny(this, 81)) END ChartTitle; PROCEDURE (this: _Chart) ChartWizard* ((* optional *) Source: CtlT.Any; Gallery: CtlT.Any; Format: CtlT.Any; PlotBy: CtlT.Any; CategoryLabels: CtlT.Any; SeriesLabels: CtlT.Any; HasLegend: CtlT.Any; Title: CtlT.Any; CategoryTitle: CtlT.Any; ValueTitle: CtlT.Any; ExtraTitle: CtlT.Any), NEW; VAR arg: ARRAY 11 OF CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[10]); CtlC.AnyVar(Gallery, arg[9]); CtlC.AnyVar(Format, arg[8]); CtlC.AnyVar(PlotBy, arg[7]); CtlC.AnyVar(CategoryLabels, arg[6]); CtlC.AnyVar(SeriesLabels, arg[5]); CtlC.AnyVar(HasLegend, arg[4]); CtlC.AnyVar(Title, arg[3]); CtlC.AnyVar(CategoryTitle, arg[2]); CtlC.AnyVar(ValueTitle, arg[1]); CtlC.AnyVar(ExtraTitle, arg[0]); CtlC.CallParMethod(this, 196, arg, NIL); END ChartWizard; PROCEDURE (this: _Chart) CheckBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 824, arg, ret); RETURN CtlC.VarObj(ret) END CheckBoxes; PROCEDURE (this: _Chart) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, NIL); END CheckSpelling; PROCEDURE (this: _Chart) Column3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 19)) END Column3DGroup; PROCEDURE (this: _Chart) ColumnGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN CtlC.VarObj(ret) END ColumnGroups; PROCEDURE (this: _Chart) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat; Size: XlPictureAppearance), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[2]); CtlC.IntVar(Format, arg[1]); CtlC.IntVar(Size, arg[0]); CtlC.CallParMethod(this, 213, arg, NIL); END CopyPicture; PROCEDURE (this: _Chart) Corners* (): Corners, NEW; BEGIN RETURN ThisCorners(CtlC.GetAny(this, 79)) END Corners; PROCEDURE (this: _Chart) CreatePublisher* (Edition: CtlT.Any; Appearance: XlPictureAppearance; Size: XlPictureAppearance; (* optional *) ContainsPICT: CtlT.Any; ContainsBIFF: CtlT.Any; ContainsRTF: CtlT.Any; ContainsVALU: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(Edition, arg[6]); CtlC.IntVar(Appearance, arg[5]); CtlC.IntVar(Size, arg[4]); CtlC.AnyVar(ContainsPICT, arg[3]); CtlC.AnyVar(ContainsBIFF, arg[2]); CtlC.AnyVar(ContainsRTF, arg[1]); CtlC.AnyVar(ContainsVALU, arg[0]); CtlC.CallParMethod(this, 458, arg, NIL); END CreatePublisher; PROCEDURE (this: _Chart) DataTable* (): DataTable, NEW; BEGIN RETURN ThisDataTable(CtlC.GetAny(this, 1395)) END DataTable; PROCEDURE (this: _Chart) DepthPercent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 48) END DepthPercent; PROCEDURE (this: _Chart) PUTDepthPercent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 48, p1) END PUTDepthPercent; PROCEDURE (this: _Chart) Deselect* (), NEW; BEGIN CtlC.CallMethod(this, 1120, NIL); END Deselect; PROCEDURE (this: _Chart) DisplayBlanksAs* (): XlDisplayBlanksAs, NEW; BEGIN RETURN CtlC.GetInt(this, 93) END DisplayBlanksAs; PROCEDURE (this: _Chart) PUTDisplayBlanksAs* (p1: XlDisplayBlanksAs), NEW; BEGIN CtlC.PutInt(this, 93, p1) END PUTDisplayBlanksAs; PROCEDURE (this: _Chart) DoughnutGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN CtlC.VarObj(ret) END DoughnutGroups; PROCEDURE (this: _Chart) Drawings* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 772, arg, ret); RETURN CtlC.VarObj(ret) END Drawings; PROCEDURE (this: _Chart) DrawingObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 88, arg, ret); RETURN CtlC.VarObj(ret) END DrawingObjects; PROCEDURE (this: _Chart) DropDowns* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 836, arg, ret); RETURN CtlC.VarObj(ret) END DropDowns; PROCEDURE (this: _Chart) Elevation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 49) END Elevation; PROCEDURE (this: _Chart) PUTElevation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 49, p1) END PUTElevation; PROCEDURE (this: _Chart) Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: _Chart) _Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Chart) Floor* (): Floor, NEW; BEGIN RETURN ThisFloor(CtlC.GetAny(this, 83)) END Floor; PROCEDURE (this: _Chart) GapDepth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 50) END GapDepth; PROCEDURE (this: _Chart) PUTGapDepth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 50, p1) END PUTGapDepth; PROCEDURE (this: _Chart) GroupBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 834, arg, ret); RETURN CtlC.VarObj(ret) END GroupBoxes; PROCEDURE (this: _Chart) GroupObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1113, arg, ret); RETURN CtlC.VarObj(ret) END GroupObjects; PROCEDURE (this: _Chart) HasAxis* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallGetMethod(this, 52, arg, ret); RETURN CtlC.VarAny(ret) END HasAxis; PROCEDURE (this: _Chart) PUTHasAxis* (Index1: CtlT.Any; (* optional *) Index2: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[2]); CtlC.AnyVar(Index2, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 52, arg, NIL); END PUTHasAxis; PROCEDURE (this: _Chart) HasDataTable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1396) END HasDataTable; PROCEDURE (this: _Chart) PUTHasDataTable* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1396, p1) END PUTHasDataTable; PROCEDURE (this: _Chart) HasLegend* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 53) END HasLegend; PROCEDURE (this: _Chart) PUTHasLegend* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 53, p1) END PUTHasLegend; PROCEDURE (this: _Chart) HasTitle* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 54) END HasTitle; PROCEDURE (this: _Chart) PUTHasTitle* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 54, p1) END PUTHasTitle; PROCEDURE (this: _Chart) HeightPercent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 55) END HeightPercent; PROCEDURE (this: _Chart) PUTHeightPercent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 55, p1) END PUTHeightPercent; PROCEDURE (this: _Chart) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 1393)) END Hyperlinks; PROCEDURE (this: _Chart) Labels* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 841, arg, ret); RETURN CtlC.VarObj(ret) END Labels; PROCEDURE (this: _Chart) Legend* (): Legend, NEW; BEGIN RETURN ThisLegend(CtlC.GetAny(this, 84)) END Legend; PROCEDURE (this: _Chart) Line3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 20)) END Line3DGroup; PROCEDURE (this: _Chart) LineGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN CtlC.VarObj(ret) END LineGroups; PROCEDURE (this: _Chart) Lines* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 767, arg, ret); RETURN CtlC.VarObj(ret) END Lines; PROCEDURE (this: _Chart) ListBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 832, arg, ret); RETURN CtlC.VarObj(ret) END ListBoxes; PROCEDURE (this: _Chart) Location* (Where: XlChartLocation; (* optional *) Name: CtlT.Any): Chart, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Where, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1397, arg, ret); RETURN This_Chart(CtlC.VarAny(ret)) END Location; PROCEDURE (this: _Chart) OLEObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 799, arg, ret); RETURN CtlC.VarObj(ret) END OLEObjects; PROCEDURE (this: _Chart) OptionButtons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 826, arg, ret); RETURN CtlC.VarObj(ret) END OptionButtons; PROCEDURE (this: _Chart) Ovals* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 801, arg, ret); RETURN CtlC.VarObj(ret) END Ovals; PROCEDURE (this: _Chart) Paste* ((* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 211, arg, NIL); END Paste; PROCEDURE (this: _Chart) Perspective* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 57) END Perspective; PROCEDURE (this: _Chart) PUTPerspective* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 57, p1) END PUTPerspective; PROCEDURE (this: _Chart) Pictures* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 771, arg, ret); RETURN CtlC.VarObj(ret) END Pictures; PROCEDURE (this: _Chart) Pie3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 21)) END Pie3DGroup; PROCEDURE (this: _Chart) PieGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN CtlC.VarObj(ret) END PieGroups; PROCEDURE (this: _Chart) PlotArea* (): PlotArea, NEW; BEGIN RETURN ThisPlotArea(CtlC.GetAny(this, 85)) END PlotArea; PROCEDURE (this: _Chart) PlotVisibleOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 92) END PlotVisibleOnly; PROCEDURE (this: _Chart) PUTPlotVisibleOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 92, p1) END PUTPlotVisibleOnly; PROCEDURE (this: _Chart) RadarGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN CtlC.VarObj(ret) END RadarGroups; PROCEDURE (this: _Chart) Rectangles* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 774, arg, ret); RETURN CtlC.VarObj(ret) END Rectangles; PROCEDURE (this: _Chart) RightAngleAxes* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 58) END RightAngleAxes; PROCEDURE (this: _Chart) PUTRightAngleAxes* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 58, p1) END PUTRightAngleAxes; PROCEDURE (this: _Chart) Rotation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 59) END Rotation; PROCEDURE (this: _Chart) PUTRotation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 59, p1) END PUTRotation; PROCEDURE (this: _Chart) ScrollBars* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 830, arg, ret); RETURN CtlC.VarObj(ret) END ScrollBars; PROCEDURE (this: _Chart) SeriesCollection* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 68, arg, ret); RETURN CtlC.VarObj(ret) END SeriesCollection; PROCEDURE (this: _Chart) SizeWithWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 94) END SizeWithWindow; PROCEDURE (this: _Chart) PUTSizeWithWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 94, p1) END PUTSizeWithWindow; PROCEDURE (this: _Chart) ShowWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1399) END ShowWindow; PROCEDURE (this: _Chart) PUTShowWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1399, p1) END PUTShowWindow; PROCEDURE (this: _Chart) Spinners* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 838, arg, ret); RETURN CtlC.VarObj(ret) END Spinners; PROCEDURE (this: _Chart) SubType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END SubType; PROCEDURE (this: _Chart) PUTSubType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTSubType; PROCEDURE (this: _Chart) SurfaceGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 22)) END SurfaceGroup; PROCEDURE (this: _Chart) TextBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 777, arg, ret); RETURN CtlC.VarObj(ret) END TextBoxes; PROCEDURE (this: _Chart) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: _Chart) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: _Chart) ChartType* (): XlChartType, NEW; BEGIN RETURN CtlC.GetInt(this, 1400) END ChartType; PROCEDURE (this: _Chart) PUTChartType* (p1: XlChartType), NEW; BEGIN CtlC.PutInt(this, 1400, p1) END PUTChartType; PROCEDURE (this: _Chart) ApplyCustomType* (ChartType: XlChartType; (* optional *) TypeName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(ChartType, arg[1]); CtlC.AnyVar(TypeName, arg[0]); CtlC.CallParMethod(this, 1401, arg, NIL); END ApplyCustomType; PROCEDURE (this: _Chart) Walls* (): Walls, NEW; BEGIN RETURN ThisWalls(CtlC.GetAny(this, 86)) END Walls; PROCEDURE (this: _Chart) WallsAndGridlines2D* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 210) END WallsAndGridlines2D; PROCEDURE (this: _Chart) PUTWallsAndGridlines2D* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 210, p1) END PUTWallsAndGridlines2D; PROCEDURE (this: _Chart) XYGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN CtlC.VarObj(ret) END XYGroups; PROCEDURE (this: _Chart) BarShape* (): XlBarShape, NEW; BEGIN RETURN CtlC.GetInt(this, 1403) END BarShape; PROCEDURE (this: _Chart) PUTBarShape* (p1: XlBarShape), NEW; BEGIN CtlC.PutInt(this, 1403, p1) END PUTBarShape; PROCEDURE (this: _Chart) PlotBy* (): XlRowCol, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END PlotBy; PROCEDURE (this: _Chart) PUTPlotBy* (p1: XlRowCol), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTPlotBy; PROCEDURE (this: _Chart) CopyChartBuild* (), NEW; BEGIN CtlC.CallMethod(this, 1404, NIL); END CopyChartBuild; PROCEDURE (this: _Chart) ProtectFormatting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1405) END ProtectFormatting; PROCEDURE (this: _Chart) PUTProtectFormatting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1405, p1) END PUTProtectFormatting; PROCEDURE (this: _Chart) ProtectData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1406) END ProtectData; PROCEDURE (this: _Chart) PUTProtectData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1406, p1) END PUTProtectData; PROCEDURE (this: _Chart) ProtectGoalSeek* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1407) END ProtectGoalSeek; PROCEDURE (this: _Chart) PUTProtectGoalSeek* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1407, p1) END PUTProtectGoalSeek; PROCEDURE (this: _Chart) ProtectSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1408) END ProtectSelection; PROCEDURE (this: _Chart) PUTProtectSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1408, p1) END PUTProtectSelection; PROCEDURE (this: _Chart) GetChartElement* (x: INTEGER; y: INTEGER; VAR ElementID: INTEGER; VAR Arg1: INTEGER; VAR Arg2: INTEGER), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(x, arg[4]); CtlC.IntVar(y, arg[3]); CtlC.RefIntVar(ElementID, arg[2]); CtlC.RefIntVar(Arg1, arg[1]); CtlC.RefIntVar(Arg2, arg[0]); CtlC.CallParMethod(this, 1409, arg, NIL); END GetChartElement; PROCEDURE (this: _Chart) SetSourceData* (Source: Range; (* optional *) PlotBy: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(Source, arg[1]); CtlC.AnyVar(PlotBy, arg[0]); CtlC.CallParMethod(this, 1413, arg, NIL); END SetSourceData; PROCEDURE (this: _Chart) Export* (Filename: ARRAY OF CHAR; (* optional *) FilterName: CtlT.Any; Interactive: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[2]); CtlC.AnyVar(FilterName, arg[1]); CtlC.AnyVar(Interactive, arg[0]); CtlC.CallParMethod(this, 1414, arg, ret); RETURN CtlC.VarBool(ret) END Export; PROCEDURE (this: _Chart) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1417, NIL); END Refresh; PROCEDURE (this: _Chart) PivotLayout* (): PivotLayout, NEW; BEGIN RETURN ThisPivotLayout(CtlC.GetAny(this, 1814)) END PivotLayout; PROCEDURE (this: _Chart) HasPivotFields* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1815) END HasPivotFields; PROCEDURE (this: _Chart) PUTHasPivotFields* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1815, p1) END PUTHasPivotFields; PROCEDURE (this: _Chart) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 1816)) END Scripts; PROCEDURE (this: _Chart) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- Sheets, dual, nonextensible ---------- *) PROCEDURE (this: Sheets) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Sheets) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Sheets) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Sheets) Add* ((* optional *) Before: CtlT.Any; After: CtlT.Any; Count: CtlT.Any; Type: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[3]); CtlC.AnyVar(After, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN CtlC.VarObj(ret) END Add; PROCEDURE (this: Sheets) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Sheets) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Sheets) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Sheets) FillAcrossSheets* (range: Range; Type: XlFillWith), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[1]); CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 469, arg, NIL); END FillAcrossSheets; PROCEDURE (this: Sheets) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Sheets) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: Sheets) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Sheets) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: Sheets) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: Sheets) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Sheets) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: Sheets) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: Sheets) Visible* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 558) END Visible; PROCEDURE (this: Sheets) PUTVisible* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 558, p1) END PUTVisible; PROCEDURE (this: Sheets) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: Sheets) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- _Worksheet, dual, nonextensible ---------- *) PROCEDURE (this: _Worksheet) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Worksheet) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Worksheet) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: _Worksheet) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: _Worksheet) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: _Worksheet) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: _Worksheet) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1373) END CodeName; PROCEDURE (this: _Worksheet) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: _Worksheet) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: _Worksheet) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: _Worksheet) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: _Worksheet) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: _Worksheet) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: _Worksheet) Next* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 502) END Next; PROCEDURE (this: _Worksheet) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 628) END OnDoubleClick; PROCEDURE (this: _Worksheet) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 628, p1) END PUTOnDoubleClick; PROCEDURE (this: _Worksheet) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: _Worksheet) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: _Worksheet) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: _Worksheet) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: _Worksheet) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 998)) END PageSetup; PROCEDURE (this: _Worksheet) Previous* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 503) END Previous; PROCEDURE (this: _Worksheet) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: _Worksheet) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: _Worksheet) Protect* ((* optional *) Password: CtlT.Any; DrawingObjects: CtlT.Any; Contents: CtlT.Any; Scenarios: CtlT.Any; UserInterfaceOnly: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[4]); CtlC.AnyVar(DrawingObjects, arg[3]); CtlC.AnyVar(Contents, arg[2]); CtlC.AnyVar(Scenarios, arg[1]); CtlC.AnyVar(UserInterfaceOnly, arg[0]); CtlC.CallParMethod(this, 282, arg, NIL); END Protect; PROCEDURE (this: _Worksheet) ProtectContents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 292) END ProtectContents; PROCEDURE (this: _Worksheet) ProtectDrawingObjects* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 293) END ProtectDrawingObjects; PROCEDURE (this: _Worksheet) ProtectionMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1159) END ProtectionMode; PROCEDURE (this: _Worksheet) ProtectScenarios* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END ProtectScenarios; PROCEDURE (this: _Worksheet) SaveAs* (Filename: ARRAY OF CHAR; (* optional *) FileFormat: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; AddToMru: CtlT.Any; TextCodepage: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[8]); CtlC.AnyVar(FileFormat, arg[7]); CtlC.AnyVar(Password, arg[6]); CtlC.AnyVar(WriteResPassword, arg[5]); CtlC.AnyVar(ReadOnlyRecommended, arg[4]); CtlC.AnyVar(CreateBackup, arg[3]); CtlC.AnyVar(AddToMru, arg[2]); CtlC.AnyVar(TextCodepage, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: _Worksheet) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: _Worksheet) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 285, arg, NIL); END Unprotect; PROCEDURE (this: _Worksheet) Visible* (): XlSheetVisibility, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: _Worksheet) PUTVisible* (p1: XlSheetVisibility), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: _Worksheet) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 1377)) END Shapes; PROCEDURE (this: _Worksheet) TransitionExpEval* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 401) END TransitionExpEval; PROCEDURE (this: _Worksheet) PUTTransitionExpEval* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 401, p1) END PUTTransitionExpEval; PROCEDURE (this: _Worksheet) Arcs* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 760, arg, ret); RETURN CtlC.VarObj(ret) END Arcs; PROCEDURE (this: _Worksheet) AutoFilterMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 792) END AutoFilterMode; PROCEDURE (this: _Worksheet) PUTAutoFilterMode* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 792, p1) END PUTAutoFilterMode; PROCEDURE (this: _Worksheet) SetBackgroundPicture* (Filename: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[0]); CtlC.CallParMethod(this, 1188, arg, NIL); END SetBackgroundPicture; PROCEDURE (this: _Worksheet) Buttons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 557, arg, ret); RETURN CtlC.VarObj(ret) END Buttons; PROCEDURE (this: _Worksheet) Calculate* (), NEW; BEGIN CtlC.CallMethod(this, 279, NIL); END Calculate; PROCEDURE (this: _Worksheet) EnableCalculation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1424) END EnableCalculation; PROCEDURE (this: _Worksheet) PUTEnableCalculation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1424, p1) END PUTEnableCalculation; PROCEDURE (this: _Worksheet) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: _Worksheet) ChartObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1060, arg, ret); RETURN CtlC.VarObj(ret) END ChartObjects; PROCEDURE (this: _Worksheet) CheckBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 824, arg, ret); RETURN CtlC.VarObj(ret) END CheckBoxes; PROCEDURE (this: _Worksheet) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, NIL); END CheckSpelling; PROCEDURE (this: _Worksheet) CircularReference* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1069)) END CircularReference; PROCEDURE (this: _Worksheet) ClearArrows* (), NEW; BEGIN CtlC.CallMethod(this, 970, NIL); END ClearArrows; PROCEDURE (this: _Worksheet) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: _Worksheet) ConsolidationFunction* (): XlConsolidationFunction, NEW; BEGIN RETURN CtlC.GetInt(this, 789) END ConsolidationFunction; PROCEDURE (this: _Worksheet) ConsolidationOptions* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 790) END ConsolidationOptions; PROCEDURE (this: _Worksheet) ConsolidationSources* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 791) END ConsolidationSources; PROCEDURE (this: _Worksheet) DisplayAutomaticPageBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 643) END DisplayAutomaticPageBreaks; PROCEDURE (this: _Worksheet) PUTDisplayAutomaticPageBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 643, p1) END PUTDisplayAutomaticPageBreaks; PROCEDURE (this: _Worksheet) Drawings* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 772, arg, ret); RETURN CtlC.VarObj(ret) END Drawings; PROCEDURE (this: _Worksheet) DrawingObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 88, arg, ret); RETURN CtlC.VarObj(ret) END DrawingObjects; PROCEDURE (this: _Worksheet) DropDowns* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 836, arg, ret); RETURN CtlC.VarObj(ret) END DropDowns; PROCEDURE (this: _Worksheet) EnableAutoFilter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1156) END EnableAutoFilter; PROCEDURE (this: _Worksheet) PUTEnableAutoFilter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1156, p1) END PUTEnableAutoFilter; PROCEDURE (this: _Worksheet) EnableSelection* (): XlEnableSelection, NEW; BEGIN RETURN CtlC.GetInt(this, 1425) END EnableSelection; PROCEDURE (this: _Worksheet) PUTEnableSelection* (p1: XlEnableSelection), NEW; BEGIN CtlC.PutInt(this, 1425, p1) END PUTEnableSelection; PROCEDURE (this: _Worksheet) EnableOutlining* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1157) END EnableOutlining; PROCEDURE (this: _Worksheet) PUTEnableOutlining* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1157, p1) END PUTEnableOutlining; PROCEDURE (this: _Worksheet) EnablePivotTable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1158) END EnablePivotTable; PROCEDURE (this: _Worksheet) PUTEnablePivotTable* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1158, p1) END PUTEnablePivotTable; PROCEDURE (this: _Worksheet) Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: _Worksheet) _Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Worksheet) FilterMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 800) END FilterMode; PROCEDURE (this: _Worksheet) ResetAllPageBreaks* (), NEW; BEGIN CtlC.CallMethod(this, 1426, NIL); END ResetAllPageBreaks; PROCEDURE (this: _Worksheet) GroupBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 834, arg, ret); RETURN CtlC.VarObj(ret) END GroupBoxes; PROCEDURE (this: _Worksheet) GroupObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1113, arg, ret); RETURN CtlC.VarObj(ret) END GroupObjects; PROCEDURE (this: _Worksheet) Labels* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 841, arg, ret); RETURN CtlC.VarObj(ret) END Labels; PROCEDURE (this: _Worksheet) Lines* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 767, arg, ret); RETURN CtlC.VarObj(ret) END Lines; PROCEDURE (this: _Worksheet) ListBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 832, arg, ret); RETURN CtlC.VarObj(ret) END ListBoxes; PROCEDURE (this: _Worksheet) Names* (): Names, NEW; BEGIN RETURN ThisNames(CtlC.GetAny(this, 442)) END Names; PROCEDURE (this: _Worksheet) OLEObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 799, arg, ret); RETURN CtlC.VarObj(ret) END OLEObjects; PROCEDURE (this: _Worksheet) OnCalculate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 625) END OnCalculate; PROCEDURE (this: _Worksheet) PUTOnCalculate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 625, p1) END PUTOnCalculate; PROCEDURE (this: _Worksheet) OnData* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 629) END OnData; PROCEDURE (this: _Worksheet) PUTOnData* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 629, p1) END PUTOnData; PROCEDURE (this: _Worksheet) OnEntry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 627) END OnEntry; PROCEDURE (this: _Worksheet) PUTOnEntry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 627, p1) END PUTOnEntry; PROCEDURE (this: _Worksheet) OptionButtons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 826, arg, ret); RETURN CtlC.VarObj(ret) END OptionButtons; PROCEDURE (this: _Worksheet) Outline* (): Outline, NEW; BEGIN RETURN ThisOutline(CtlC.GetAny(this, 102)) END Outline; PROCEDURE (this: _Worksheet) Ovals* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 801, arg, ret); RETURN CtlC.VarObj(ret) END Ovals; PROCEDURE (this: _Worksheet) Paste* ((* optional *) Destination: CtlT.Any; Link: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[1]); CtlC.AnyVar(Link, arg[0]); CtlC.CallParMethod(this, 211, arg, NIL); END Paste; PROCEDURE (this: _Worksheet) PasteSpecial* ((* optional *) Format: CtlT.Any; Link: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[5]); CtlC.AnyVar(Link, arg[4]); CtlC.AnyVar(DisplayAsIcon, arg[3]); CtlC.AnyVar(IconFileName, arg[2]); CtlC.AnyVar(IconIndex, arg[1]); CtlC.AnyVar(IconLabel, arg[0]); CtlC.CallParMethod(this, 1027, arg, NIL); END PasteSpecial; PROCEDURE (this: _Worksheet) Pictures* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 771, arg, ret); RETURN CtlC.VarObj(ret) END Pictures; PROCEDURE (this: _Worksheet) PivotTables* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 690, arg, ret); RETURN CtlC.VarObj(ret) END PivotTables; PROCEDURE (this: _Worksheet) PivotTableWizard* ((* optional *) SourceType: CtlT.Any; SourceData: CtlT.Any; TableDestination: CtlT.Any; TableName: CtlT.Any; RowGrand: CtlT.Any; ColumnGrand: CtlT.Any; SaveData: CtlT.Any; HasAutoFormat: CtlT.Any; AutoPage: CtlT.Any; Reserved: CtlT.Any; BackgroundQuery: CtlT.Any; OptimizeCache: CtlT.Any; PageFieldOrder: CtlT.Any; PageFieldWrapCount: CtlT.Any; ReadData: CtlT.Any; Connection: CtlT.Any): PivotTable, NEW; VAR arg: ARRAY 16 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SourceType, arg[15]); CtlC.AnyVar(SourceData, arg[14]); CtlC.AnyVar(TableDestination, arg[13]); CtlC.AnyVar(TableName, arg[12]); CtlC.AnyVar(RowGrand, arg[11]); CtlC.AnyVar(ColumnGrand, arg[10]); CtlC.AnyVar(SaveData, arg[9]); CtlC.AnyVar(HasAutoFormat, arg[8]); CtlC.AnyVar(AutoPage, arg[7]); CtlC.AnyVar(Reserved, arg[6]); CtlC.AnyVar(BackgroundQuery, arg[5]); CtlC.AnyVar(OptimizeCache, arg[4]); CtlC.AnyVar(PageFieldOrder, arg[3]); CtlC.AnyVar(PageFieldWrapCount, arg[2]); CtlC.AnyVar(ReadData, arg[1]); CtlC.AnyVar(Connection, arg[0]); CtlC.CallParMethod(this, 684, arg, ret); RETURN ThisPivotTable(CtlC.VarAny(ret)) END PivotTableWizard; PROCEDURE (this: _Worksheet) Range* (Cell1: CtlT.Any; (* optional *) Cell2: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cell1, arg[1]); CtlC.AnyVar(Cell2, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: _Worksheet) Rectangles* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 774, arg, ret); RETURN CtlC.VarObj(ret) END Rectangles; PROCEDURE (this: _Worksheet) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: _Worksheet) Scenarios* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 908, arg, ret); RETURN CtlC.VarObj(ret) END Scenarios; PROCEDURE (this: _Worksheet) ScrollArea* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1433) END ScrollArea; PROCEDURE (this: _Worksheet) PUTScrollArea* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1433, p1) END PUTScrollArea; PROCEDURE (this: _Worksheet) ScrollBars* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 830, arg, ret); RETURN CtlC.VarObj(ret) END ScrollBars; PROCEDURE (this: _Worksheet) ShowAllData* (), NEW; BEGIN CtlC.CallMethod(this, 794, NIL); END ShowAllData; PROCEDURE (this: _Worksheet) ShowDataForm* (), NEW; BEGIN CtlC.CallMethod(this, 409, NIL); END ShowDataForm; PROCEDURE (this: _Worksheet) Spinners* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 838, arg, ret); RETURN CtlC.VarObj(ret) END Spinners; PROCEDURE (this: _Worksheet) StandardHeight* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 407) END StandardHeight; PROCEDURE (this: _Worksheet) StandardWidth* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 408) END StandardWidth; PROCEDURE (this: _Worksheet) PUTStandardWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 408, p1) END PUTStandardWidth; PROCEDURE (this: _Worksheet) TextBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 777, arg, ret); RETURN CtlC.VarObj(ret) END TextBoxes; PROCEDURE (this: _Worksheet) TransitionFormEntry* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 402) END TransitionFormEntry; PROCEDURE (this: _Worksheet) PUTTransitionFormEntry* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 402, p1) END PUTTransitionFormEntry; PROCEDURE (this: _Worksheet) Type* (): XlSheetType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: _Worksheet) UsedRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 412)) END UsedRange; PROCEDURE (this: _Worksheet) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: _Worksheet) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: _Worksheet) QueryTables* (): QueryTables, NEW; BEGIN RETURN ThisQueryTables(CtlC.GetAny(this, 1434)) END QueryTables; PROCEDURE (this: _Worksheet) DisplayPageBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1435) END DisplayPageBreaks; PROCEDURE (this: _Worksheet) PUTDisplayPageBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1435, p1) END PUTDisplayPageBreaks; PROCEDURE (this: _Worksheet) Comments* (): Comments, NEW; BEGIN RETURN ThisComments(CtlC.GetAny(this, 575)) END Comments; PROCEDURE (this: _Worksheet) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 1393)) END Hyperlinks; PROCEDURE (this: _Worksheet) ClearCircles* (), NEW; BEGIN CtlC.CallMethod(this, 1436, NIL); END ClearCircles; PROCEDURE (this: _Worksheet) CircleInvalid* (), NEW; BEGIN CtlC.CallMethod(this, 1437, NIL); END CircleInvalid; PROCEDURE (this: _Worksheet) _DisplayRightToLeft* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 648) END _DisplayRightToLeft; PROCEDURE (this: _Worksheet) PUT_DisplayRightToLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 648, p1) END PUT_DisplayRightToLeft; PROCEDURE (this: _Worksheet) AutoFilter* (): AutoFilter, NEW; BEGIN RETURN ThisAutoFilter(CtlC.GetAny(this, 793)) END AutoFilter; PROCEDURE (this: _Worksheet) DisplayRightToLeft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1774) END DisplayRightToLeft; PROCEDURE (this: _Worksheet) PUTDisplayRightToLeft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1774, p1) END PUTDisplayRightToLeft; PROCEDURE (this: _Worksheet) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 1816)) END Scripts; PROCEDURE (this: _Worksheet) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; PROCEDURE (this: _Worksheet) _CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any; IgnoreFinalYaa: CtlT.Any; SpellScript: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[5]); CtlC.AnyVar(IgnoreUppercase, arg[4]); CtlC.AnyVar(AlwaysSuggest, arg[3]); CtlC.AnyVar(SpellLang, arg[2]); CtlC.AnyVar(IgnoreFinalYaa, arg[1]); CtlC.AnyVar(SpellScript, arg[0]); CtlC.CallParMethod(this, 1817, arg, NIL); END _CheckSpelling; (* ---------- _Global, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Global) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Global) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Global) Parent* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: _Global) ActiveCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 305)) END ActiveCell; PROCEDURE (this: _Global) ActiveChart* (): Chart, NEW; BEGIN RETURN This_Chart(CtlC.GetAny(this, 183)) END ActiveChart; PROCEDURE (this: _Global) ActiveDialog* (): DialogSheet, NEW; BEGIN RETURN ThisDialogSheet(CtlC.GetAny(this, 815)) END ActiveDialog; PROCEDURE (this: _Global) ActiveMenuBar* (): MenuBar, NEW; BEGIN RETURN ThisMenuBar(CtlC.GetAny(this, 758)) END ActiveMenuBar; PROCEDURE (this: _Global) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 306) END ActivePrinter; PROCEDURE (this: _Global) PUTActivePrinter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 306, p1) END PUTActivePrinter; PROCEDURE (this: _Global) ActiveSheet* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 307) END ActiveSheet; PROCEDURE (this: _Global) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 759)) END ActiveWindow; PROCEDURE (this: _Global) ActiveWorkbook* (): Workbook, NEW; BEGIN RETURN This_Workbook(CtlC.GetAny(this, 308)) END ActiveWorkbook; PROCEDURE (this: _Global) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 549)) END AddIns; PROCEDURE (this: _Global) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 1438)) END Assistant; PROCEDURE (this: _Global) Calculate* (), NEW; BEGIN CtlC.CallMethod(this, 279, NIL); END Calculate; PROCEDURE (this: _Global) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: _Global) Charts* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 121)) END Charts; PROCEDURE (this: _Global) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: _Global) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 1439)) END CommandBars; PROCEDURE (this: _Global) DDEAppReturnCode* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 332) END DDEAppReturnCode; PROCEDURE (this: _Global) DDEExecute* (Channel: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 333, arg, NIL); END DDEExecute; PROCEDURE (this: _Global) DDEInitiate* (App: ARRAY OF CHAR; Topic: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(App, arg[1]); CtlC.StrVar(Topic, arg[0]); CtlC.CallParMethod(this, 334, arg, ret); RETURN CtlC.VarInt(ret) END DDEInitiate; PROCEDURE (this: _Global) DDEPoke* (Channel: INTEGER; Item: CtlT.Any; Data: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[2]); CtlC.AnyVar(Item, arg[1]); CtlC.AnyVar(Data, arg[0]); CtlC.CallParMethod(this, 335, arg, NIL); END DDEPoke; PROCEDURE (this: _Global) DDERequest* (Channel: INTEGER; Item: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Item, arg[0]); CtlC.CallParMethod(this, 336, arg, ret); RETURN CtlC.VarAny(ret) END DDERequest; PROCEDURE (this: _Global) DDETerminate* (Channel: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[0]); CtlC.CallParMethod(this, 337, arg, NIL); END DDETerminate; PROCEDURE (this: _Global) DialogSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 764)) END DialogSheets; PROCEDURE (this: _Global) Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: _Global) _Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: _Global) ExecuteExcel4Macro* (String: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 350, arg, ret); RETURN CtlC.VarAny(ret) END ExecuteExcel4Macro; PROCEDURE (this: _Global) Intersect* (Arg1: Range; Arg2: Range; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): Range, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[29]); CtlC.ObjVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 766, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Intersect; PROCEDURE (this: _Global) MenuBars* (): MenuBars, NEW; BEGIN RETURN ThisMenuBars(CtlC.GetAny(this, 589)) END MenuBars; PROCEDURE (this: _Global) Modules* (): Modules, NEW; BEGIN RETURN ThisModules(CtlC.GetAny(this, 582)) END Modules; PROCEDURE (this: _Global) Names* (): Names, NEW; BEGIN RETURN ThisNames(CtlC.GetAny(this, 442)) END Names; PROCEDURE (this: _Global) Range* (Cell1: CtlT.Any; (* optional *) Cell2: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cell1, arg[1]); CtlC.AnyVar(Cell2, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: _Global) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: _Global) Run* ((* optional *) Macro: CtlT.Any; Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Macro, arg[30]); CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 259, arg, ret); RETURN CtlC.VarAny(ret) END Run; PROCEDURE (this: _Global) _Run2* ((* optional *) Macro: CtlT.Any; Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Macro, arg[30]); CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 806, arg, ret); RETURN CtlC.VarAny(ret) END _Run2; PROCEDURE (this: _Global) Selection* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 147) END Selection; PROCEDURE (this: _Global) SendKeys* (Keys: CtlT.Any; (* optional *) Wait: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Keys, arg[1]); CtlC.AnyVar(Wait, arg[0]); CtlC.CallParMethod(this, 383, arg, NIL); END SendKeys; PROCEDURE (this: _Global) Sheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 485)) END Sheets; PROCEDURE (this: _Global) ShortcutMenus* (Index: INTEGER): Menu, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 776, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END ShortcutMenus; PROCEDURE (this: _Global) ThisWorkbook* (): Workbook, NEW; BEGIN RETURN This_Workbook(CtlC.GetAny(this, 778)) END ThisWorkbook; PROCEDURE (this: _Global) Toolbars* (): Toolbars, NEW; BEGIN RETURN ThisToolbars(CtlC.GetAny(this, 552)) END Toolbars; PROCEDURE (this: _Global) Union* (Arg1: Range; Arg2: Range; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): Range, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[29]); CtlC.ObjVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 779, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Union; PROCEDURE (this: _Global) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 430)) END Windows; PROCEDURE (this: _Global) Workbooks* (): Workbooks, NEW; BEGIN RETURN ThisWorkbooks(CtlC.GetAny(this, 572)) END Workbooks; PROCEDURE (this: _Global) WorksheetFunction* (): WorksheetFunction, NEW; BEGIN RETURN ThisWorksheetFunction(CtlC.GetAny(this, 1440)) END WorksheetFunction; PROCEDURE (this: _Global) Worksheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 494)) END Worksheets; PROCEDURE (this: _Global) Excel4IntlMacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 581)) END Excel4IntlMacroSheets; PROCEDURE (this: _Global) Excel4MacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 579)) END Excel4MacroSheets; (* ---------- _Workbook, dual ---------- *) PROCEDURE (this: _Workbook) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Workbook) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Workbook) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: _Workbook) AcceptLabelsInFormulas* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1441) END AcceptLabelsInFormulas; PROCEDURE (this: _Workbook) PUTAcceptLabelsInFormulas* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1441, p1) END PUTAcceptLabelsInFormulas; PROCEDURE (this: _Workbook) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: _Workbook) ActiveChart* (): Chart, NEW; BEGIN RETURN This_Chart(CtlC.GetAny(this, 183)) END ActiveChart; PROCEDURE (this: _Workbook) ActiveSheet* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 307) END ActiveSheet; PROCEDURE (this: _Workbook) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 574) END Author; PROCEDURE (this: _Workbook) PUTAuthor* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 574, p1) END PUTAuthor; PROCEDURE (this: _Workbook) AutoUpdateFrequency* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1442) END AutoUpdateFrequency; PROCEDURE (this: _Workbook) PUTAutoUpdateFrequency* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1442, p1) END PUTAutoUpdateFrequency; PROCEDURE (this: _Workbook) AutoUpdateSaveChanges* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1443) END AutoUpdateSaveChanges; PROCEDURE (this: _Workbook) PUTAutoUpdateSaveChanges* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1443, p1) END PUTAutoUpdateSaveChanges; PROCEDURE (this: _Workbook) ChangeHistoryDuration* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1444) END ChangeHistoryDuration; PROCEDURE (this: _Workbook) PUTChangeHistoryDuration* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1444, p1) END PUTChangeHistoryDuration; PROCEDURE (this: _Workbook) BuiltinDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1176) END BuiltinDocumentProperties; PROCEDURE (this: _Workbook) ChangeFileAccess* (Mode: XlFileAccess; (* optional *) WritePassword: CtlT.Any; Notify: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Mode, arg[2]); CtlC.AnyVar(WritePassword, arg[1]); CtlC.AnyVar(Notify, arg[0]); CtlC.CallParMethod(this, 989, arg, NIL); END ChangeFileAccess; PROCEDURE (this: _Workbook) ChangeLink* (Name: ARRAY OF CHAR; NewName: ARRAY OF CHAR; Type: XlLinkType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[2]); CtlC.StrVar(NewName, arg[1]); CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 802, arg, NIL); END ChangeLink; PROCEDURE (this: _Workbook) Charts* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 121)) END Charts; PROCEDURE (this: _Workbook) Close* ((* optional *) SaveChanges: CtlT.Any; Filename: CtlT.Any; RouteWorkbook: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[2]); CtlC.AnyVar(Filename, arg[1]); CtlC.AnyVar(RouteWorkbook, arg[0]); CtlC.CallParMethod(this, 277, arg, NIL); END Close; PROCEDURE (this: _Workbook) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1373) END CodeName; PROCEDURE (this: _Workbook) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: _Workbook) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: _Workbook) Colors* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 286, arg, ret); RETURN CtlC.VarAny(ret) END Colors; PROCEDURE (this: _Workbook) PUTColors* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 286, arg, NIL); END PUTColors; PROCEDURE (this: _Workbook) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 1439)) END CommandBars; PROCEDURE (this: _Workbook) Comments* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 575) END Comments; PROCEDURE (this: _Workbook) PUTComments* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 575, p1) END PUTComments; PROCEDURE (this: _Workbook) ConflictResolution* (): XlSaveConflictResolution, NEW; BEGIN RETURN CtlC.GetInt(this, 1175) END ConflictResolution; PROCEDURE (this: _Workbook) PUTConflictResolution* (p1: XlSaveConflictResolution), NEW; BEGIN CtlC.PutInt(this, 1175, p1) END PUTConflictResolution; PROCEDURE (this: _Workbook) Container* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1190) END Container; PROCEDURE (this: _Workbook) CreateBackup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 287) END CreateBackup; PROCEDURE (this: _Workbook) CustomDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1177) END CustomDocumentProperties; PROCEDURE (this: _Workbook) Date1904* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 403) END Date1904; PROCEDURE (this: _Workbook) PUTDate1904* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 403, p1) END PUTDate1904; PROCEDURE (this: _Workbook) DeleteNumberFormat* (NumberFormat: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(NumberFormat, arg[0]); CtlC.CallParMethod(this, 397, arg, NIL); END DeleteNumberFormat; PROCEDURE (this: _Workbook) DialogSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 764)) END DialogSheets; PROCEDURE (this: _Workbook) DisplayDrawingObjects* (): xlDisplayDrawingObjects, NEW; BEGIN RETURN CtlC.GetInt(this, 404) END DisplayDrawingObjects; PROCEDURE (this: _Workbook) PUTDisplayDrawingObjects* (p1: xlDisplayDrawingObjects), NEW; BEGIN CtlC.PutInt(this, 404, p1) END PUTDisplayDrawingObjects; PROCEDURE (this: _Workbook) ExclusiveAccess* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1168, ret); RETURN CtlC.VarBool(ret) END ExclusiveAccess; PROCEDURE (this: _Workbook) FileFormat* (): XlFileFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 288) END FileFormat; PROCEDURE (this: _Workbook) ForwardMailer* (), NEW; BEGIN CtlC.CallMethod(this, 973, NIL); END ForwardMailer; PROCEDURE (this: _Workbook) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 289) END FullName; PROCEDURE (this: _Workbook) HasMailer* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 976) END HasMailer; PROCEDURE (this: _Workbook) PUTHasMailer* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 976, p1) END PUTHasMailer; PROCEDURE (this: _Workbook) HasPassword* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 290) END HasPassword; PROCEDURE (this: _Workbook) HasRoutingSlip* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 950) END HasRoutingSlip; PROCEDURE (this: _Workbook) PUTHasRoutingSlip* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 950, p1) END PUTHasRoutingSlip; PROCEDURE (this: _Workbook) IsAddin* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1445) END IsAddin; PROCEDURE (this: _Workbook) PUTIsAddin* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1445, p1) END PUTIsAddin; PROCEDURE (this: _Workbook) Keywords* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 577) END Keywords; PROCEDURE (this: _Workbook) PUTKeywords* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 577, p1) END PUTKeywords; PROCEDURE (this: _Workbook) LinkInfo* (Name: ARRAY OF CHAR; LinkInfo: XlLinkInfo; (* optional *) Type: CtlT.Any; EditionRef: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.IntVar(LinkInfo, arg[2]); CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(EditionRef, arg[0]); CtlC.CallParMethod(this, 807, arg, ret); RETURN CtlC.VarAny(ret) END LinkInfo; PROCEDURE (this: _Workbook) LinkSources* ((* optional *) Type: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 808, arg, ret); RETURN CtlC.VarAny(ret) END LinkSources; PROCEDURE (this: _Workbook) Mailer* (): Mailer, NEW; BEGIN RETURN ThisMailer(CtlC.GetAny(this, 979)) END Mailer; PROCEDURE (this: _Workbook) MergeWorkbook* (Filename: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[0]); CtlC.CallParMethod(this, 1446, arg, NIL); END MergeWorkbook; PROCEDURE (this: _Workbook) Modules* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 582)) END Modules; PROCEDURE (this: _Workbook) MultiUserEditing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1169) END MultiUserEditing; PROCEDURE (this: _Workbook) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: _Workbook) Names* (): Names, NEW; BEGIN RETURN ThisNames(CtlC.GetAny(this, 442)) END Names; PROCEDURE (this: _Workbook) NewWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 280, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: _Workbook) OnSave* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1178) END OnSave; PROCEDURE (this: _Workbook) PUTOnSave* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1178, p1) END PUTOnSave; PROCEDURE (this: _Workbook) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: _Workbook) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: _Workbook) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: _Workbook) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: _Workbook) OpenLinks* (Name: ARRAY OF CHAR; (* optional *) ReadOnly: CtlT.Any; Type: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[2]); CtlC.AnyVar(ReadOnly, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 803, arg, NIL); END OpenLinks; PROCEDURE (this: _Workbook) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 291) END Path; PROCEDURE (this: _Workbook) PersonalViewListSettings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1447) END PersonalViewListSettings; PROCEDURE (this: _Workbook) PUTPersonalViewListSettings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1447, p1) END PUTPersonalViewListSettings; PROCEDURE (this: _Workbook) PersonalViewPrintSettings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1448) END PersonalViewPrintSettings; PROCEDURE (this: _Workbook) PUTPersonalViewPrintSettings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1448, p1) END PUTPersonalViewPrintSettings; PROCEDURE (this: _Workbook) PivotCaches* (): PivotCaches, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1449, ret); RETURN ThisPivotCaches(CtlC.VarAny(ret)) END PivotCaches; PROCEDURE (this: _Workbook) Post* ((* optional *) DestName: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(DestName, arg[0]); CtlC.CallParMethod(this, 1166, arg, NIL); END Post; PROCEDURE (this: _Workbook) PrecisionAsDisplayed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 405) END PrecisionAsDisplayed; PROCEDURE (this: _Workbook) PUTPrecisionAsDisplayed* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 405, p1) END PUTPrecisionAsDisplayed; PROCEDURE (this: _Workbook) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: _Workbook) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: _Workbook) Protect* ((* optional *) Password: CtlT.Any; Structure: CtlT.Any; Windows: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[2]); CtlC.AnyVar(Structure, arg[1]); CtlC.AnyVar(Windows, arg[0]); CtlC.CallParMethod(this, 282, arg, NIL); END Protect; PROCEDURE (this: _Workbook) ProtectSharing* ((* optional *) Filename: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; SharingPassword: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[5]); CtlC.AnyVar(Password, arg[4]); CtlC.AnyVar(WriteResPassword, arg[3]); CtlC.AnyVar(ReadOnlyRecommended, arg[2]); CtlC.AnyVar(CreateBackup, arg[1]); CtlC.AnyVar(SharingPassword, arg[0]); CtlC.CallParMethod(this, 1450, arg, NIL); END ProtectSharing; PROCEDURE (this: _Workbook) ProtectStructure* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 588) END ProtectStructure; PROCEDURE (this: _Workbook) ProtectWindows* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 295) END ProtectWindows; PROCEDURE (this: _Workbook) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 296) END ReadOnly; PROCEDURE (this: _Workbook) ReadOnlyRecommended* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 297) END ReadOnlyRecommended; PROCEDURE (this: _Workbook) RefreshAll* (), NEW; BEGIN CtlC.CallMethod(this, 1452, NIL); END RefreshAll; PROCEDURE (this: _Workbook) Reply* (), NEW; BEGIN CtlC.CallMethod(this, 977, NIL); END Reply; PROCEDURE (this: _Workbook) ReplyAll* (), NEW; BEGIN CtlC.CallMethod(this, 978, NIL); END ReplyAll; PROCEDURE (this: _Workbook) RemoveUser* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 1453, arg, NIL); END RemoveUser; PROCEDURE (this: _Workbook) RevisionNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1172) END RevisionNumber; PROCEDURE (this: _Workbook) Route* (), NEW; BEGIN CtlC.CallMethod(this, 946, NIL); END Route; PROCEDURE (this: _Workbook) Routed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 951) END Routed; PROCEDURE (this: _Workbook) RoutingSlip* (): RoutingSlip, NEW; BEGIN RETURN ThisRoutingSlip(CtlC.GetAny(this, 949)) END RoutingSlip; PROCEDURE (this: _Workbook) RunAutoMacros* (Which: XlRunAutoMacro), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Which, arg[0]); CtlC.CallParMethod(this, 634, arg, NIL); END RunAutoMacros; PROCEDURE (this: _Workbook) Save* (), NEW; BEGIN CtlC.CallMethod(this, 283, NIL); END Save; PROCEDURE (this: _Workbook) SaveAs* (Filename: CtlT.Any; FileFormat: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; AccessMode: XlSaveAsAccessMode; (* optional *) ConflictResolution: CtlT.Any; AddToMru: CtlT.Any; TextCodepage: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 11 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[10]); CtlC.AnyVar(FileFormat, arg[9]); CtlC.AnyVar(Password, arg[8]); CtlC.AnyVar(WriteResPassword, arg[7]); CtlC.AnyVar(ReadOnlyRecommended, arg[6]); CtlC.AnyVar(CreateBackup, arg[5]); CtlC.IntVar(AccessMode, arg[4]); CtlC.AnyVar(ConflictResolution, arg[3]); CtlC.AnyVar(AddToMru, arg[2]); CtlC.AnyVar(TextCodepage, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: _Workbook) SaveCopyAs* ((* optional *) Filename: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[0]); CtlC.CallParMethod(this, 175, arg, NIL); END SaveCopyAs; PROCEDURE (this: _Workbook) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 298) END Saved; PROCEDURE (this: _Workbook) PUTSaved* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 298, p1) END PUTSaved; PROCEDURE (this: _Workbook) SaveLinkValues* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 406) END SaveLinkValues; PROCEDURE (this: _Workbook) PUTSaveLinkValues* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 406, p1) END PUTSaveLinkValues; PROCEDURE (this: _Workbook) SendMail* (Recipients: CtlT.Any; (* optional *) Subject: CtlT.Any; ReturnReceipt: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Recipients, arg[2]); CtlC.AnyVar(Subject, arg[1]); CtlC.AnyVar(ReturnReceipt, arg[0]); CtlC.CallParMethod(this, 947, arg, NIL); END SendMail; PROCEDURE (this: _Workbook) SendMailer* (FileFormat: CtlT.Any; Priority: XlPriority), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FileFormat, arg[1]); CtlC.IntVar(Priority, arg[0]); CtlC.CallParMethod(this, 980, arg, NIL); END SendMailer; PROCEDURE (this: _Workbook) SetLinkOnData* (Name: ARRAY OF CHAR; (* optional *) Procedure: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Procedure, arg[0]); CtlC.CallParMethod(this, 809, arg, NIL); END SetLinkOnData; PROCEDURE (this: _Workbook) Sheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 485)) END Sheets; PROCEDURE (this: _Workbook) ShowConflictHistory* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1171) END ShowConflictHistory; PROCEDURE (this: _Workbook) PUTShowConflictHistory* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1171, p1) END PUTShowConflictHistory; PROCEDURE (this: _Workbook) Styles* (): Styles, NEW; BEGIN RETURN ThisStyles(CtlC.GetAny(this, 493)) END Styles; PROCEDURE (this: _Workbook) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 953) END Subject; PROCEDURE (this: _Workbook) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 953, p1) END PUTSubject; PROCEDURE (this: _Workbook) Title* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 199) END Title; PROCEDURE (this: _Workbook) PUTTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 199, p1) END PUTTitle; PROCEDURE (this: _Workbook) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 285, arg, NIL); END Unprotect; PROCEDURE (this: _Workbook) UnprotectSharing* ((* optional *) SharingPassword: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(SharingPassword, arg[0]); CtlC.CallParMethod(this, 1455, arg, NIL); END UnprotectSharing; PROCEDURE (this: _Workbook) UpdateFromFile* (), NEW; BEGIN CtlC.CallMethod(this, 995, NIL); END UpdateFromFile; PROCEDURE (this: _Workbook) UpdateLink* ((* optional *) Name: CtlT.Any; Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 804, arg, NIL); END UpdateLink; PROCEDURE (this: _Workbook) UpdateRemoteReferences* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 411) END UpdateRemoteReferences; PROCEDURE (this: _Workbook) PUTUpdateRemoteReferences* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 411, p1) END PUTUpdateRemoteReferences; PROCEDURE (this: _Workbook) UserControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1210) END UserControl; PROCEDURE (this: _Workbook) PUTUserControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1210, p1) END PUTUserControl; PROCEDURE (this: _Workbook) UserStatus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1173) END UserStatus; PROCEDURE (this: _Workbook) CustomViews* (): CustomViews, NEW; BEGIN RETURN ThisCustomViews(CtlC.GetAny(this, 1456)) END CustomViews; PROCEDURE (this: _Workbook) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 430)) END Windows; PROCEDURE (this: _Workbook) Worksheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 494)) END Worksheets; PROCEDURE (this: _Workbook) WriteReserved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 299) END WriteReserved; PROCEDURE (this: _Workbook) WriteReservedBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 300) END WriteReservedBy; PROCEDURE (this: _Workbook) Excel4IntlMacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 581)) END Excel4IntlMacroSheets; PROCEDURE (this: _Workbook) Excel4MacroSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 579)) END Excel4MacroSheets; PROCEDURE (this: _Workbook) TemplateRemoveExtData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1457) END TemplateRemoveExtData; PROCEDURE (this: _Workbook) PUTTemplateRemoveExtData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1457, p1) END PUTTemplateRemoveExtData; PROCEDURE (this: _Workbook) HighlightChangesOptions* ((* optional *) When: CtlT.Any; Who: CtlT.Any; Where: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(When, arg[2]); CtlC.AnyVar(Who, arg[1]); CtlC.AnyVar(Where, arg[0]); CtlC.CallParMethod(this, 1458, arg, NIL); END HighlightChangesOptions; PROCEDURE (this: _Workbook) HighlightChangesOnScreen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1461) END HighlightChangesOnScreen; PROCEDURE (this: _Workbook) PUTHighlightChangesOnScreen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1461, p1) END PUTHighlightChangesOnScreen; PROCEDURE (this: _Workbook) KeepChangeHistory* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1462) END KeepChangeHistory; PROCEDURE (this: _Workbook) PUTKeepChangeHistory* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1462, p1) END PUTKeepChangeHistory; PROCEDURE (this: _Workbook) ListChangesOnNewSheet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1463) END ListChangesOnNewSheet; PROCEDURE (this: _Workbook) PUTListChangesOnNewSheet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1463, p1) END PUTListChangesOnNewSheet; PROCEDURE (this: _Workbook) PurgeChangeHistoryNow* (Days: INTEGER; (* optional *) SharingPassword: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Days, arg[1]); CtlC.AnyVar(SharingPassword, arg[0]); CtlC.CallParMethod(this, 1464, arg, NIL); END PurgeChangeHistoryNow; PROCEDURE (this: _Workbook) AcceptAllChanges* ((* optional *) When: CtlT.Any; Who: CtlT.Any; Where: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(When, arg[2]); CtlC.AnyVar(Who, arg[1]); CtlC.AnyVar(Where, arg[0]); CtlC.CallParMethod(this, 1466, arg, NIL); END AcceptAllChanges; PROCEDURE (this: _Workbook) RejectAllChanges* ((* optional *) When: CtlT.Any; Who: CtlT.Any; Where: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(When, arg[2]); CtlC.AnyVar(Who, arg[1]); CtlC.AnyVar(Where, arg[0]); CtlC.CallParMethod(this, 1467, arg, NIL); END RejectAllChanges; PROCEDURE (this: _Workbook) PivotTableWizard* ((* optional *) SourceType: CtlT.Any; SourceData: CtlT.Any; TableDestination: CtlT.Any; TableName: CtlT.Any; RowGrand: CtlT.Any; ColumnGrand: CtlT.Any; SaveData: CtlT.Any; HasAutoFormat: CtlT.Any; AutoPage: CtlT.Any; Reserved: CtlT.Any; BackgroundQuery: CtlT.Any; OptimizeCache: CtlT.Any; PageFieldOrder: CtlT.Any; PageFieldWrapCount: CtlT.Any; ReadData: CtlT.Any; Connection: CtlT.Any), NEW; VAR arg: ARRAY 16 OF CtlT.Variant; BEGIN CtlC.AnyVar(SourceType, arg[15]); CtlC.AnyVar(SourceData, arg[14]); CtlC.AnyVar(TableDestination, arg[13]); CtlC.AnyVar(TableName, arg[12]); CtlC.AnyVar(RowGrand, arg[11]); CtlC.AnyVar(ColumnGrand, arg[10]); CtlC.AnyVar(SaveData, arg[9]); CtlC.AnyVar(HasAutoFormat, arg[8]); CtlC.AnyVar(AutoPage, arg[7]); CtlC.AnyVar(Reserved, arg[6]); CtlC.AnyVar(BackgroundQuery, arg[5]); CtlC.AnyVar(OptimizeCache, arg[4]); CtlC.AnyVar(PageFieldOrder, arg[3]); CtlC.AnyVar(PageFieldWrapCount, arg[2]); CtlC.AnyVar(ReadData, arg[1]); CtlC.AnyVar(Connection, arg[0]); CtlC.CallParMethod(this, 684, arg, NIL); END PivotTableWizard; PROCEDURE (this: _Workbook) ResetColors* (), NEW; BEGIN CtlC.CallMethod(this, 1468, NIL); END ResetColors; PROCEDURE (this: _Workbook) VBProject* (): CtlVBIDE.VBProject, NEW; BEGIN RETURN CtlVBIDE.This_VBProject(CtlC.GetAny(this, 1469)) END VBProject; PROCEDURE (this: _Workbook) FollowHyperlink* (Address: ARRAY OF CHAR; (* optional *) SubAddress: CtlT.Any; NewWindow: CtlT.Any; AddHistory: CtlT.Any; ExtraInfo: CtlT.Any; Method: CtlT.Any; HeaderInfo: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.StrVar(Address, arg[6]); CtlC.AnyVar(SubAddress, arg[5]); CtlC.AnyVar(NewWindow, arg[4]); CtlC.AnyVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.AnyVar(Method, arg[1]); CtlC.AnyVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 1470, arg, NIL); END FollowHyperlink; PROCEDURE (this: _Workbook) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 1476, NIL); END AddToFavorites; PROCEDURE (this: _Workbook) IsInplace* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1769) END IsInplace; PROCEDURE (this: _Workbook) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; PROCEDURE (this: _Workbook) WebPagePreview* (), NEW; BEGIN CtlC.CallMethod(this, 1818, NIL); END WebPagePreview; PROCEDURE (this: _Workbook) PublishObjects* (): PublishObjects, NEW; BEGIN RETURN ThisPublishObjects(CtlC.GetAny(this, 1819)) END PublishObjects; PROCEDURE (this: _Workbook) WebOptions* (): WebOptions, NEW; BEGIN RETURN ThisWebOptions(CtlC.GetAny(this, 1820)) END WebOptions; PROCEDURE (this: _Workbook) ReloadAs* (Encoding: CtlOffice.MsoEncoding), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Encoding, arg[0]); CtlC.CallParMethod(this, 1821, arg, NIL); END ReloadAs; PROCEDURE (this: _Workbook) HTMLProject* (): CtlOffice.HTMLProject, NEW; BEGIN RETURN CtlOffice.ThisHTMLProject(CtlC.GetAny(this, 1823)) END HTMLProject; PROCEDURE (this: _Workbook) EnvelopeVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1824) END EnvelopeVisible; PROCEDURE (this: _Workbook) PUTEnvelopeVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1824, p1) END PUTEnvelopeVisible; PROCEDURE (this: _Workbook) CalculationVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1806) END CalculationVersion; PROCEDURE (this: _Workbook) Dummy1* (unused: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(unused, arg[0]); CtlC.CallParMethod(this, 1782, arg, NIL); END Dummy1; PROCEDURE (this: _Workbook) sblt* (s: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(s, arg[0]); CtlC.CallParMethod(this, 1826, arg, NIL); END sblt; PROCEDURE (this: _Workbook) VBASigned* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1828) END VBASigned; (* ---------- Workbooks, dual, nonextensible ---------- *) PROCEDURE (this: Workbooks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Workbooks) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Workbooks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Workbooks) Add* ((* optional *) Template: CtlT.Any): Workbook, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Template, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Workbooks) Close* (), NEW; BEGIN CtlC.CallMethod(this, 277, NIL); END Close; PROCEDURE (this: Workbooks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Workbooks) Item* (Index: CtlT.Any): Workbook, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Workbooks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Workbooks) Open* (Filename: ARRAY OF CHAR; (* optional *) UpdateLinks: CtlT.Any; ReadOnly: CtlT.Any; Format: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; IgnoreReadOnlyRecommended: CtlT.Any; Origin: CtlT.Any; Delimiter: CtlT.Any; Editable: CtlT.Any; Notify: CtlT.Any; Converter: CtlT.Any; AddToMru: CtlT.Any): Workbook, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[12]); CtlC.AnyVar(UpdateLinks, arg[11]); CtlC.AnyVar(ReadOnly, arg[10]); CtlC.AnyVar(Format, arg[9]); CtlC.AnyVar(Password, arg[8]); CtlC.AnyVar(WriteResPassword, arg[7]); CtlC.AnyVar(IgnoreReadOnlyRecommended, arg[6]); CtlC.AnyVar(Origin, arg[5]); CtlC.AnyVar(Delimiter, arg[4]); CtlC.AnyVar(Editable, arg[3]); CtlC.AnyVar(Notify, arg[2]); CtlC.AnyVar(Converter, arg[1]); CtlC.AnyVar(AddToMru, arg[0]); CtlC.CallParMethod(this, 682, arg, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END Open; PROCEDURE (this: Workbooks) _OpenText* (Filename: ARRAY OF CHAR; Origin: CtlT.Any; StartRow: CtlT.Any; DataType: CtlT.Any; TextQualifier: XlTextQualifier; (* optional *) ConsecutiveDelimiter: CtlT.Any; Tab: CtlT.Any; Semicolon: CtlT.Any; Comma: CtlT.Any; Space: CtlT.Any; Other: CtlT.Any; OtherChar: CtlT.Any; FieldInfo: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[13]); CtlC.AnyVar(Origin, arg[12]); CtlC.AnyVar(StartRow, arg[11]); CtlC.AnyVar(DataType, arg[10]); CtlC.IntVar(TextQualifier, arg[9]); CtlC.AnyVar(ConsecutiveDelimiter, arg[8]); CtlC.AnyVar(Tab, arg[7]); CtlC.AnyVar(Semicolon, arg[6]); CtlC.AnyVar(Comma, arg[5]); CtlC.AnyVar(Space, arg[4]); CtlC.AnyVar(Other, arg[3]); CtlC.AnyVar(OtherChar, arg[2]); CtlC.AnyVar(FieldInfo, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 683, arg, NIL); END _OpenText; PROCEDURE (this: Workbooks) _Default* (Index: CtlT.Any): Workbook, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Workbooks) OpenText* (Filename: ARRAY OF CHAR; Origin: CtlT.Any; StartRow: CtlT.Any; DataType: CtlT.Any; TextQualifier: XlTextQualifier; (* optional *) ConsecutiveDelimiter: CtlT.Any; Tab: CtlT.Any; Semicolon: CtlT.Any; Comma: CtlT.Any; Space: CtlT.Any; Other: CtlT.Any; OtherChar: CtlT.Any; FieldInfo: CtlT.Any; TextVisualLayout: CtlT.Any; DecimalSeparator: CtlT.Any; ThousandsSeparator: CtlT.Any), NEW; VAR arg: ARRAY 16 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[15]); CtlC.AnyVar(Origin, arg[14]); CtlC.AnyVar(StartRow, arg[13]); CtlC.AnyVar(DataType, arg[12]); CtlC.IntVar(TextQualifier, arg[11]); CtlC.AnyVar(ConsecutiveDelimiter, arg[10]); CtlC.AnyVar(Tab, arg[9]); CtlC.AnyVar(Semicolon, arg[8]); CtlC.AnyVar(Comma, arg[7]); CtlC.AnyVar(Space, arg[6]); CtlC.AnyVar(Other, arg[5]); CtlC.AnyVar(OtherChar, arg[4]); CtlC.AnyVar(FieldInfo, arg[3]); CtlC.AnyVar(TextVisualLayout, arg[2]); CtlC.AnyVar(DecimalSeparator, arg[1]); CtlC.AnyVar(ThousandsSeparator, arg[0]); CtlC.CallParMethod(this, 1773, arg, NIL); END OpenText; (* ---------- PublishObject, dual, nonextensible ---------- *) PROCEDURE (this: PublishObject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PublishObject) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PublishObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PublishObject) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: PublishObject) Publish* ((* optional *) Create: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Create, arg[0]); CtlC.CallParMethod(this, 1895, arg, NIL); END Publish; PROCEDURE (this: PublishObject) DivID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1894) END DivID; PROCEDURE (this: PublishObject) Sheet* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 751) END Sheet; PROCEDURE (this: PublishObject) SourceType* (): XlSourceType, NEW; BEGIN RETURN CtlC.GetInt(this, 685) END SourceType; PROCEDURE (this: PublishObject) Source* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 222) END Source; PROCEDURE (this: PublishObject) HtmlType* (): XlHtmlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1893) END HtmlType; PROCEDURE (this: PublishObject) PUTHtmlType* (p1: XlHtmlType), NEW; BEGIN CtlC.PutInt(this, 1893, p1) END PUTHtmlType; PROCEDURE (this: PublishObject) Title* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 199) END Title; PROCEDURE (this: PublishObject) PUTTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 199, p1) END PUTTitle; PROCEDURE (this: PublishObject) Filename* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1415) END Filename; PROCEDURE (this: PublishObject) PUTFilename* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1415, p1) END PUTFilename; (* ---------- DefaultWebOptions, dual, nonextensible ---------- *) PROCEDURE (this: DefaultWebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DefaultWebOptions) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DefaultWebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DefaultWebOptions) RelyOnCSS* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1899) END RelyOnCSS; PROCEDURE (this: DefaultWebOptions) PUTRelyOnCSS* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1899, p1) END PUTRelyOnCSS; PROCEDURE (this: DefaultWebOptions) SaveHiddenData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1900) END SaveHiddenData; PROCEDURE (this: DefaultWebOptions) PUTSaveHiddenData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1900, p1) END PUTSaveHiddenData; PROCEDURE (this: DefaultWebOptions) LoadPictures* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1901) END LoadPictures; PROCEDURE (this: DefaultWebOptions) PUTLoadPictures* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1901, p1) END PUTLoadPictures; PROCEDURE (this: DefaultWebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1902) END OrganizeInFolder; PROCEDURE (this: DefaultWebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1902, p1) END PUTOrganizeInFolder; PROCEDURE (this: DefaultWebOptions) UpdateLinksOnSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1903) END UpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) PUTUpdateLinksOnSave* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1903, p1) END PUTUpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1904) END UseLongFileNames; PROCEDURE (this: DefaultWebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1904, p1) END PUTUseLongFileNames; PROCEDURE (this: DefaultWebOptions) CheckIfOfficeIsHTMLEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1905) END CheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) PUTCheckIfOfficeIsHTMLEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1905, p1) END PUTCheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) DownloadComponents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1906) END DownloadComponents; PROCEDURE (this: DefaultWebOptions) PUTDownloadComponents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1906, p1) END PUTDownloadComponents; PROCEDURE (this: DefaultWebOptions) RelyOnVML* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1907) END RelyOnVML; PROCEDURE (this: DefaultWebOptions) PUTRelyOnVML* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1907, p1) END PUTRelyOnVML; PROCEDURE (this: DefaultWebOptions) AllowPNG* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1908) END AllowPNG; PROCEDURE (this: DefaultWebOptions) PUTAllowPNG* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1908, p1) END PUTAllowPNG; PROCEDURE (this: DefaultWebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 1909) END ScreenSize; PROCEDURE (this: DefaultWebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 1909, p1) END PUTScreenSize; PROCEDURE (this: DefaultWebOptions) PixelsPerInch* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1910) END PixelsPerInch; PROCEDURE (this: DefaultWebOptions) PUTPixelsPerInch* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1910, p1) END PUTPixelsPerInch; PROCEDURE (this: DefaultWebOptions) LocationOfComponents* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1911) END LocationOfComponents; PROCEDURE (this: DefaultWebOptions) PUTLocationOfComponents* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1911, p1) END PUTLocationOfComponents; PROCEDURE (this: DefaultWebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 1822) END Encoding; PROCEDURE (this: DefaultWebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 1822, p1) END PUTEncoding; PROCEDURE (this: DefaultWebOptions) AlwaysSaveInDefaultEncoding* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1912) END AlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) PUTAlwaysSaveInDefaultEncoding* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1912, p1) END PUTAlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) Fonts* (): CtlOffice.WebPageFonts, NEW; BEGIN RETURN CtlOffice.ThisWebPageFonts(CtlC.GetAny(this, 1913)) END Fonts; PROCEDURE (this: DefaultWebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1914) END FolderSuffix; (* ---------- WebOptions, dual, nonextensible ---------- *) PROCEDURE (this: WebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: WebOptions) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: WebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: WebOptions) RelyOnCSS* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1899) END RelyOnCSS; PROCEDURE (this: WebOptions) PUTRelyOnCSS* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1899, p1) END PUTRelyOnCSS; PROCEDURE (this: WebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1902) END OrganizeInFolder; PROCEDURE (this: WebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1902, p1) END PUTOrganizeInFolder; PROCEDURE (this: WebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1904) END UseLongFileNames; PROCEDURE (this: WebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1904, p1) END PUTUseLongFileNames; PROCEDURE (this: WebOptions) DownloadComponents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1906) END DownloadComponents; PROCEDURE (this: WebOptions) PUTDownloadComponents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1906, p1) END PUTDownloadComponents; PROCEDURE (this: WebOptions) RelyOnVML* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1907) END RelyOnVML; PROCEDURE (this: WebOptions) PUTRelyOnVML* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1907, p1) END PUTRelyOnVML; PROCEDURE (this: WebOptions) AllowPNG* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1908) END AllowPNG; PROCEDURE (this: WebOptions) PUTAllowPNG* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1908, p1) END PUTAllowPNG; PROCEDURE (this: WebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 1909) END ScreenSize; PROCEDURE (this: WebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 1909, p1) END PUTScreenSize; PROCEDURE (this: WebOptions) PixelsPerInch* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1910) END PixelsPerInch; PROCEDURE (this: WebOptions) PUTPixelsPerInch* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1910, p1) END PUTPixelsPerInch; PROCEDURE (this: WebOptions) LocationOfComponents* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1911) END LocationOfComponents; PROCEDURE (this: WebOptions) PUTLocationOfComponents* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1911, p1) END PUTLocationOfComponents; PROCEDURE (this: WebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 1822) END Encoding; PROCEDURE (this: WebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 1822, p1) END PUTEncoding; PROCEDURE (this: WebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1914) END FolderSuffix; PROCEDURE (this: WebOptions) UseDefaultFolderSuffix* (), NEW; BEGIN CtlC.CallMethod(this, 1915, NIL); END UseDefaultFolderSuffix; (* ---------- TreeviewControl, dual, nonextensible ---------- *) PROCEDURE (this: TreeviewControl) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TreeviewControl) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TreeviewControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TreeviewControl) Hidden* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 268) END Hidden; PROCEDURE (this: TreeviewControl) PUTHidden* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 268, p1) END PUTHidden; PROCEDURE (this: TreeviewControl) Drilled* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1917) END Drilled; PROCEDURE (this: TreeviewControl) PUTDrilled* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1917, p1) END PUTDrilled; (* ---------- CubeField, dual, nonextensible ---------- *) PROCEDURE (this: CubeField) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CubeField) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CubeField) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CubeField) CubeFieldType* (): XlCubeFieldType, NEW; BEGIN RETURN CtlC.GetInt(this, 1918) END CubeFieldType; PROCEDURE (this: CubeField) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: CubeField) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: CubeField) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: CubeField) Orientation* (): XlPivotFieldOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: CubeField) PUTOrientation* (p1: XlPivotFieldOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: CubeField) Position* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: CubeField) PUTPosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: CubeField) TreeviewControl* (): TreeviewControl, NEW; BEGIN RETURN ThisTreeviewControl(CtlC.GetAny(this, 1919)) END TreeviewControl; PROCEDURE (this: CubeField) DragToColumn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1508) END DragToColumn; PROCEDURE (this: CubeField) PUTDragToColumn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1508, p1) END PUTDragToColumn; PROCEDURE (this: CubeField) DragToHide* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1509) END DragToHide; PROCEDURE (this: CubeField) PUTDragToHide* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1509, p1) END PUTDragToHide; PROCEDURE (this: CubeField) DragToPage* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1510) END DragToPage; PROCEDURE (this: CubeField) PUTDragToPage* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1510, p1) END PUTDragToPage; PROCEDURE (this: CubeField) DragToRow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1511) END DragToRow; PROCEDURE (this: CubeField) PUTDragToRow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1511, p1) END PUTDragToRow; PROCEDURE (this: CubeField) DragToData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1844) END DragToData; PROCEDURE (this: CubeField) PUTDragToData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1844, p1) END PUTDragToData; PROCEDURE (this: CubeField) HiddenLevels* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1920) END HiddenLevels; PROCEDURE (this: CubeField) PUTHiddenLevels* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1920, p1) END PUTHiddenLevels; (* ---------- CubeFields, dual, nonextensible ---------- *) PROCEDURE (this: CubeFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CubeFields) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CubeFields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CubeFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: CubeFields) Item* (Index: CtlT.Any): CubeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisCubeField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CubeFields) _Default* (Index: CtlT.Any): CubeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisCubeField(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: CubeFields) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Font ---------- *) PROCEDURE (this: Font) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Font) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Font) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Font) Background* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 180) END Background; PROCEDURE (this: Font) PUTBackground* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 180, p1) END PUTBackground; PROCEDURE (this: Font) Bold* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 96) END Bold; PROCEDURE (this: Font) PUTBold* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 96, p1) END PUTBold; PROCEDURE (this: Font) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Font) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Font) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Font) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Font) FontStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 177) END FontStyle; PROCEDURE (this: Font) PUTFontStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 177, p1) END PUTFontStyle; PROCEDURE (this: Font) Italic* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Italic; PROCEDURE (this: Font) PUTItalic* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 101, p1) END PUTItalic; PROCEDURE (this: Font) Name* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 110) END Name; PROCEDURE (this: Font) PUTName* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 110, p1) END PUTName; PROCEDURE (this: Font) OutlineFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 221) END OutlineFont; PROCEDURE (this: Font) PUTOutlineFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 221, p1) END PUTOutlineFont; PROCEDURE (this: Font) Shadow* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 103) END Shadow; PROCEDURE (this: Font) PUTShadow* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 103, p1) END PUTShadow; PROCEDURE (this: Font) Size* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 104) END Size; PROCEDURE (this: Font) PUTSize* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 104, p1) END PUTSize; PROCEDURE (this: Font) Strikethrough* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 105) END Strikethrough; PROCEDURE (this: Font) PUTStrikethrough* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 105, p1) END PUTStrikethrough; PROCEDURE (this: Font) Subscript* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 179) END Subscript; PROCEDURE (this: Font) PUTSubscript* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 179, p1) END PUTSubscript; PROCEDURE (this: Font) Superscript* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 178) END Superscript; PROCEDURE (this: Font) PUTSuperscript* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 178, p1) END PUTSuperscript; PROCEDURE (this: Font) Underline* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 106) END Underline; PROCEDURE (this: Font) PUTUnderline* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 106, p1) END PUTUnderline; (* ---------- Window ---------- *) PROCEDURE (this: Window) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Window) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Window) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Window) Activate* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 304, ret); RETURN CtlC.VarAny(ret) END Activate; PROCEDURE (this: Window) ActivateNext* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1115, ret); RETURN CtlC.VarAny(ret) END ActivateNext; PROCEDURE (this: Window) ActivatePrevious* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1116, ret); RETURN CtlC.VarAny(ret) END ActivatePrevious; PROCEDURE (this: Window) ActiveCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 305)) END ActiveCell; PROCEDURE (this: Window) ActiveChart* (): Chart, NEW; BEGIN RETURN This_Chart(CtlC.GetAny(this, 183)) END ActiveChart; PROCEDURE (this: Window) ActivePane* (): Pane, NEW; BEGIN RETURN ThisPane(CtlC.GetAny(this, 642)) END ActivePane; PROCEDURE (this: Window) ActiveSheet* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 307) END ActiveSheet; PROCEDURE (this: Window) Caption* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 139) END Caption; PROCEDURE (this: Window) PUTCaption* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 139, p1) END PUTCaption; PROCEDURE (this: Window) Close* ((* optional *) SaveChanges: CtlT.Any; Filename: CtlT.Any; RouteWorkbook: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[2]); CtlC.AnyVar(Filename, arg[1]); CtlC.AnyVar(RouteWorkbook, arg[0]); CtlC.CallParMethod(this, 277, arg, ret); RETURN CtlC.VarBool(ret) END Close; PROCEDURE (this: Window) DisplayFormulas* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 644) END DisplayFormulas; PROCEDURE (this: Window) PUTDisplayFormulas* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 644, p1) END PUTDisplayFormulas; PROCEDURE (this: Window) DisplayGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 645) END DisplayGridlines; PROCEDURE (this: Window) PUTDisplayGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 645, p1) END PUTDisplayGridlines; PROCEDURE (this: Window) DisplayHeadings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 646) END DisplayHeadings; PROCEDURE (this: Window) PUTDisplayHeadings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 646, p1) END PUTDisplayHeadings; PROCEDURE (this: Window) DisplayHorizontalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 921) END DisplayHorizontalScrollBar; PROCEDURE (this: Window) PUTDisplayHorizontalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 921, p1) END PUTDisplayHorizontalScrollBar; PROCEDURE (this: Window) DisplayOutline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 647) END DisplayOutline; PROCEDURE (this: Window) PUTDisplayOutline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 647, p1) END PUTDisplayOutline; PROCEDURE (this: Window) _DisplayRightToLeft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 648) END _DisplayRightToLeft; PROCEDURE (this: Window) PUT_DisplayRightToLeft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 648, p1) END PUT_DisplayRightToLeft; PROCEDURE (this: Window) DisplayVerticalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 922) END DisplayVerticalScrollBar; PROCEDURE (this: Window) PUTDisplayVerticalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 922, p1) END PUTDisplayVerticalScrollBar; PROCEDURE (this: Window) DisplayWorkbookTabs* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 923) END DisplayWorkbookTabs; PROCEDURE (this: Window) PUTDisplayWorkbookTabs* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 923, p1) END PUTDisplayWorkbookTabs; PROCEDURE (this: Window) DisplayZeros* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 649) END DisplayZeros; PROCEDURE (this: Window) PUTDisplayZeros* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 649, p1) END PUTDisplayZeros; PROCEDURE (this: Window) EnableResize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1192) END EnableResize; PROCEDURE (this: Window) PUTEnableResize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1192, p1) END PUTEnableResize; PROCEDURE (this: Window) FreezePanes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 650) END FreezePanes; PROCEDURE (this: Window) PUTFreezePanes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 650, p1) END PUTFreezePanes; PROCEDURE (this: Window) GridlineColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 651) END GridlineColor; PROCEDURE (this: Window) PUTGridlineColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 651, p1) END PUTGridlineColor; PROCEDURE (this: Window) GridlineColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 652) END GridlineColorIndex; PROCEDURE (this: Window) PUTGridlineColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 652, p1) END PUTGridlineColorIndex; PROCEDURE (this: Window) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Window) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Window) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Window) LargeScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 547, arg, ret); RETURN CtlC.VarAny(ret) END LargeScroll; PROCEDURE (this: Window) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Window) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Window) NewWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 280, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: Window) OnWindow* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 623) END OnWindow; PROCEDURE (this: Window) PUTOnWindow* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 623, p1) END PUTOnWindow; PROCEDURE (this: Window) Panes* (): Panes, NEW; BEGIN RETURN ThisPanes(CtlC.GetAny(this, 653)) END Panes; PROCEDURE (this: Window) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, ret); RETURN CtlC.VarAny(ret) END PrintOut; PROCEDURE (this: Window) PrintPreview* ((* optional *) EnableChanges: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, ret); RETURN CtlC.VarAny(ret) END PrintPreview; PROCEDURE (this: Window) RangeSelection* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1189)) END RangeSelection; PROCEDURE (this: Window) ScrollColumn* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 654) END ScrollColumn; PROCEDURE (this: Window) PUTScrollColumn* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 654, p1) END PUTScrollColumn; PROCEDURE (this: Window) ScrollRow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 655) END ScrollRow; PROCEDURE (this: Window) PUTScrollRow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 655, p1) END PUTScrollRow; PROCEDURE (this: Window) ScrollWorkbookTabs* ((* optional *) Sheets: CtlT.Any; Position: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Sheets, arg[1]); CtlC.AnyVar(Position, arg[0]); CtlC.CallParMethod(this, 662, arg, ret); RETURN CtlC.VarAny(ret) END ScrollWorkbookTabs; PROCEDURE (this: Window) SelectedSheets* (): Sheets, NEW; BEGIN RETURN ThisSheets(CtlC.GetAny(this, 656)) END SelectedSheets; PROCEDURE (this: Window) Selection* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 147) END Selection; PROCEDURE (this: Window) SmallScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 548, arg, ret); RETURN CtlC.VarAny(ret) END SmallScroll; PROCEDURE (this: Window) Split* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 657) END Split; PROCEDURE (this: Window) PUTSplit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 657, p1) END PUTSplit; PROCEDURE (this: Window) SplitColumn* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 658) END SplitColumn; PROCEDURE (this: Window) PUTSplitColumn* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 658, p1) END PUTSplitColumn; PROCEDURE (this: Window) SplitHorizontal* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 659) END SplitHorizontal; PROCEDURE (this: Window) PUTSplitHorizontal* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 659, p1) END PUTSplitHorizontal; PROCEDURE (this: Window) SplitRow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 660) END SplitRow; PROCEDURE (this: Window) PUTSplitRow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 660, p1) END PUTSplitRow; PROCEDURE (this: Window) SplitVertical* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 661) END SplitVertical; PROCEDURE (this: Window) PUTSplitVertical* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 661, p1) END PUTSplitVertical; PROCEDURE (this: Window) TabRatio* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 673) END TabRatio; PROCEDURE (this: Window) PUTTabRatio* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 673, p1) END PUTTabRatio; PROCEDURE (this: Window) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Window) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Window) Type* (): XlWindowType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Window) UsableHeight* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 389) END UsableHeight; PROCEDURE (this: Window) UsableWidth* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 390) END UsableWidth; PROCEDURE (this: Window) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Window) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Window) VisibleRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1118)) END VisibleRange; PROCEDURE (this: Window) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Window) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Window) WindowNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1119) END WindowNumber; PROCEDURE (this: Window) WindowState* (): XlWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 396) END WindowState; PROCEDURE (this: Window) PUTWindowState* (p1: XlWindowState), NEW; BEGIN CtlC.PutInt(this, 396, p1) END PUTWindowState; PROCEDURE (this: Window) Zoom* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 663) END Zoom; PROCEDURE (this: Window) PUTZoom* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 663, p1) END PUTZoom; PROCEDURE (this: Window) View* (): XlWindowView, NEW; BEGIN RETURN CtlC.GetInt(this, 1194) END View; PROCEDURE (this: Window) PUTView* (p1: XlWindowView), NEW; BEGIN CtlC.PutInt(this, 1194, p1) END PUTView; PROCEDURE (this: Window) DisplayRightToLeft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1774) END DisplayRightToLeft; PROCEDURE (this: Window) PUTDisplayRightToLeft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1774, p1) END PUTDisplayRightToLeft; PROCEDURE (this: Window) PointsToScreenPixelsX* (Points: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Points, arg[0]); CtlC.CallParMethod(this, 1776, arg, ret); RETURN CtlC.VarInt(ret) END PointsToScreenPixelsX; PROCEDURE (this: Window) PointsToScreenPixelsY* (Points: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Points, arg[0]); CtlC.CallParMethod(this, 1777, arg, ret); RETURN CtlC.VarInt(ret) END PointsToScreenPixelsY; PROCEDURE (this: Window) RangeFromPoint* (x: INTEGER; y: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(x, arg[1]); CtlC.IntVar(y, arg[0]); CtlC.CallParMethod(this, 1778, arg, ret); RETURN CtlC.VarObj(ret) END RangeFromPoint; PROCEDURE (this: Window) ScrollIntoView* (Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[4]); CtlC.IntVar(Top, arg[3]); CtlC.IntVar(Width, arg[2]); CtlC.IntVar(Height, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1781, arg, NIL); END ScrollIntoView; (* ---------- Windows ---------- *) PROCEDURE (this: Windows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Windows) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Windows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Windows) Arrange* (ArrangeStyle: XlArrangeStyle; (* optional *) ActiveWorkbook: CtlT.Any; SyncHorizontal: CtlT.Any; SyncVertical: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ArrangeStyle, arg[3]); CtlC.AnyVar(ActiveWorkbook, arg[2]); CtlC.AnyVar(SyncHorizontal, arg[1]); CtlC.AnyVar(SyncVertical, arg[0]); CtlC.CallParMethod(this, 638, arg, ret); RETURN CtlC.VarAny(ret) END Arrange; PROCEDURE (this: Windows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Windows) Item* (Index: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Windows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Windows) _Default* (Index: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END _Default; (* ---------- AppEvents, hidden ---------- *) PROCEDURE (this: AppEvents) NewWorkbook* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetSelectionChange* (Sh: CtlT.Object; Target: Range), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetBeforeDoubleClick* (Sh: CtlT.Object; Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetBeforeRightClick* (Sh: CtlT.Object; Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetActivate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetDeactivate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetCalculate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetChange* (Sh: CtlT.Object; Target: Range), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookOpen* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookActivate* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookDeactivate* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookBeforeClose* (Wb: Workbook; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookBeforeSave* (Wb: Workbook; SaveAsUI: BOOLEAN; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookBeforePrint* (Wb: Workbook; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookNewSheet* (Wb: Workbook; Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookAddinInstall* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WorkbookAddinUninstall* (Wb: Workbook), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WindowResize* (Wb: Workbook; Wn: Window), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WindowActivate* (Wb: Workbook; Wn: Window), NEW, ABSTRACT; PROCEDURE (this: AppEvents) WindowDeactivate* (Wb: Workbook; Wn: Window), NEW, ABSTRACT; PROCEDURE (this: AppEvents) SheetFollowHyperlink* (Sh: CtlT.Object; Target: Hyperlink), NEW, ABSTRACT; PROCEDURE (this: AppEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1565: ASSERT(n = 1, 11); this.NewWorkbook(This_Workbook(CtlC.VarAny(par[0]))) | 1558: ASSERT(n = 2, 11); this.SheetSelectionChange(CtlC.VarObj(par[1]), ThisRange(CtlC.VarAny(par[0]))) | 1559: ASSERT(n = 3, 11); this.SheetBeforeDoubleClick(CtlC.VarObj(par[2]), ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1560: ASSERT(n = 3, 11); this.SheetBeforeRightClick(CtlC.VarObj(par[2]), ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1561: ASSERT(n = 1, 11); this.SheetActivate(CtlC.VarObj(par[0])) | 1562: ASSERT(n = 1, 11); this.SheetDeactivate(CtlC.VarObj(par[0])) | 1563: ASSERT(n = 1, 11); this.SheetCalculate(CtlC.VarObj(par[0])) | 1564: ASSERT(n = 2, 11); this.SheetChange(CtlC.VarObj(par[1]), ThisRange(CtlC.VarAny(par[0]))) | 1567: ASSERT(n = 1, 11); this.WorkbookOpen(This_Workbook(CtlC.VarAny(par[0]))) | 1568: ASSERT(n = 1, 11); this.WorkbookActivate(This_Workbook(CtlC.VarAny(par[0]))) | 1569: ASSERT(n = 1, 11); this.WorkbookDeactivate(This_Workbook(CtlC.VarAny(par[0]))) | 1570: ASSERT(n = 2, 11); this.WorkbookBeforeClose(This_Workbook(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1571: ASSERT(n = 3, 11); this.WorkbookBeforeSave(This_Workbook(CtlC.VarAny(par[2])), CtlC.VarBool(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1572: ASSERT(n = 2, 11); this.WorkbookBeforePrint(This_Workbook(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1573: ASSERT(n = 2, 11); this.WorkbookNewSheet(This_Workbook(CtlC.VarAny(par[1])), CtlC.VarObj(par[0])) | 1574: ASSERT(n = 1, 11); this.WorkbookAddinInstall(This_Workbook(CtlC.VarAny(par[0]))) | 1575: ASSERT(n = 1, 11); this.WorkbookAddinUninstall(This_Workbook(CtlC.VarAny(par[0]))) | 1554: ASSERT(n = 2, 11); this.WindowResize(This_Workbook(CtlC.VarAny(par[1])), ThisWindow(CtlC.VarAny(par[0]))) | 1556: ASSERT(n = 2, 11); this.WindowActivate(This_Workbook(CtlC.VarAny(par[1])), ThisWindow(CtlC.VarAny(par[0]))) | 1557: ASSERT(n = 2, 11); this.WindowDeactivate(This_Workbook(CtlC.VarAny(par[1])), ThisWindow(CtlC.VarAny(par[0]))) | 1854: ASSERT(n = 2, 11); this.SheetFollowHyperlink(CtlC.VarObj(par[1]), ThisHyperlink(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: AppEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00024413-0000-0000-C000-000000000046}" END GetIID; (* ---------- WorksheetFunction ---------- *) PROCEDURE (this: WorksheetFunction) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: WorksheetFunction) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: WorksheetFunction) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: WorksheetFunction) _WSFunction* ((* optional *) Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 169, arg, ret); RETURN CtlC.VarAny(ret) END _WSFunction; PROCEDURE (this: WorksheetFunction) Count* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16384, arg, ret); RETURN CtlC.VarReal(ret) END Count; PROCEDURE (this: WorksheetFunction) IsNA* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16386, arg, ret); RETURN CtlC.VarBool(ret) END IsNA; PROCEDURE (this: WorksheetFunction) IsError* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16387, arg, ret); RETURN CtlC.VarBool(ret) END IsError; PROCEDURE (this: WorksheetFunction) Sum* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16388, arg, ret); RETURN CtlC.VarReal(ret) END Sum; PROCEDURE (this: WorksheetFunction) Average* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16389, arg, ret); RETURN CtlC.VarReal(ret) END Average; PROCEDURE (this: WorksheetFunction) Min* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16390, arg, ret); RETURN CtlC.VarReal(ret) END Min; PROCEDURE (this: WorksheetFunction) Max* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16391, arg, ret); RETURN CtlC.VarReal(ret) END Max; PROCEDURE (this: WorksheetFunction) Npv* (Arg1: REAL; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16395, arg, ret); RETURN CtlC.VarReal(ret) END Npv; PROCEDURE (this: WorksheetFunction) StDev* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16396, arg, ret); RETURN CtlC.VarReal(ret) END StDev; PROCEDURE (this: WorksheetFunction) Dollar* (Arg1: REAL; (* optional *) Arg2: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16397, arg, ret); RETURN CtlC.VarStr(ret) END Dollar; PROCEDURE (this: WorksheetFunction) Fixed* (Arg1: REAL; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16398, arg, ret); RETURN CtlC.VarStr(ret) END Fixed; PROCEDURE (this: WorksheetFunction) Pi* (): REAL, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 16403, ret); RETURN CtlC.VarReal(ret) END Pi; PROCEDURE (this: WorksheetFunction) Ln* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16406, arg, ret); RETURN CtlC.VarReal(ret) END Ln; PROCEDURE (this: WorksheetFunction) Log10* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16407, arg, ret); RETURN CtlC.VarReal(ret) END Log10; PROCEDURE (this: WorksheetFunction) Round* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16411, arg, ret); RETURN CtlC.VarReal(ret) END Round; PROCEDURE (this: WorksheetFunction) Lookup* (Arg1: CtlT.Any; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16412, arg, ret); RETURN CtlC.VarAny(ret) END Lookup; PROCEDURE (this: WorksheetFunction) Index* (Arg1: CtlT.Any; Arg2: REAL; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16413, arg, ret); RETURN CtlC.VarAny(ret) END Index; PROCEDURE (this: WorksheetFunction) Rept* (Arg1: ARRAY OF CHAR; Arg2: REAL): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16414, arg, ret); RETURN CtlC.VarStr(ret) END Rept; PROCEDURE (this: WorksheetFunction) And* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16420, arg, ret); RETURN CtlC.VarBool(ret) END And; PROCEDURE (this: WorksheetFunction) Or* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16421, arg, ret); RETURN CtlC.VarBool(ret) END Or; PROCEDURE (this: WorksheetFunction) DCount* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16424, arg, ret); RETURN CtlC.VarReal(ret) END DCount; PROCEDURE (this: WorksheetFunction) DSum* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16425, arg, ret); RETURN CtlC.VarReal(ret) END DSum; PROCEDURE (this: WorksheetFunction) DAverage* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16426, arg, ret); RETURN CtlC.VarReal(ret) END DAverage; PROCEDURE (this: WorksheetFunction) DMin* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16427, arg, ret); RETURN CtlC.VarReal(ret) END DMin; PROCEDURE (this: WorksheetFunction) DMax* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16428, arg, ret); RETURN CtlC.VarReal(ret) END DMax; PROCEDURE (this: WorksheetFunction) DStDev* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16429, arg, ret); RETURN CtlC.VarReal(ret) END DStDev; PROCEDURE (this: WorksheetFunction) Var* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16430, arg, ret); RETURN CtlC.VarReal(ret) END Var; PROCEDURE (this: WorksheetFunction) DVar* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16431, arg, ret); RETURN CtlC.VarReal(ret) END DVar; PROCEDURE (this: WorksheetFunction) Text* (Arg1: CtlT.Any; Arg2: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.StrVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16432, arg, ret); RETURN CtlC.VarStr(ret) END Text; PROCEDURE (this: WorksheetFunction) LinEst* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16433, arg, ret); RETURN CtlC.VarAny(ret) END LinEst; PROCEDURE (this: WorksheetFunction) Trend* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16434, arg, ret); RETURN CtlC.VarAny(ret) END Trend; PROCEDURE (this: WorksheetFunction) LogEst* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16435, arg, ret); RETURN CtlC.VarAny(ret) END LogEst; PROCEDURE (this: WorksheetFunction) Growth* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16436, arg, ret); RETURN CtlC.VarAny(ret) END Growth; PROCEDURE (this: WorksheetFunction) Pv* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16440, arg, ret); RETURN CtlC.VarReal(ret) END Pv; PROCEDURE (this: WorksheetFunction) Fv* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16441, arg, ret); RETURN CtlC.VarReal(ret) END Fv; PROCEDURE (this: WorksheetFunction) NPer* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16442, arg, ret); RETURN CtlC.VarReal(ret) END NPer; PROCEDURE (this: WorksheetFunction) Pmt* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16443, arg, ret); RETURN CtlC.VarReal(ret) END Pmt; PROCEDURE (this: WorksheetFunction) Rate* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any): REAL, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[5]); CtlC.RealVar(Arg2, arg[4]); CtlC.RealVar(Arg3, arg[3]); CtlC.AnyVar(Arg4, arg[2]); CtlC.AnyVar(Arg5, arg[1]); CtlC.AnyVar(Arg6, arg[0]); CtlC.CallParMethod(this, 16444, arg, ret); RETURN CtlC.VarReal(ret) END Rate; PROCEDURE (this: WorksheetFunction) MIrr* (Arg1: CtlT.Any; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16445, arg, ret); RETURN CtlC.VarReal(ret) END MIrr; PROCEDURE (this: WorksheetFunction) Irr* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16446, arg, ret); RETURN CtlC.VarReal(ret) END Irr; PROCEDURE (this: WorksheetFunction) Match* (Arg1: CtlT.Any; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16448, arg, ret); RETURN CtlC.VarReal(ret) END Match; PROCEDURE (this: WorksheetFunction) Weekday* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16454, arg, ret); RETURN CtlC.VarReal(ret) END Weekday; PROCEDURE (this: WorksheetFunction) Search* (Arg1: ARRAY OF CHAR; Arg2: ARRAY OF CHAR; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[2]); CtlC.StrVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16466, arg, ret); RETURN CtlC.VarReal(ret) END Search; PROCEDURE (this: WorksheetFunction) Transpose* (Arg1: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16467, arg, ret); RETURN CtlC.VarAny(ret) END Transpose; PROCEDURE (this: WorksheetFunction) Atan2* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16481, arg, ret); RETURN CtlC.VarReal(ret) END Atan2; PROCEDURE (this: WorksheetFunction) Asin* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16482, arg, ret); RETURN CtlC.VarReal(ret) END Asin; PROCEDURE (this: WorksheetFunction) Acos* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16483, arg, ret); RETURN CtlC.VarReal(ret) END Acos; PROCEDURE (this: WorksheetFunction) Choose* (Arg1: CtlT.Any; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16484, arg, ret); RETURN CtlC.VarAny(ret) END Choose; PROCEDURE (this: WorksheetFunction) HLookup* (Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; (* optional *) Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16485, arg, ret); RETURN CtlC.VarAny(ret) END HLookup; PROCEDURE (this: WorksheetFunction) VLookup* (Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; (* optional *) Arg4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16486, arg, ret); RETURN CtlC.VarAny(ret) END VLookup; PROCEDURE (this: WorksheetFunction) Log* (Arg1: REAL; (* optional *) Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16493, arg, ret); RETURN CtlC.VarReal(ret) END Log; PROCEDURE (this: WorksheetFunction) Proper* (Arg1: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16498, arg, ret); RETURN CtlC.VarStr(ret) END Proper; PROCEDURE (this: WorksheetFunction) Trim* (Arg1: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16502, arg, ret); RETURN CtlC.VarStr(ret) END Trim; PROCEDURE (this: WorksheetFunction) Replace* (Arg1: ARRAY OF CHAR; Arg2: REAL; Arg3: REAL; Arg4: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.StrVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16503, arg, ret); RETURN CtlC.VarStr(ret) END Replace; PROCEDURE (this: WorksheetFunction) Substitute* (Arg1: ARRAY OF CHAR; Arg2: ARRAY OF CHAR; Arg3: ARRAY OF CHAR; (* optional *) Arg4: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[3]); CtlC.StrVar(Arg2, arg[2]); CtlC.StrVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16504, arg, ret); RETURN CtlC.VarStr(ret) END Substitute; PROCEDURE (this: WorksheetFunction) Find* (Arg1: ARRAY OF CHAR; Arg2: ARRAY OF CHAR; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[2]); CtlC.StrVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16508, arg, ret); RETURN CtlC.VarReal(ret) END Find; PROCEDURE (this: WorksheetFunction) IsErr* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16510, arg, ret); RETURN CtlC.VarBool(ret) END IsErr; PROCEDURE (this: WorksheetFunction) IsText* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16511, arg, ret); RETURN CtlC.VarBool(ret) END IsText; PROCEDURE (this: WorksheetFunction) IsNumber* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16512, arg, ret); RETURN CtlC.VarBool(ret) END IsNumber; PROCEDURE (this: WorksheetFunction) Sln* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16526, arg, ret); RETURN CtlC.VarReal(ret) END Sln; PROCEDURE (this: WorksheetFunction) Syd* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.RealVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16527, arg, ret); RETURN CtlC.VarReal(ret) END Syd; PROCEDURE (this: WorksheetFunction) Ddb* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL; (* optional *) Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.RealVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16528, arg, ret); RETURN CtlC.VarReal(ret) END Ddb; PROCEDURE (this: WorksheetFunction) Clean* (Arg1: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16546, arg, ret); RETURN CtlC.VarStr(ret) END Clean; PROCEDURE (this: WorksheetFunction) MDeterm* (Arg1: CtlT.Any): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16547, arg, ret); RETURN CtlC.VarReal(ret) END MDeterm; PROCEDURE (this: WorksheetFunction) MInverse* (Arg1: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16548, arg, ret); RETURN CtlC.VarAny(ret) END MInverse; PROCEDURE (this: WorksheetFunction) MMult* (Arg1: CtlT.Any; Arg2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16549, arg, ret); RETURN CtlC.VarAny(ret) END MMult; PROCEDURE (this: WorksheetFunction) Ipmt* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL; (* optional *) Arg5: CtlT.Any; Arg6: CtlT.Any): REAL, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[5]); CtlC.RealVar(Arg2, arg[4]); CtlC.RealVar(Arg3, arg[3]); CtlC.RealVar(Arg4, arg[2]); CtlC.AnyVar(Arg5, arg[1]); CtlC.AnyVar(Arg6, arg[0]); CtlC.CallParMethod(this, 16551, arg, ret); RETURN CtlC.VarReal(ret) END Ipmt; PROCEDURE (this: WorksheetFunction) Ppmt* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL; (* optional *) Arg5: CtlT.Any; Arg6: CtlT.Any): REAL, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[5]); CtlC.RealVar(Arg2, arg[4]); CtlC.RealVar(Arg3, arg[3]); CtlC.RealVar(Arg4, arg[2]); CtlC.AnyVar(Arg5, arg[1]); CtlC.AnyVar(Arg6, arg[0]); CtlC.CallParMethod(this, 16552, arg, ret); RETURN CtlC.VarReal(ret) END Ppmt; PROCEDURE (this: WorksheetFunction) CountA* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16553, arg, ret); RETURN CtlC.VarReal(ret) END CountA; PROCEDURE (this: WorksheetFunction) Product* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16567, arg, ret); RETURN CtlC.VarReal(ret) END Product; PROCEDURE (this: WorksheetFunction) Fact* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16568, arg, ret); RETURN CtlC.VarReal(ret) END Fact; PROCEDURE (this: WorksheetFunction) DProduct* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16573, arg, ret); RETURN CtlC.VarReal(ret) END DProduct; PROCEDURE (this: WorksheetFunction) IsNonText* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16574, arg, ret); RETURN CtlC.VarBool(ret) END IsNonText; PROCEDURE (this: WorksheetFunction) StDevP* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16577, arg, ret); RETURN CtlC.VarReal(ret) END StDevP; PROCEDURE (this: WorksheetFunction) VarP* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16578, arg, ret); RETURN CtlC.VarReal(ret) END VarP; PROCEDURE (this: WorksheetFunction) DStDevP* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16579, arg, ret); RETURN CtlC.VarReal(ret) END DStDevP; PROCEDURE (this: WorksheetFunction) DVarP* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16580, arg, ret); RETURN CtlC.VarReal(ret) END DVarP; PROCEDURE (this: WorksheetFunction) IsLogical* (Arg1: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16582, arg, ret); RETURN CtlC.VarBool(ret) END IsLogical; PROCEDURE (this: WorksheetFunction) DCountA* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16583, arg, ret); RETURN CtlC.VarReal(ret) END DCountA; PROCEDURE (this: WorksheetFunction) USDollar* (Arg1: REAL; Arg2: REAL): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16588, arg, ret); RETURN CtlC.VarStr(ret) END USDollar; PROCEDURE (this: WorksheetFunction) FindB* (Arg1: ARRAY OF CHAR; Arg2: ARRAY OF CHAR; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[2]); CtlC.StrVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16589, arg, ret); RETURN CtlC.VarReal(ret) END FindB; PROCEDURE (this: WorksheetFunction) SearchB* (Arg1: ARRAY OF CHAR; Arg2: ARRAY OF CHAR; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[2]); CtlC.StrVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16590, arg, ret); RETURN CtlC.VarReal(ret) END SearchB; PROCEDURE (this: WorksheetFunction) ReplaceB* (Arg1: ARRAY OF CHAR; Arg2: REAL; Arg3: REAL; Arg4: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.StrVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16591, arg, ret); RETURN CtlC.VarStr(ret) END ReplaceB; PROCEDURE (this: WorksheetFunction) RoundUp* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16596, arg, ret); RETURN CtlC.VarReal(ret) END RoundUp; PROCEDURE (this: WorksheetFunction) RoundDown* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16597, arg, ret); RETURN CtlC.VarReal(ret) END RoundDown; PROCEDURE (this: WorksheetFunction) Rank* (Arg1: REAL; Arg2: Range; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.ObjVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16600, arg, ret); RETURN CtlC.VarReal(ret) END Rank; PROCEDURE (this: WorksheetFunction) Days360* (Arg1: CtlT.Any; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16604, arg, ret); RETURN CtlC.VarReal(ret) END Days360; PROCEDURE (this: WorksheetFunction) Vdb* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL; Arg5: REAL; (* optional *) Arg6: CtlT.Any; Arg7: CtlT.Any): REAL, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[6]); CtlC.RealVar(Arg2, arg[5]); CtlC.RealVar(Arg3, arg[4]); CtlC.RealVar(Arg4, arg[3]); CtlC.RealVar(Arg5, arg[2]); CtlC.AnyVar(Arg6, arg[1]); CtlC.AnyVar(Arg7, arg[0]); CtlC.CallParMethod(this, 16606, arg, ret); RETURN CtlC.VarReal(ret) END Vdb; PROCEDURE (this: WorksheetFunction) Median* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16611, arg, ret); RETURN CtlC.VarReal(ret) END Median; PROCEDURE (this: WorksheetFunction) SumProduct* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16612, arg, ret); RETURN CtlC.VarReal(ret) END SumProduct; PROCEDURE (this: WorksheetFunction) Sinh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16613, arg, ret); RETURN CtlC.VarReal(ret) END Sinh; PROCEDURE (this: WorksheetFunction) Cosh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16614, arg, ret); RETURN CtlC.VarReal(ret) END Cosh; PROCEDURE (this: WorksheetFunction) Tanh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16615, arg, ret); RETURN CtlC.VarReal(ret) END Tanh; PROCEDURE (this: WorksheetFunction) Asinh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16616, arg, ret); RETURN CtlC.VarReal(ret) END Asinh; PROCEDURE (this: WorksheetFunction) Acosh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16617, arg, ret); RETURN CtlC.VarReal(ret) END Acosh; PROCEDURE (this: WorksheetFunction) Atanh* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16618, arg, ret); RETURN CtlC.VarReal(ret) END Atanh; PROCEDURE (this: WorksheetFunction) DGet* (Arg1: Range; Arg2: CtlT.Any; Arg3: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16619, arg, ret); RETURN CtlC.VarAny(ret) END DGet; PROCEDURE (this: WorksheetFunction) Db* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL; (* optional *) Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.RealVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16631, arg, ret); RETURN CtlC.VarReal(ret) END Db; PROCEDURE (this: WorksheetFunction) Frequency* (Arg1: CtlT.Any; Arg2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16636, arg, ret); RETURN CtlC.VarAny(ret) END Frequency; PROCEDURE (this: WorksheetFunction) AveDev* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16653, arg, ret); RETURN CtlC.VarReal(ret) END AveDev; PROCEDURE (this: WorksheetFunction) BetaDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16654, arg, ret); RETURN CtlC.VarReal(ret) END BetaDist; PROCEDURE (this: WorksheetFunction) GammaLn* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16655, arg, ret); RETURN CtlC.VarReal(ret) END GammaLn; PROCEDURE (this: WorksheetFunction) BetaInv* (Arg1: REAL; Arg2: REAL; Arg3: REAL; (* optional *) Arg4: CtlT.Any; Arg5: CtlT.Any): REAL, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[4]); CtlC.RealVar(Arg2, arg[3]); CtlC.RealVar(Arg3, arg[2]); CtlC.AnyVar(Arg4, arg[1]); CtlC.AnyVar(Arg5, arg[0]); CtlC.CallParMethod(this, 16656, arg, ret); RETURN CtlC.VarReal(ret) END BetaInv; PROCEDURE (this: WorksheetFunction) BinomDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: BOOLEAN): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.BoolVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16657, arg, ret); RETURN CtlC.VarReal(ret) END BinomDist; PROCEDURE (this: WorksheetFunction) ChiDist* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16658, arg, ret); RETURN CtlC.VarReal(ret) END ChiDist; PROCEDURE (this: WorksheetFunction) ChiInv* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16659, arg, ret); RETURN CtlC.VarReal(ret) END ChiInv; PROCEDURE (this: WorksheetFunction) Combin* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16660, arg, ret); RETURN CtlC.VarReal(ret) END Combin; PROCEDURE (this: WorksheetFunction) Confidence* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16661, arg, ret); RETURN CtlC.VarReal(ret) END Confidence; PROCEDURE (this: WorksheetFunction) CritBinom* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16662, arg, ret); RETURN CtlC.VarReal(ret) END CritBinom; PROCEDURE (this: WorksheetFunction) Even* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16663, arg, ret); RETURN CtlC.VarReal(ret) END Even; PROCEDURE (this: WorksheetFunction) ExponDist* (Arg1: REAL; Arg2: REAL; Arg3: BOOLEAN): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.BoolVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16664, arg, ret); RETURN CtlC.VarReal(ret) END ExponDist; PROCEDURE (this: WorksheetFunction) FDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16665, arg, ret); RETURN CtlC.VarReal(ret) END FDist; PROCEDURE (this: WorksheetFunction) FInv* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16666, arg, ret); RETURN CtlC.VarReal(ret) END FInv; PROCEDURE (this: WorksheetFunction) Fisher* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16667, arg, ret); RETURN CtlC.VarReal(ret) END Fisher; PROCEDURE (this: WorksheetFunction) FisherInv* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16668, arg, ret); RETURN CtlC.VarReal(ret) END FisherInv; PROCEDURE (this: WorksheetFunction) Floor* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16669, arg, ret); RETURN CtlC.VarReal(ret) END Floor; PROCEDURE (this: WorksheetFunction) GammaDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: BOOLEAN): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.BoolVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16670, arg, ret); RETURN CtlC.VarReal(ret) END GammaDist; PROCEDURE (this: WorksheetFunction) GammaInv* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16671, arg, ret); RETURN CtlC.VarReal(ret) END GammaInv; PROCEDURE (this: WorksheetFunction) Ceiling* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16672, arg, ret); RETURN CtlC.VarReal(ret) END Ceiling; PROCEDURE (this: WorksheetFunction) HypGeomDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.RealVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16673, arg, ret); RETURN CtlC.VarReal(ret) END HypGeomDist; PROCEDURE (this: WorksheetFunction) LogNormDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16674, arg, ret); RETURN CtlC.VarReal(ret) END LogNormDist; PROCEDURE (this: WorksheetFunction) LogInv* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16675, arg, ret); RETURN CtlC.VarReal(ret) END LogInv; PROCEDURE (this: WorksheetFunction) NegBinomDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16676, arg, ret); RETURN CtlC.VarReal(ret) END NegBinomDist; PROCEDURE (this: WorksheetFunction) NormDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: BOOLEAN): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.BoolVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16677, arg, ret); RETURN CtlC.VarReal(ret) END NormDist; PROCEDURE (this: WorksheetFunction) NormSDist* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16678, arg, ret); RETURN CtlC.VarReal(ret) END NormSDist; PROCEDURE (this: WorksheetFunction) NormInv* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16679, arg, ret); RETURN CtlC.VarReal(ret) END NormInv; PROCEDURE (this: WorksheetFunction) NormSInv* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16680, arg, ret); RETURN CtlC.VarReal(ret) END NormSInv; PROCEDURE (this: WorksheetFunction) Standardize* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16681, arg, ret); RETURN CtlC.VarReal(ret) END Standardize; PROCEDURE (this: WorksheetFunction) Odd* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16682, arg, ret); RETURN CtlC.VarReal(ret) END Odd; PROCEDURE (this: WorksheetFunction) Permut* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16683, arg, ret); RETURN CtlC.VarReal(ret) END Permut; PROCEDURE (this: WorksheetFunction) Poisson* (Arg1: REAL; Arg2: REAL; Arg3: BOOLEAN): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.BoolVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16684, arg, ret); RETURN CtlC.VarReal(ret) END Poisson; PROCEDURE (this: WorksheetFunction) TDist* (Arg1: REAL; Arg2: REAL; Arg3: REAL): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.RealVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16685, arg, ret); RETURN CtlC.VarReal(ret) END TDist; PROCEDURE (this: WorksheetFunction) Weibull* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: BOOLEAN): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.BoolVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16686, arg, ret); RETURN CtlC.VarReal(ret) END Weibull; PROCEDURE (this: WorksheetFunction) SumXMY2* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16687, arg, ret); RETURN CtlC.VarReal(ret) END SumXMY2; PROCEDURE (this: WorksheetFunction) SumX2MY2* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16688, arg, ret); RETURN CtlC.VarReal(ret) END SumX2MY2; PROCEDURE (this: WorksheetFunction) SumX2PY2* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16689, arg, ret); RETURN CtlC.VarReal(ret) END SumX2PY2; PROCEDURE (this: WorksheetFunction) ChiTest* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16690, arg, ret); RETURN CtlC.VarReal(ret) END ChiTest; PROCEDURE (this: WorksheetFunction) Correl* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16691, arg, ret); RETURN CtlC.VarReal(ret) END Correl; PROCEDURE (this: WorksheetFunction) Covar* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16692, arg, ret); RETURN CtlC.VarReal(ret) END Covar; PROCEDURE (this: WorksheetFunction) Forecast* (Arg1: REAL; Arg2: CtlT.Any; Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16693, arg, ret); RETURN CtlC.VarReal(ret) END Forecast; PROCEDURE (this: WorksheetFunction) FTest* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16694, arg, ret); RETURN CtlC.VarReal(ret) END FTest; PROCEDURE (this: WorksheetFunction) Intercept* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16695, arg, ret); RETURN CtlC.VarReal(ret) END Intercept; PROCEDURE (this: WorksheetFunction) Pearson* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16696, arg, ret); RETURN CtlC.VarReal(ret) END Pearson; PROCEDURE (this: WorksheetFunction) RSq* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16697, arg, ret); RETURN CtlC.VarReal(ret) END RSq; PROCEDURE (this: WorksheetFunction) StEyx* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16698, arg, ret); RETURN CtlC.VarReal(ret) END StEyx; PROCEDURE (this: WorksheetFunction) Slope* (Arg1: CtlT.Any; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16699, arg, ret); RETURN CtlC.VarReal(ret) END Slope; PROCEDURE (this: WorksheetFunction) TTest* (Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: REAL; Arg4: REAL): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.RealVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16700, arg, ret); RETURN CtlC.VarReal(ret) END TTest; PROCEDURE (this: WorksheetFunction) Prob* (Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: REAL; (* optional *) Arg4: CtlT.Any): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16701, arg, ret); RETURN CtlC.VarReal(ret) END Prob; PROCEDURE (this: WorksheetFunction) DevSq* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16702, arg, ret); RETURN CtlC.VarReal(ret) END DevSq; PROCEDURE (this: WorksheetFunction) GeoMean* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16703, arg, ret); RETURN CtlC.VarReal(ret) END GeoMean; PROCEDURE (this: WorksheetFunction) HarMean* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16704, arg, ret); RETURN CtlC.VarReal(ret) END HarMean; PROCEDURE (this: WorksheetFunction) SumSq* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16705, arg, ret); RETURN CtlC.VarReal(ret) END SumSq; PROCEDURE (this: WorksheetFunction) Kurt* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16706, arg, ret); RETURN CtlC.VarReal(ret) END Kurt; PROCEDURE (this: WorksheetFunction) Skew* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16707, arg, ret); RETURN CtlC.VarReal(ret) END Skew; PROCEDURE (this: WorksheetFunction) ZTest* (Arg1: CtlT.Any; Arg2: REAL; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16708, arg, ret); RETURN CtlC.VarReal(ret) END ZTest; PROCEDURE (this: WorksheetFunction) Large* (Arg1: CtlT.Any; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16709, arg, ret); RETURN CtlC.VarReal(ret) END Large; PROCEDURE (this: WorksheetFunction) Small* (Arg1: CtlT.Any; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16710, arg, ret); RETURN CtlC.VarReal(ret) END Small; PROCEDURE (this: WorksheetFunction) Quartile* (Arg1: CtlT.Any; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16711, arg, ret); RETURN CtlC.VarReal(ret) END Quartile; PROCEDURE (this: WorksheetFunction) Percentile* (Arg1: CtlT.Any; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16712, arg, ret); RETURN CtlC.VarReal(ret) END Percentile; PROCEDURE (this: WorksheetFunction) PercentRank* (Arg1: CtlT.Any; Arg2: REAL; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[2]); CtlC.RealVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16713, arg, ret); RETURN CtlC.VarReal(ret) END PercentRank; PROCEDURE (this: WorksheetFunction) Mode* (Arg1: CtlT.Any; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16714, arg, ret); RETURN CtlC.VarReal(ret) END Mode; PROCEDURE (this: WorksheetFunction) TrimMean* (Arg1: CtlT.Any; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16715, arg, ret); RETURN CtlC.VarReal(ret) END TrimMean; PROCEDURE (this: WorksheetFunction) TInv* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16716, arg, ret); RETURN CtlC.VarReal(ret) END TInv; PROCEDURE (this: WorksheetFunction) Power* (Arg1: REAL; Arg2: REAL): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.RealVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16721, arg, ret); RETURN CtlC.VarReal(ret) END Power; PROCEDURE (this: WorksheetFunction) Radians* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16726, arg, ret); RETURN CtlC.VarReal(ret) END Radians; PROCEDURE (this: WorksheetFunction) Degrees* (Arg1: REAL): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16727, arg, ret); RETURN CtlC.VarReal(ret) END Degrees; PROCEDURE (this: WorksheetFunction) Subtotal* (Arg1: REAL; Arg2: Range; (* optional *) Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): REAL, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[29]); CtlC.ObjVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 16728, arg, ret); RETURN CtlC.VarReal(ret) END Subtotal; PROCEDURE (this: WorksheetFunction) SumIf* (Arg1: Range; Arg2: CtlT.Any; (* optional *) Arg3: CtlT.Any): REAL, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[2]); CtlC.AnyVar(Arg2, arg[1]); CtlC.AnyVar(Arg3, arg[0]); CtlC.CallParMethod(this, 16729, arg, ret); RETURN CtlC.VarReal(ret) END SumIf; PROCEDURE (this: WorksheetFunction) CountIf* (Arg1: Range; Arg2: CtlT.Any): REAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16730, arg, ret); RETURN CtlC.VarReal(ret) END CountIf; PROCEDURE (this: WorksheetFunction) CountBlank* (Arg1: Range): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16731, arg, ret); RETURN CtlC.VarReal(ret) END CountBlank; PROCEDURE (this: WorksheetFunction) Ispmt* (Arg1: REAL; Arg2: REAL; Arg3: REAL; Arg4: REAL): REAL, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[3]); CtlC.RealVar(Arg2, arg[2]); CtlC.RealVar(Arg3, arg[1]); CtlC.RealVar(Arg4, arg[0]); CtlC.CallParMethod(this, 16734, arg, ret); RETURN CtlC.VarReal(ret) END Ispmt; PROCEDURE (this: WorksheetFunction) Roman* (Arg1: REAL; (* optional *) Arg2: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Arg1, arg[1]); CtlC.AnyVar(Arg2, arg[0]); CtlC.CallParMethod(this, 16738, arg, ret); RETURN CtlC.VarStr(ret) END Roman; PROCEDURE (this: WorksheetFunction) Asc* (Arg1: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16598, arg, ret); RETURN CtlC.VarStr(ret) END Asc; PROCEDURE (this: WorksheetFunction) Dbcs* (Arg1: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16599, arg, ret); RETURN CtlC.VarStr(ret) END Dbcs; PROCEDURE (this: WorksheetFunction) Phonetic* (Arg1: Range): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Arg1, arg[0]); CtlC.CallParMethod(this, 16744, arg, ret); RETURN CtlC.VarStr(ret) END Phonetic; (* ---------- Range ---------- *) PROCEDURE (this: Range) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Range) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Range) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Range) Activate* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 304, ret); RETURN CtlC.VarAny(ret) END Activate; PROCEDURE (this: Range) AddIndent* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1063) END AddIndent; PROCEDURE (this: Range) PUTAddIndent* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Range) Address* (RowAbsolute: CtlT.Any; ColumnAbsolute: CtlT.Any; ReferenceStyle: XlReferenceStyle; (* optional *) External: CtlT.Any; RelativeTo: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowAbsolute, arg[4]); CtlC.AnyVar(ColumnAbsolute, arg[3]); CtlC.IntVar(ReferenceStyle, arg[2]); CtlC.AnyVar(External, arg[1]); CtlC.AnyVar(RelativeTo, arg[0]); CtlC.CallGetMethod(this, 236, arg, ret); RETURN CtlC.VarStr(ret) END Address; PROCEDURE (this: Range) AddressLocal* (RowAbsolute: CtlT.Any; ColumnAbsolute: CtlT.Any; ReferenceStyle: XlReferenceStyle; (* optional *) External: CtlT.Any; RelativeTo: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowAbsolute, arg[4]); CtlC.AnyVar(ColumnAbsolute, arg[3]); CtlC.IntVar(ReferenceStyle, arg[2]); CtlC.AnyVar(External, arg[1]); CtlC.AnyVar(RelativeTo, arg[0]); CtlC.CallGetMethod(this, 437, arg, ret); RETURN CtlC.VarStr(ret) END AddressLocal; PROCEDURE (this: Range) AdvancedFilter* (Action: XlFilterAction; (* optional *) CriteriaRange: CtlT.Any; CopyToRange: CtlT.Any; Unique: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Action, arg[3]); CtlC.AnyVar(CriteriaRange, arg[2]); CtlC.AnyVar(CopyToRange, arg[1]); CtlC.AnyVar(Unique, arg[0]); CtlC.CallParMethod(this, 876, arg, ret); RETURN CtlC.VarAny(ret) END AdvancedFilter; PROCEDURE (this: Range) ApplyNames* (Names: CtlT.Any; IgnoreRelativeAbsolute: CtlT.Any; UseRowColumnNames: CtlT.Any; OmitColumn: CtlT.Any; OmitRow: CtlT.Any; Order: XlApplyNamesOrder; (* optional *) AppendLast: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Names, arg[6]); CtlC.AnyVar(IgnoreRelativeAbsolute, arg[5]); CtlC.AnyVar(UseRowColumnNames, arg[4]); CtlC.AnyVar(OmitColumn, arg[3]); CtlC.AnyVar(OmitRow, arg[2]); CtlC.IntVar(Order, arg[1]); CtlC.AnyVar(AppendLast, arg[0]); CtlC.CallParMethod(this, 441, arg, ret); RETURN CtlC.VarAny(ret) END ApplyNames; PROCEDURE (this: Range) ApplyOutlineStyles* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 448, ret); RETURN CtlC.VarAny(ret) END ApplyOutlineStyles; PROCEDURE (this: Range) Areas* (): Areas, NEW; BEGIN RETURN ThisAreas(CtlC.GetAny(this, 568)) END Areas; PROCEDURE (this: Range) AutoComplete* (String: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1185, arg, ret); RETURN CtlC.VarStr(ret) END AutoComplete; PROCEDURE (this: Range) AutoFill* (Destination: Range; Type: XlAutoFillType): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Destination, arg[1]); CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 449, arg, ret); RETURN CtlC.VarAny(ret) END AutoFill; PROCEDURE (this: Range) AutoFilter* (Field: CtlT.Any; Criteria1: CtlT.Any; Operator: XlAutoFilterOperator; (* optional *) Criteria2: CtlT.Any; VisibleDropDown: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Field, arg[4]); CtlC.AnyVar(Criteria1, arg[3]); CtlC.IntVar(Operator, arg[2]); CtlC.AnyVar(Criteria2, arg[1]); CtlC.AnyVar(VisibleDropDown, arg[0]); CtlC.CallParMethod(this, 793, arg, ret); RETURN CtlC.VarAny(ret) END AutoFilter; PROCEDURE (this: Range) AutoFit* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 237, ret); RETURN CtlC.VarAny(ret) END AutoFit; PROCEDURE (this: Range) AutoFormat* (Format: XlRangeAutoFormat; (* optional *) Number: CtlT.Any; Font: CtlT.Any; Alignment: CtlT.Any; Border: CtlT.Any; Pattern: CtlT.Any; Width: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Format, arg[6]); CtlC.AnyVar(Number, arg[5]); CtlC.AnyVar(Font, arg[4]); CtlC.AnyVar(Alignment, arg[3]); CtlC.AnyVar(Border, arg[2]); CtlC.AnyVar(Pattern, arg[1]); CtlC.AnyVar(Width, arg[0]); CtlC.CallParMethod(this, 114, arg, ret); RETURN CtlC.VarAny(ret) END AutoFormat; PROCEDURE (this: Range) AutoOutline* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1036, ret); RETURN CtlC.VarAny(ret) END AutoOutline; PROCEDURE (this: Range) BorderAround* (LineStyle: CtlT.Any; Weight: XlBorderWeight; ColorIndex: XlColorIndex; (* optional *) Color: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(LineStyle, arg[3]); CtlC.IntVar(Weight, arg[2]); CtlC.IntVar(ColorIndex, arg[1]); CtlC.AnyVar(Color, arg[0]); CtlC.CallParMethod(this, 1067, arg, ret); RETURN CtlC.VarAny(ret) END BorderAround; PROCEDURE (this: Range) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 435)) END Borders; PROCEDURE (this: Range) Calculate* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 279, ret); RETURN CtlC.VarAny(ret) END Calculate; PROCEDURE (this: Range) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: Range) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Range) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Range) Clear* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 111, ret); RETURN CtlC.VarAny(ret) END Clear; PROCEDURE (this: Range) ClearContents* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 113, ret); RETURN CtlC.VarAny(ret) END ClearContents; PROCEDURE (this: Range) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Range) ClearNotes* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 239, ret); RETURN CtlC.VarAny(ret) END ClearNotes; PROCEDURE (this: Range) ClearOutline* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1037, ret); RETURN CtlC.VarAny(ret) END ClearOutline; PROCEDURE (this: Range) Column* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 240) END Column; PROCEDURE (this: Range) ColumnDifferences* (Comparison: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Comparison, arg[0]); CtlC.CallParMethod(this, 510, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ColumnDifferences; PROCEDURE (this: Range) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: Range) ColumnWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 242) END ColumnWidth; PROCEDURE (this: Range) PUTColumnWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 242, p1) END PUTColumnWidth; PROCEDURE (this: Range) Consolidate* ((* optional *) Sources: CtlT.Any; Function: CtlT.Any; TopRow: CtlT.Any; LeftColumn: CtlT.Any; CreateLinks: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Sources, arg[4]); CtlC.AnyVar(Function, arg[3]); CtlC.AnyVar(TopRow, arg[2]); CtlC.AnyVar(LeftColumn, arg[1]); CtlC.AnyVar(CreateLinks, arg[0]); CtlC.CallParMethod(this, 482, arg, ret); RETURN CtlC.VarAny(ret) END Consolidate; PROCEDURE (this: Range) Copy* ((* optional *) Destination: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[0]); CtlC.CallParMethod(this, 551, arg, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Range) CopyFromRecordset* (Data: CtlT.IUnknown; (* optional *) MaxRows: CtlT.Any; MaxColumns: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntfceVar(Data, arg[2]); CtlC.AnyVar(MaxRows, arg[1]); CtlC.AnyVar(MaxColumns, arg[0]); CtlC.CallParMethod(this, 1152, arg, ret); RETURN CtlC.VarInt(ret) END CopyFromRecordset; PROCEDURE (this: Range) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Range) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Range) CreateNames* ((* optional *) Top: CtlT.Any; Left: CtlT.Any; Bottom: CtlT.Any; Right: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Left, arg[2]); CtlC.AnyVar(Bottom, arg[1]); CtlC.AnyVar(Right, arg[0]); CtlC.CallParMethod(this, 457, arg, ret); RETURN CtlC.VarAny(ret) END CreateNames; PROCEDURE (this: Range) CreatePublisher* (Edition: CtlT.Any; Appearance: XlPictureAppearance; (* optional *) ContainsPICT: CtlT.Any; ContainsBIFF: CtlT.Any; ContainsRTF: CtlT.Any; ContainsVALU: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Edition, arg[5]); CtlC.IntVar(Appearance, arg[4]); CtlC.AnyVar(ContainsPICT, arg[3]); CtlC.AnyVar(ContainsBIFF, arg[2]); CtlC.AnyVar(ContainsRTF, arg[1]); CtlC.AnyVar(ContainsVALU, arg[0]); CtlC.CallParMethod(this, 458, arg, ret); RETURN CtlC.VarAny(ret) END CreatePublisher; PROCEDURE (this: Range) CurrentArray* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 501)) END CurrentArray; PROCEDURE (this: Range) CurrentRegion* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 243)) END CurrentRegion; PROCEDURE (this: Range) Cut* ((* optional *) Destination: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[0]); CtlC.CallParMethod(this, 565, arg, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Range) DataSeries* (Rowcol: CtlT.Any; Type: XlDataSeriesType; Date: XlDataSeriesDate; (* optional *) Step: CtlT.Any; Stop: CtlT.Any; Trend: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Rowcol, arg[5]); CtlC.IntVar(Type, arg[4]); CtlC.IntVar(Date, arg[3]); CtlC.AnyVar(Step, arg[2]); CtlC.AnyVar(Stop, arg[1]); CtlC.AnyVar(Trend, arg[0]); CtlC.CallParMethod(this, 464, arg, ret); RETURN CtlC.VarAny(ret) END DataSeries; PROCEDURE (this: Range) _Default* ((* optional *) RowIndex: CtlT.Any; ColumnIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[1]); CtlC.AnyVar(ColumnIndex, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarAny(ret) END _Default; PROCEDURE (this: Range) PUT_Default* (RowIndex: CtlT.Any; (* optional *) ColumnIndex: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[2]); CtlC.AnyVar(ColumnIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUT_Default; PROCEDURE (this: Range) Delete* ((* optional *) Shift: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Shift, arg[0]); CtlC.CallParMethod(this, 117, arg, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Range) Dependents* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 543)) END Dependents; PROCEDURE (this: Range) DialogBox* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 245, ret); RETURN CtlC.VarAny(ret) END DialogBox; PROCEDURE (this: Range) DirectDependents* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 545)) END DirectDependents; PROCEDURE (this: Range) DirectPrecedents* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 546)) END DirectPrecedents; PROCEDURE (this: Range) EditionOptions* (Type: XlEditionType; Option: XlEditionOptionsOption; Name: CtlT.Any; Reference: CtlT.Any; Appearance: XlPictureAppearance; ChartSize: XlPictureAppearance; (* optional *) Format: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[6]); CtlC.IntVar(Option, arg[5]); CtlC.AnyVar(Name, arg[4]); CtlC.AnyVar(Reference, arg[3]); CtlC.IntVar(Appearance, arg[2]); CtlC.IntVar(ChartSize, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 1131, arg, ret); RETURN CtlC.VarAny(ret) END EditionOptions; PROCEDURE (this: Range) End* (Direction: XlDirection): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[0]); CtlC.CallGetMethod(this, 500, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END End; PROCEDURE (this: Range) EntireColumn* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 246)) END EntireColumn; PROCEDURE (this: Range) EntireRow* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 247)) END EntireRow; PROCEDURE (this: Range) FillDown* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 248, ret); RETURN CtlC.VarAny(ret) END FillDown; PROCEDURE (this: Range) FillLeft* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 249, ret); RETURN CtlC.VarAny(ret) END FillLeft; PROCEDURE (this: Range) FillRight* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 250, ret); RETURN CtlC.VarAny(ret) END FillRight; PROCEDURE (this: Range) FillUp* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 251, ret); RETURN CtlC.VarAny(ret) END FillUp; PROCEDURE (this: Range) Find* (What: CtlT.Any; After: CtlT.Any; LookIn: CtlT.Any; LookAt: CtlT.Any; SearchOrder: CtlT.Any; SearchDirection: XlSearchDirection; (* optional *) MatchCase: CtlT.Any; MatchByte: CtlT.Any): Range, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(What, arg[7]); CtlC.AnyVar(After, arg[6]); CtlC.AnyVar(LookIn, arg[5]); CtlC.AnyVar(LookAt, arg[4]); CtlC.AnyVar(SearchOrder, arg[3]); CtlC.IntVar(SearchDirection, arg[2]); CtlC.AnyVar(MatchCase, arg[1]); CtlC.AnyVar(MatchByte, arg[0]); CtlC.CallParMethod(this, 398, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Find; PROCEDURE (this: Range) FindNext* ((* optional *) After: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 399, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END FindNext; PROCEDURE (this: Range) FindPrevious* ((* optional *) After: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 400, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END FindPrevious; PROCEDURE (this: Range) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Range) Formula* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 261) END Formula; PROCEDURE (this: Range) PUTFormula* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 261, p1) END PUTFormula; PROCEDURE (this: Range) FormulaArray* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 586) END FormulaArray; PROCEDURE (this: Range) PUTFormulaArray* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 586, p1) END PUTFormulaArray; PROCEDURE (this: Range) FormulaLabel* (): XlFormulaLabel, NEW; BEGIN RETURN CtlC.GetInt(this, 1380) END FormulaLabel; PROCEDURE (this: Range) PUTFormulaLabel* (p1: XlFormulaLabel), NEW; BEGIN CtlC.PutInt(this, 1380, p1) END PUTFormulaLabel; PROCEDURE (this: Range) FormulaHidden* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 262) END FormulaHidden; PROCEDURE (this: Range) PUTFormulaHidden* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 262, p1) END PUTFormulaHidden; PROCEDURE (this: Range) FormulaLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 263) END FormulaLocal; PROCEDURE (this: Range) PUTFormulaLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 263, p1) END PUTFormulaLocal; PROCEDURE (this: Range) FormulaR1C1* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 264) END FormulaR1C1; PROCEDURE (this: Range) PUTFormulaR1C1* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 264, p1) END PUTFormulaR1C1; PROCEDURE (this: Range) FormulaR1C1Local* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 265) END FormulaR1C1Local; PROCEDURE (this: Range) PUTFormulaR1C1Local* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 265, p1) END PUTFormulaR1C1Local; PROCEDURE (this: Range) FunctionWizard* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 571, ret); RETURN CtlC.VarAny(ret) END FunctionWizard; PROCEDURE (this: Range) GoalSeek* (Goal: CtlT.Any; ChangingCell: Range): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Goal, arg[1]); CtlC.ObjVar(ChangingCell, arg[0]); CtlC.CallParMethod(this, 472, arg, ret); RETURN CtlC.VarBool(ret) END GoalSeek; PROCEDURE (this: Range) Group* ((* optional *) Start: CtlT.Any; End: CtlT.Any; By: CtlT.Any; Periods: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[3]); CtlC.AnyVar(End, arg[2]); CtlC.AnyVar(By, arg[1]); CtlC.AnyVar(Periods, arg[0]); CtlC.CallParMethod(this, 46, arg, ret); RETURN CtlC.VarAny(ret) END Group; PROCEDURE (this: Range) HasArray* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 266) END HasArray; PROCEDURE (this: Range) HasFormula* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 267) END HasFormula; PROCEDURE (this: Range) Height* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 123) END Height; PROCEDURE (this: Range) Hidden* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 268) END Hidden; PROCEDURE (this: Range) PUTHidden* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 268, p1) END PUTHidden; PROCEDURE (this: Range) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Range) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Range) IndentLevel* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 201) END IndentLevel; PROCEDURE (this: Range) PUTIndentLevel* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 201, p1) END PUTIndentLevel; PROCEDURE (this: Range) InsertIndent* (InsertAmount: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(InsertAmount, arg[0]); CtlC.CallParMethod(this, 1381, arg, NIL); END InsertIndent; PROCEDURE (this: Range) Insert* ((* optional *) Shift: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Shift, arg[0]); CtlC.CallParMethod(this, 252, arg, ret); RETURN CtlC.VarAny(ret) END Insert; PROCEDURE (this: Range) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Range) Item* (RowIndex: CtlT.Any; (* optional *) ColumnIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[1]); CtlC.AnyVar(ColumnIndex, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarAny(ret) END Item; PROCEDURE (this: Range) PUTItem* (RowIndex: CtlT.Any; ColumnIndex: CtlT.Any; (* optional *) p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[2]); CtlC.AnyVar(ColumnIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 170, arg, NIL); END PUTItem; PROCEDURE (this: Range) Justify* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 495, ret); RETURN CtlC.VarAny(ret) END Justify; PROCEDURE (this: Range) Left* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 127) END Left; PROCEDURE (this: Range) ListHeaderRows* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1187) END ListHeaderRows; PROCEDURE (this: Range) ListNames* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 253, ret); RETURN CtlC.VarAny(ret) END ListNames; PROCEDURE (this: Range) LocationInTable* (): XlLocationInTable, NEW; BEGIN RETURN CtlC.GetInt(this, 691) END LocationInTable; PROCEDURE (this: Range) Locked* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 269) END Locked; PROCEDURE (this: Range) PUTLocked* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 269, p1) END PUTLocked; PROCEDURE (this: Range) Merge* ((* optional *) Across: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Across, arg[0]); CtlC.CallParMethod(this, 564, arg, NIL); END Merge; PROCEDURE (this: Range) UnMerge* (), NEW; BEGIN CtlC.CallMethod(this, 1384, NIL); END UnMerge; PROCEDURE (this: Range) MergeArea* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1385)) END MergeArea; PROCEDURE (this: Range) MergeCells* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 208) END MergeCells; PROCEDURE (this: Range) PUTMergeCells* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 208, p1) END PUTMergeCells; PROCEDURE (this: Range) Name* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 110) END Name; PROCEDURE (this: Range) PUTName* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 110, p1) END PUTName; PROCEDURE (this: Range) NavigateArrow* ((* optional *) TowardPrecedent: CtlT.Any; ArrowNumber: CtlT.Any; LinkNumber: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(TowardPrecedent, arg[2]); CtlC.AnyVar(ArrowNumber, arg[1]); CtlC.AnyVar(LinkNumber, arg[0]); CtlC.CallParMethod(this, 1032, arg, ret); RETURN CtlC.VarAny(ret) END NavigateArrow; PROCEDURE (this: Range) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Range) Next* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 502)) END Next; PROCEDURE (this: Range) NoteText* ((* optional *) Text: CtlT.Any; Start: CtlT.Any; Length: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[2]); CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallParMethod(this, 1127, arg, ret); RETURN CtlC.VarStr(ret) END NoteText; PROCEDURE (this: Range) NumberFormat* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 193) END NumberFormat; PROCEDURE (this: Range) PUTNumberFormat* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: Range) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: Range) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: Range) Offset* ((* optional *) RowOffset: CtlT.Any; ColumnOffset: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowOffset, arg[1]); CtlC.AnyVar(ColumnOffset, arg[0]); CtlC.CallGetMethod(this, 254, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Offset; PROCEDURE (this: Range) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Range) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Range) OutlineLevel* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 271) END OutlineLevel; PROCEDURE (this: Range) PUTOutlineLevel* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 271, p1) END PUTOutlineLevel; PROCEDURE (this: Range) PageBreak* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 255) END PageBreak; PROCEDURE (this: Range) PUTPageBreak* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 255, p1) END PUTPageBreak; PROCEDURE (this: Range) Parse* ((* optional *) ParseLine: CtlT.Any; Destination: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ParseLine, arg[1]); CtlC.AnyVar(Destination, arg[0]); CtlC.CallParMethod(this, 477, arg, ret); RETURN CtlC.VarAny(ret) END Parse; PROCEDURE (this: Range) PasteSpecial* (Paste: XlPasteType; Operation: XlPasteSpecialOperation; (* optional *) SkipBlanks: CtlT.Any; Transpose: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Paste, arg[3]); CtlC.IntVar(Operation, arg[2]); CtlC.AnyVar(SkipBlanks, arg[1]); CtlC.AnyVar(Transpose, arg[0]); CtlC.CallParMethod(this, 1027, arg, ret); RETURN CtlC.VarAny(ret) END PasteSpecial; PROCEDURE (this: Range) PivotField* (): PivotField, NEW; BEGIN RETURN ThisPivotField(CtlC.GetAny(this, 731)) END PivotField; PROCEDURE (this: Range) PivotItem* (): PivotItem, NEW; BEGIN RETURN ThisPivotItem(CtlC.GetAny(this, 740)) END PivotItem; PROCEDURE (this: Range) PivotTable* (): PivotTable, NEW; BEGIN RETURN ThisPivotTable(CtlC.GetAny(this, 716)) END PivotTable; PROCEDURE (this: Range) Precedents* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 544)) END Precedents; PROCEDURE (this: Range) PrefixCharacter* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 504) END PrefixCharacter; PROCEDURE (this: Range) Previous* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 503)) END Previous; PROCEDURE (this: Range) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, ret); RETURN CtlC.VarAny(ret) END _PrintOut; PROCEDURE (this: Range) PrintPreview* ((* optional *) EnableChanges: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, ret); RETURN CtlC.VarAny(ret) END PrintPreview; PROCEDURE (this: Range) QueryTable* (): QueryTable, NEW; BEGIN RETURN This_QueryTable(CtlC.GetAny(this, 1386)) END QueryTable; PROCEDURE (this: Range) Range* (Cell1: CtlT.Any; (* optional *) Cell2: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cell1, arg[1]); CtlC.AnyVar(Cell2, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Range) RemoveSubtotal* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 883, ret); RETURN CtlC.VarAny(ret) END RemoveSubtotal; PROCEDURE (this: Range) Replace* (What: CtlT.Any; Replacement: CtlT.Any; (* optional *) LookAt: CtlT.Any; SearchOrder: CtlT.Any; MatchCase: CtlT.Any; MatchByte: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(What, arg[5]); CtlC.AnyVar(Replacement, arg[4]); CtlC.AnyVar(LookAt, arg[3]); CtlC.AnyVar(SearchOrder, arg[2]); CtlC.AnyVar(MatchCase, arg[1]); CtlC.AnyVar(MatchByte, arg[0]); CtlC.CallParMethod(this, 226, arg, ret); RETURN CtlC.VarBool(ret) END Replace; PROCEDURE (this: Range) Resize* ((* optional *) RowSize: CtlT.Any; ColumnSize: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowSize, arg[1]); CtlC.AnyVar(ColumnSize, arg[0]); CtlC.CallGetMethod(this, 256, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Resize; PROCEDURE (this: Range) Row* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 257) END Row; PROCEDURE (this: Range) RowDifferences* (Comparison: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Comparison, arg[0]); CtlC.CallParMethod(this, 511, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END RowDifferences; PROCEDURE (this: Range) RowHeight* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 272) END RowHeight; PROCEDURE (this: Range) PUTRowHeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 272, p1) END PUTRowHeight; PROCEDURE (this: Range) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: Range) Run* ((* optional *) Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 259, arg, ret); RETURN CtlC.VarAny(ret) END Run; PROCEDURE (this: Range) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Range) Show* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 496, ret); RETURN CtlC.VarAny(ret) END Show; PROCEDURE (this: Range) ShowDependents* ((* optional *) Remove: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Remove, arg[0]); CtlC.CallParMethod(this, 877, arg, ret); RETURN CtlC.VarAny(ret) END ShowDependents; PROCEDURE (this: Range) ShowDetail* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 585) END ShowDetail; PROCEDURE (this: Range) PUTShowDetail* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 585, p1) END PUTShowDetail; PROCEDURE (this: Range) ShowErrors* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 878, ret); RETURN CtlC.VarAny(ret) END ShowErrors; PROCEDURE (this: Range) ShowPrecedents* ((* optional *) Remove: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Remove, arg[0]); CtlC.CallParMethod(this, 879, arg, ret); RETURN CtlC.VarAny(ret) END ShowPrecedents; PROCEDURE (this: Range) ShrinkToFit* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 209) END ShrinkToFit; PROCEDURE (this: Range) PUTShrinkToFit* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 209, p1) END PUTShrinkToFit; PROCEDURE (this: Range) Sort* (Key1: CtlT.Any; Order1: XlSortOrder; Key2: CtlT.Any; Type: CtlT.Any; Order2: XlSortOrder; Key3: CtlT.Any; Order3: XlSortOrder; Header: XlYesNoGuess; OrderCustom: CtlT.Any; MatchCase: CtlT.Any; Orientation: XlSortOrientation; SortMethod: XlSortMethod): CtlT.Any, NEW; VAR arg: ARRAY 12 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Key1, arg[11]); CtlC.IntVar(Order1, arg[10]); CtlC.AnyVar(Key2, arg[9]); CtlC.AnyVar(Type, arg[8]); CtlC.IntVar(Order2, arg[7]); CtlC.AnyVar(Key3, arg[6]); CtlC.IntVar(Order3, arg[5]); CtlC.IntVar(Header, arg[4]); CtlC.AnyVar(OrderCustom, arg[3]); CtlC.AnyVar(MatchCase, arg[2]); CtlC.IntVar(Orientation, arg[1]); CtlC.IntVar(SortMethod, arg[0]); CtlC.CallParMethod(this, 880, arg, ret); RETURN CtlC.VarAny(ret) END Sort; PROCEDURE (this: Range) SortSpecial* (SortMethod: XlSortMethod; Key1: CtlT.Any; Order1: XlSortOrder; Type: CtlT.Any; Key2: CtlT.Any; Order2: XlSortOrder; Key3: CtlT.Any; Order3: XlSortOrder; Header: XlYesNoGuess; OrderCustom: CtlT.Any; MatchCase: CtlT.Any; Orientation: XlSortOrientation): CtlT.Any, NEW; VAR arg: ARRAY 12 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SortMethod, arg[11]); CtlC.AnyVar(Key1, arg[10]); CtlC.IntVar(Order1, arg[9]); CtlC.AnyVar(Type, arg[8]); CtlC.AnyVar(Key2, arg[7]); CtlC.IntVar(Order2, arg[6]); CtlC.AnyVar(Key3, arg[5]); CtlC.IntVar(Order3, arg[4]); CtlC.IntVar(Header, arg[3]); CtlC.AnyVar(OrderCustom, arg[2]); CtlC.AnyVar(MatchCase, arg[1]); CtlC.IntVar(Orientation, arg[0]); CtlC.CallParMethod(this, 881, arg, ret); RETURN CtlC.VarAny(ret) END SortSpecial; PROCEDURE (this: Range) SoundNote* (): SoundNote, NEW; BEGIN RETURN ThisSoundNote(CtlC.GetAny(this, 916)) END SoundNote; PROCEDURE (this: Range) SpecialCells* (Type: XlCellType; (* optional *) Value: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 410, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END SpecialCells; PROCEDURE (this: Range) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 260) END Style; PROCEDURE (this: Range) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 260, p1) END PUTStyle; PROCEDURE (this: Range) SubscribeTo* (Edition: ARRAY OF CHAR; Format: XlSubscribeToFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Edition, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 481, arg, ret); RETURN CtlC.VarAny(ret) END SubscribeTo; PROCEDURE (this: Range) Subtotal* (GroupBy: INTEGER; Function: XlConsolidationFunction; TotalList: CtlT.Any; Replace: CtlT.Any; PageBreaks: CtlT.Any; SummaryBelowData: XlSummaryRow): CtlT.Any, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(GroupBy, arg[5]); CtlC.IntVar(Function, arg[4]); CtlC.AnyVar(TotalList, arg[3]); CtlC.AnyVar(Replace, arg[2]); CtlC.AnyVar(PageBreaks, arg[1]); CtlC.IntVar(SummaryBelowData, arg[0]); CtlC.CallParMethod(this, 882, arg, ret); RETURN CtlC.VarAny(ret) END Subtotal; PROCEDURE (this: Range) Summary* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 273) END Summary; PROCEDURE (this: Range) Table* ((* optional *) RowInput: CtlT.Any; ColumnInput: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowInput, arg[1]); CtlC.AnyVar(ColumnInput, arg[0]); CtlC.CallParMethod(this, 497, arg, ret); RETURN CtlC.VarAny(ret) END Table; PROCEDURE (this: Range) Text* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 138) END Text; PROCEDURE (this: Range) TextToColumns* (Destination: CtlT.Any; DataType: XlTextParsingType; TextQualifier: XlTextQualifier; (* optional *) ConsecutiveDelimiter: CtlT.Any; Tab: CtlT.Any; Semicolon: CtlT.Any; Comma: CtlT.Any; Space: CtlT.Any; Other: CtlT.Any; OtherChar: CtlT.Any; FieldInfo: CtlT.Any; DecimalSeparator: CtlT.Any; ThousandsSeparator: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[12]); CtlC.IntVar(DataType, arg[11]); CtlC.IntVar(TextQualifier, arg[10]); CtlC.AnyVar(ConsecutiveDelimiter, arg[9]); CtlC.AnyVar(Tab, arg[8]); CtlC.AnyVar(Semicolon, arg[7]); CtlC.AnyVar(Comma, arg[6]); CtlC.AnyVar(Space, arg[5]); CtlC.AnyVar(Other, arg[4]); CtlC.AnyVar(OtherChar, arg[3]); CtlC.AnyVar(FieldInfo, arg[2]); CtlC.AnyVar(DecimalSeparator, arg[1]); CtlC.AnyVar(ThousandsSeparator, arg[0]); CtlC.CallParMethod(this, 1040, arg, ret); RETURN CtlC.VarAny(ret) END TextToColumns; PROCEDURE (this: Range) Top* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Top; PROCEDURE (this: Range) Ungroup* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN CtlC.VarAny(ret) END Ungroup; PROCEDURE (this: Range) UseStandardHeight* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 274) END UseStandardHeight; PROCEDURE (this: Range) PUTUseStandardHeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 274, p1) END PUTUseStandardHeight; PROCEDURE (this: Range) UseStandardWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 275) END UseStandardWidth; PROCEDURE (this: Range) PUTUseStandardWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 275, p1) END PUTUseStandardWidth; PROCEDURE (this: Range) Validation* (): Validation, NEW; BEGIN RETURN ThisValidation(CtlC.GetAny(this, 1387)) END Validation; PROCEDURE (this: Range) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: Range) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: Range) Value2* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1388) END Value2; PROCEDURE (this: Range) PUTValue2* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1388, p1) END PUTValue2; PROCEDURE (this: Range) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Range) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Range) Width* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 122) END Width; PROCEDURE (this: Range) Worksheet* (): Worksheet, NEW; BEGIN RETURN This_Worksheet(CtlC.GetAny(this, 348)) END Worksheet; PROCEDURE (this: Range) WrapText* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 276) END WrapText; PROCEDURE (this: Range) PUTWrapText* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 276, p1) END PUTWrapText; PROCEDURE (this: Range) AddComment* ((* optional *) Text: CtlT.Any): Comment, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[0]); CtlC.CallParMethod(this, 1389, arg, ret); RETURN ThisComment(CtlC.VarAny(ret)) END AddComment; PROCEDURE (this: Range) Comment* (): Comment, NEW; BEGIN RETURN ThisComment(CtlC.GetAny(this, 910)) END Comment; PROCEDURE (this: Range) ClearComments* (), NEW; BEGIN CtlC.CallMethod(this, 1390, NIL); END ClearComments; PROCEDURE (this: Range) Phonetic* (): Phonetic, NEW; BEGIN RETURN ThisPhonetic(CtlC.GetAny(this, 1391)) END Phonetic; PROCEDURE (this: Range) FormatConditions* (): FormatConditions, NEW; BEGIN RETURN ThisFormatConditions(CtlC.GetAny(this, 1392)) END FormatConditions; PROCEDURE (this: Range) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Range) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Range) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 1393)) END Hyperlinks; PROCEDURE (this: Range) Phonetics* (): Phonetics, NEW; BEGIN RETURN ThisPhonetics(CtlC.GetAny(this, 1811)) END Phonetics; PROCEDURE (this: Range) SetPhonetic* (), NEW; BEGIN CtlC.CallMethod(this, 1812, NIL); END SetPhonetic; PROCEDURE (this: Range) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1813) END ID; PROCEDURE (this: Range) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1813, p1) END PUTID; PROCEDURE (this: Range) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, ret); RETURN CtlC.VarAny(ret) END PrintOut; (* ---------- ChartEvents, hidden ---------- *) PROCEDURE (this: ChartEvents) Activate* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) Deactivate* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) Resize* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) MouseDown* (Button: INTEGER; Shift: INTEGER; x: INTEGER; y: INTEGER), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) MouseUp* (Button: INTEGER; Shift: INTEGER; x: INTEGER; y: INTEGER), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) MouseMove* (Button: INTEGER; Shift: INTEGER; x: INTEGER; y: INTEGER), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) BeforeRightClick* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) DragPlot* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) DragOver* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) BeforeDoubleClick* (ElementID: INTEGER; Arg1: INTEGER; Arg2: INTEGER; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) Select* (ElementID: INTEGER; Arg1: INTEGER; Arg2: INTEGER), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) SeriesChange* (SeriesIndex: INTEGER; PointIndex: INTEGER), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) Calculate* (), NEW, ABSTRACT; PROCEDURE (this: ChartEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 304: ASSERT(n = 0, 11); this.Activate() | 1530: ASSERT(n = 0, 11); this.Deactivate() | 256: ASSERT(n = 0, 11); this.Resize() | 1531: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 1532: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 1533: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 1534: ASSERT(n = 1, 11); this.BeforeRightClick(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1535: ASSERT(n = 0, 11); this.DragPlot() | 1536: ASSERT(n = 0, 11); this.DragOver() | 1537: ASSERT(n = 4, 11); this.BeforeDoubleClick(CtlC.VarInt(par[3]), CtlC.VarInt(par[2]), CtlC.VarInt(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 235: ASSERT(n = 3, 11); this.Select(CtlC.VarInt(par[2]), CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 1538: ASSERT(n = 2, 11); this.SeriesChange(CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 279: ASSERT(n = 0, 11); this.Calculate() END END Invoke; PROCEDURE (this: ChartEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0002440F-0000-0000-C000-000000000046}" END GetIID; (* ---------- VPageBreak ---------- *) PROCEDURE (this: VPageBreak) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: VPageBreak) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: VPageBreak) Parent* (): Worksheet, NEW; BEGIN RETURN This_Worksheet(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: VPageBreak) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: VPageBreak) DragOff* (Direction: XlDirection; RegionIndex: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[1]); CtlC.IntVar(RegionIndex, arg[0]); CtlC.CallParMethod(this, 1420, arg, NIL); END DragOff; PROCEDURE (this: VPageBreak) Type* (): XlPageBreak, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: VPageBreak) PUTType* (p1: XlPageBreak), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: VPageBreak) Extent* (): XlPageBreakExtent, NEW; BEGIN RETURN CtlC.GetInt(this, 1422) END Extent; PROCEDURE (this: VPageBreak) Location* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1397)) END Location; PROCEDURE (this: VPageBreak) PUTREFLocation* (p1: Range), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1397, arg, NIL); END PUTREFLocation; (* ---------- HPageBreak ---------- *) PROCEDURE (this: HPageBreak) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: HPageBreak) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: HPageBreak) Parent* (): Worksheet, NEW; BEGIN RETURN This_Worksheet(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: HPageBreak) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: HPageBreak) DragOff* (Direction: XlDirection; RegionIndex: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[1]); CtlC.IntVar(RegionIndex, arg[0]); CtlC.CallParMethod(this, 1420, arg, NIL); END DragOff; PROCEDURE (this: HPageBreak) Type* (): XlPageBreak, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: HPageBreak) PUTType* (p1: XlPageBreak), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: HPageBreak) Extent* (): XlPageBreakExtent, NEW; BEGIN RETURN CtlC.GetInt(this, 1422) END Extent; PROCEDURE (this: HPageBreak) Location* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1397)) END Location; PROCEDURE (this: HPageBreak) PUTREFLocation* (p1: Range), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1397, arg, NIL); END PUTREFLocation; (* ---------- HPageBreaks ---------- *) PROCEDURE (this: HPageBreaks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: HPageBreaks) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: HPageBreaks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: HPageBreaks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: HPageBreaks) Item* (Index: INTEGER): HPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisHPageBreak(CtlC.VarAny(ret)) END Item; PROCEDURE (this: HPageBreaks) _Default* (Index: INTEGER): HPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisHPageBreak(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: HPageBreaks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HPageBreaks) Add* (Before: CtlT.Object): HPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Before, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisHPageBreak(CtlC.VarAny(ret)) END Add; (* ---------- VPageBreaks ---------- *) PROCEDURE (this: VPageBreaks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: VPageBreaks) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: VPageBreaks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: VPageBreaks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: VPageBreaks) Item* (Index: INTEGER): VPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisVPageBreak(CtlC.VarAny(ret)) END Item; PROCEDURE (this: VPageBreaks) _Default* (Index: INTEGER): VPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisVPageBreak(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: VPageBreaks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: VPageBreaks) Add* (Before: CtlT.Object): VPageBreak, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Before, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisVPageBreak(CtlC.VarAny(ret)) END Add; (* ---------- RecentFile ---------- *) PROCEDURE (this: RecentFile) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: RecentFile) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: RecentFile) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: RecentFile) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: RecentFile) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 291) END Path; PROCEDURE (this: RecentFile) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: RecentFile) Open* (): Workbook, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 682, ret); RETURN This_Workbook(CtlC.VarAny(ret)) END Open; PROCEDURE (this: RecentFile) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- RecentFiles ---------- *) PROCEDURE (this: RecentFiles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: RecentFiles) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: RecentFiles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: RecentFiles) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1423) END Maximum; PROCEDURE (this: RecentFiles) PUTMaximum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1423, p1) END PUTMaximum; PROCEDURE (this: RecentFiles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: RecentFiles) Item* (Index: INTEGER): RecentFile, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisRecentFile(CtlC.VarAny(ret)) END Item; PROCEDURE (this: RecentFiles) _Default* (Index: INTEGER): RecentFile, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisRecentFile(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: RecentFiles) Add* (Name: ARRAY OF CHAR): RecentFile, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisRecentFile(CtlC.VarAny(ret)) END Add; PROCEDURE (this: RecentFiles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- DocEvents, hidden ---------- *) PROCEDURE (this: DocEvents) SelectionChange* (Target: Range), NEW, ABSTRACT; PROCEDURE (this: DocEvents) BeforeDoubleClick* (Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: DocEvents) BeforeRightClick* (Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: DocEvents) Activate* (), NEW, ABSTRACT; PROCEDURE (this: DocEvents) Deactivate* (), NEW, ABSTRACT; PROCEDURE (this: DocEvents) Calculate* (), NEW, ABSTRACT; PROCEDURE (this: DocEvents) Change* (Target: Range), NEW, ABSTRACT; PROCEDURE (this: DocEvents) FollowHyperlink* (Target: Hyperlink), NEW, ABSTRACT; PROCEDURE (this: DocEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1543: ASSERT(n = 1, 11); this.SelectionChange(ThisRange(CtlC.VarAny(par[0]))) | 1537: ASSERT(n = 2, 11); this.BeforeDoubleClick(ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1534: ASSERT(n = 2, 11); this.BeforeRightClick(ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 304: ASSERT(n = 0, 11); this.Activate() | 1530: ASSERT(n = 0, 11); this.Deactivate() | 279: ASSERT(n = 0, 11); this.Calculate() | 1545: ASSERT(n = 1, 11); this.Change(ThisRange(CtlC.VarAny(par[0]))) | 1470: ASSERT(n = 1, 11); this.FollowHyperlink(ThisHyperlink(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: DocEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00024411-0000-0000-C000-000000000046}" END GetIID; (* ---------- Style ---------- *) PROCEDURE (this: Style) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Style) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Style) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Style) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Style) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Style) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 553) END BuiltIn; PROCEDURE (this: Style) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 435)) END Borders; PROCEDURE (this: Style) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Style) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Style) FormulaHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END FormulaHidden; PROCEDURE (this: Style) PUTFormulaHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTFormulaHidden; PROCEDURE (this: Style) HorizontalAlignment* (): XlHAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 136) END HorizontalAlignment; PROCEDURE (this: Style) PUTHorizontalAlignment* (p1: XlHAlign), NEW; BEGIN CtlC.PutInt(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Style) IncludeAlignment* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 413) END IncludeAlignment; PROCEDURE (this: Style) PUTIncludeAlignment* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 413, p1) END PUTIncludeAlignment; PROCEDURE (this: Style) IncludeBorder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 414) END IncludeBorder; PROCEDURE (this: Style) PUTIncludeBorder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 414, p1) END PUTIncludeBorder; PROCEDURE (this: Style) IncludeFont* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 415) END IncludeFont; PROCEDURE (this: Style) PUTIncludeFont* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 415, p1) END PUTIncludeFont; PROCEDURE (this: Style) IncludeNumber* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 416) END IncludeNumber; PROCEDURE (this: Style) PUTIncludeNumber* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 416, p1) END PUTIncludeNumber; PROCEDURE (this: Style) IncludePatterns* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 417) END IncludePatterns; PROCEDURE (this: Style) PUTIncludePatterns* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 417, p1) END PUTIncludePatterns; PROCEDURE (this: Style) IncludeProtection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 418) END IncludeProtection; PROCEDURE (this: Style) PUTIncludeProtection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 418, p1) END PUTIncludeProtection; PROCEDURE (this: Style) IndentLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 201) END IndentLevel; PROCEDURE (this: Style) PUTIndentLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 201, p1) END PUTIndentLevel; PROCEDURE (this: Style) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Style) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Style) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Style) MergeCells* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 208) END MergeCells; PROCEDURE (this: Style) PUTMergeCells* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 208, p1) END PUTMergeCells; PROCEDURE (this: Style) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Style) NameLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 937) END NameLocal; PROCEDURE (this: Style) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: Style) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: Style) NumberFormatLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1097) END NumberFormatLocal; PROCEDURE (this: Style) PUTNumberFormatLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: Style) Orientation* (): XlOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: Style) PUTOrientation* (p1: XlOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: Style) ShrinkToFit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 209) END ShrinkToFit; PROCEDURE (this: Style) PUTShrinkToFit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 209, p1) END PUTShrinkToFit; PROCEDURE (this: Style) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: Style) VerticalAlignment* (): XlVAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 137) END VerticalAlignment; PROCEDURE (this: Style) PUTVerticalAlignment* (p1: XlVAlign), NEW; BEGIN CtlC.PutInt(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Style) WrapText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 276) END WrapText; PROCEDURE (this: Style) PUTWrapText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 276, p1) END PUTWrapText; PROCEDURE (this: Style) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: Style) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Style) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; (* ---------- Styles ---------- *) PROCEDURE (this: Styles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Styles) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Styles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Styles) Add* (Name: ARRAY OF CHAR; (* optional *) BasedOn: CtlT.Any): Style, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(BasedOn, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisStyle(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Styles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Styles) Item* (Index: CtlT.Any): Style, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisStyle(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Styles) Merge* (Workbook: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Workbook, arg[0]); CtlC.CallParMethod(this, 564, arg, ret); RETURN CtlC.VarAny(ret) END Merge; PROCEDURE (this: Styles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Styles) _Default* (Index: CtlT.Any): Style, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisStyle(CtlC.VarAny(ret)) END _Default; (* ---------- Borders ---------- *) PROCEDURE (this: Borders) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Borders) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Borders) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Borders) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Borders) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Borders) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Borders) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Borders) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Borders) Item* (Index: XlBordersIndex): Border, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisBorder(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Borders) LineStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 119) END LineStyle; PROCEDURE (this: Borders) PUTLineStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 119, p1) END PUTLineStyle; PROCEDURE (this: Borders) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Borders) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: Borders) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: Borders) Weight* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 120) END Weight; PROCEDURE (this: Borders) PUTWeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 120, p1) END PUTWeight; PROCEDURE (this: Borders) _Default* (Index: XlBordersIndex): Border, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisBorder(CtlC.VarAny(ret)) END _Default; (* ---------- AddIn ---------- *) PROCEDURE (this: AddIn) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AddIn) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AddIn) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AddIn) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 574) END Author; PROCEDURE (this: AddIn) Comments* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 575) END Comments; PROCEDURE (this: AddIn) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 289) END FullName; PROCEDURE (this: AddIn) Installed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 550) END Installed; PROCEDURE (this: AddIn) PUTInstalled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 550, p1) END PUTInstalled; PROCEDURE (this: AddIn) Keywords* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 577) END Keywords; PROCEDURE (this: AddIn) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: AddIn) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 291) END Path; PROCEDURE (this: AddIn) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 953) END Subject; PROCEDURE (this: AddIn) Title* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 199) END Title; (* ---------- AddIns ---------- *) PROCEDURE (this: AddIns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AddIns) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AddIns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AddIns) Add* (Filename: ARRAY OF CHAR; (* optional *) CopyFile: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[1]); CtlC.AnyVar(CopyFile, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AddIns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: AddIns) Item* (Index: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AddIns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AddIns) _Default* (Index: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END _Default; (* ---------- Toolbar, hidden ---------- *) PROCEDURE (this: Toolbar) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Toolbar) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Toolbar) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Toolbar) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 553) END BuiltIn; PROCEDURE (this: Toolbar) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Toolbar) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 123) END Height; PROCEDURE (this: Toolbar) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 123, p1) END PUTHeight; PROCEDURE (this: Toolbar) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Left; PROCEDURE (this: Toolbar) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTLeft; PROCEDURE (this: Toolbar) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Toolbar) Position* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: Toolbar) PUTPosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: Toolbar) Protection* (): XlToolbarProtection, NEW; BEGIN RETURN CtlC.GetInt(this, 176) END Protection; PROCEDURE (this: Toolbar) PUTProtection* (p1: XlToolbarProtection), NEW; BEGIN CtlC.PutInt(this, 176, p1) END PUTProtection; PROCEDURE (this: Toolbar) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 555, NIL); END Reset; PROCEDURE (this: Toolbar) ToolbarButtons* (): ToolbarButtons, NEW; BEGIN RETURN ThisToolbarButtons(CtlC.GetAny(this, 964)) END ToolbarButtons; PROCEDURE (this: Toolbar) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 126) END Top; PROCEDURE (this: Toolbar) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 126, p1) END PUTTop; PROCEDURE (this: Toolbar) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Toolbar) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Toolbar) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END Width; PROCEDURE (this: Toolbar) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTWidth; (* ---------- Toolbars, hidden ---------- *) PROCEDURE (this: Toolbars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Toolbars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Toolbars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Toolbars) Add* ((* optional *) Name: CtlT.Any): Toolbar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisToolbar(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Toolbars) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Toolbars) _Default* (Index: CtlT.Any): Toolbar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisToolbar(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Toolbars) Item* (Index: CtlT.Any): Toolbar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisToolbar(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Toolbars) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- ToolbarButton, hidden ---------- *) PROCEDURE (this: ToolbarButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ToolbarButton) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ToolbarButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ToolbarButton) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 553) END BuiltIn; PROCEDURE (this: ToolbarButton) BuiltInFace* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 554) END BuiltInFace; PROCEDURE (this: ToolbarButton) PUTBuiltInFace* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 554, p1) END PUTBuiltInFace; PROCEDURE (this: ToolbarButton) Copy* (toolbar: Toolbar; Before: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(toolbar, arg[1]); CtlC.IntVar(Before, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: ToolbarButton) CopyFace* (), NEW; BEGIN CtlC.CallMethod(this, 966, NIL); END CopyFace; PROCEDURE (this: ToolbarButton) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: ToolbarButton) Edit* (), NEW; BEGIN CtlC.CallMethod(this, 562, NIL); END Edit; PROCEDURE (this: ToolbarButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ToolbarButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ToolbarButton) HelpContextID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 355) END HelpContextID; PROCEDURE (this: ToolbarButton) PUTHelpContextID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 355, p1) END PUTHelpContextID; PROCEDURE (this: ToolbarButton) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 360) END HelpFile; PROCEDURE (this: ToolbarButton) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 360, p1) END PUTHelpFile; PROCEDURE (this: ToolbarButton) ID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 570) END ID; PROCEDURE (this: ToolbarButton) IsGap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 561) END IsGap; PROCEDURE (this: ToolbarButton) Move* (toolbar: Toolbar; Before: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(toolbar, arg[1]); CtlC.IntVar(Before, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: ToolbarButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ToolbarButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: ToolbarButton) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ToolbarButton) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ToolbarButton) PasteFace* (), NEW; BEGIN CtlC.CallMethod(this, 967, NIL); END PasteFace; PROCEDURE (this: ToolbarButton) Pushed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 560) END Pushed; PROCEDURE (this: ToolbarButton) PUTPushed* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 560, p1) END PUTPushed; PROCEDURE (this: ToolbarButton) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 555, NIL); END Reset; PROCEDURE (this: ToolbarButton) StatusBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 386) END StatusBar; PROCEDURE (this: ToolbarButton) PUTStatusBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 386, p1) END PUTStatusBar; PROCEDURE (this: ToolbarButton) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END Width; PROCEDURE (this: ToolbarButton) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTWidth; (* ---------- ToolbarButtons, hidden ---------- *) PROCEDURE (this: ToolbarButtons) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ToolbarButtons) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ToolbarButtons) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ToolbarButtons) Add* ((* optional *) Button: CtlT.Any; Before: CtlT.Any; OnAction: CtlT.Any; Pushed: CtlT.Any; Enabled: CtlT.Any; StatusBar: CtlT.Any; HelpFile: CtlT.Any; HelpContextID: CtlT.Any): ToolbarButton, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Button, arg[7]); CtlC.AnyVar(Before, arg[6]); CtlC.AnyVar(OnAction, arg[5]); CtlC.AnyVar(Pushed, arg[4]); CtlC.AnyVar(Enabled, arg[3]); CtlC.AnyVar(StatusBar, arg[2]); CtlC.AnyVar(HelpFile, arg[1]); CtlC.AnyVar(HelpContextID, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisToolbarButton(CtlC.VarAny(ret)) END Add; PROCEDURE (this: ToolbarButtons) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ToolbarButtons) Item* (Index: INTEGER): ToolbarButton, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisToolbarButton(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ToolbarButtons) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ToolbarButtons) _Default* (Index: INTEGER): ToolbarButton, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisToolbarButton(CtlC.VarAny(ret)) END _Default; (* ---------- Areas ---------- *) PROCEDURE (this: Areas) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Areas) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Areas) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Areas) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Areas) Item* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Areas) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Areas) _Default* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END _Default; (* ---------- WorkbookEvents, hidden ---------- *) PROCEDURE (this: WorkbookEvents) Open* (), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) Activate* (), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) Deactivate* (), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) BeforeClose* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) BeforeSave* (SaveAsUI: BOOLEAN; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) BeforePrint* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) NewSheet* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) AddinInstall* (), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) AddinUninstall* (), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) WindowResize* (Wn: Window), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) WindowActivate* (Wn: Window), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) WindowDeactivate* (Wn: Window), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetSelectionChange* (Sh: CtlT.Object; Target: Range), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetBeforeDoubleClick* (Sh: CtlT.Object; Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetBeforeRightClick* (Sh: CtlT.Object; Target: Range; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetActivate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetDeactivate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetCalculate* (Sh: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetChange* (Sh: CtlT.Object; Target: Range), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) SheetFollowHyperlink* (Sh: CtlT.Object; Target: Hyperlink), NEW, ABSTRACT; PROCEDURE (this: WorkbookEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 682: ASSERT(n = 0, 11); this.Open() | 304: ASSERT(n = 0, 11); this.Activate() | 1530: ASSERT(n = 0, 11); this.Deactivate() | 1546: ASSERT(n = 1, 11); this.BeforeClose(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1547: ASSERT(n = 2, 11); this.BeforeSave(CtlC.VarBool(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1549: ASSERT(n = 1, 11); this.BeforePrint(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1550: ASSERT(n = 1, 11); this.NewSheet(CtlC.VarObj(par[0])) | 1552: ASSERT(n = 0, 11); this.AddinInstall() | 1553: ASSERT(n = 0, 11); this.AddinUninstall() | 1554: ASSERT(n = 1, 11); this.WindowResize(ThisWindow(CtlC.VarAny(par[0]))) | 1556: ASSERT(n = 1, 11); this.WindowActivate(ThisWindow(CtlC.VarAny(par[0]))) | 1557: ASSERT(n = 1, 11); this.WindowDeactivate(ThisWindow(CtlC.VarAny(par[0]))) | 1558: ASSERT(n = 2, 11); this.SheetSelectionChange(CtlC.VarObj(par[1]), ThisRange(CtlC.VarAny(par[0]))) | 1559: ASSERT(n = 3, 11); this.SheetBeforeDoubleClick(CtlC.VarObj(par[2]), ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1560: ASSERT(n = 3, 11); this.SheetBeforeRightClick(CtlC.VarObj(par[2]), ThisRange(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1561: ASSERT(n = 1, 11); this.SheetActivate(CtlC.VarObj(par[0])) | 1562: ASSERT(n = 1, 11); this.SheetDeactivate(CtlC.VarObj(par[0])) | 1563: ASSERT(n = 1, 11); this.SheetCalculate(CtlC.VarObj(par[0])) | 1564: ASSERT(n = 2, 11); this.SheetChange(CtlC.VarObj(par[1]), ThisRange(CtlC.VarAny(par[0]))) | 1854: ASSERT(n = 2, 11); this.SheetFollowHyperlink(CtlC.VarObj(par[1]), ThisHyperlink(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: WorkbookEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00024412-0000-0000-C000-000000000046}" END GetIID; (* ---------- MenuBars, hidden ---------- *) PROCEDURE (this: MenuBars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: MenuBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: MenuBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: MenuBars) Add* ((* optional *) Name: CtlT.Any): MenuBar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisMenuBar(CtlC.VarAny(ret)) END Add; PROCEDURE (this: MenuBars) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: MenuBars) _Default* (Index: CtlT.Any): MenuBar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisMenuBar(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: MenuBars) Item* (Index: CtlT.Any): MenuBar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisMenuBar(CtlC.VarAny(ret)) END Item; PROCEDURE (this: MenuBars) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- MenuBar, hidden ---------- *) PROCEDURE (this: MenuBar) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: MenuBar) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: MenuBar) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: MenuBar) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: MenuBar) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 553) END BuiltIn; PROCEDURE (this: MenuBar) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: MenuBar) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: MenuBar) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: MenuBar) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: MenuBar) Menus* (): Menus, NEW; BEGIN RETURN ThisMenus(CtlC.GetAny(this, 591)) END Menus; PROCEDURE (this: MenuBar) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 555, NIL); END Reset; (* ---------- Menus, hidden ---------- *) PROCEDURE (this: Menus) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Menus) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Menus) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Menus) Add* (Caption: ARRAY OF CHAR; (* optional *) Before: CtlT.Any; Restore: CtlT.Any): Menu, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Caption, arg[2]); CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(Restore, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Menus) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Menus) _Default* (Index: CtlT.Any): Menu, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Menus) Item* (Index: CtlT.Any): Menu, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Menus) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Menu, hidden ---------- *) PROCEDURE (this: Menu) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Menu) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Menu) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Menu) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Menu) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Menu) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Menu) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Menu) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Menu) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Menu) MenuItems* (): MenuItems, NEW; BEGIN RETURN ThisMenuItems(CtlC.GetAny(this, 593)) END MenuItems; (* ---------- MenuItems, hidden ---------- *) PROCEDURE (this: MenuItems) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: MenuItems) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: MenuItems) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: MenuItems) Add* (Caption: ARRAY OF CHAR; (* optional *) OnAction: CtlT.Any; ShortcutKey: CtlT.Any; Before: CtlT.Any; Restore: CtlT.Any; StatusBar: CtlT.Any; HelpFile: CtlT.Any; HelpContextID: CtlT.Any): MenuItem, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Caption, arg[7]); CtlC.AnyVar(OnAction, arg[6]); CtlC.AnyVar(ShortcutKey, arg[5]); CtlC.AnyVar(Before, arg[4]); CtlC.AnyVar(Restore, arg[3]); CtlC.AnyVar(StatusBar, arg[2]); CtlC.AnyVar(HelpFile, arg[1]); CtlC.AnyVar(HelpContextID, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisMenuItem(CtlC.VarAny(ret)) END Add; PROCEDURE (this: MenuItems) AddMenu* (Caption: ARRAY OF CHAR; (* optional *) Before: CtlT.Any; Restore: CtlT.Any): Menu, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Caption, arg[2]); CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(Restore, arg[0]); CtlC.CallParMethod(this, 598, arg, ret); RETURN ThisMenu(CtlC.VarAny(ret)) END AddMenu; PROCEDURE (this: MenuItems) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: MenuItems) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: MenuItems) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: MenuItems) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- MenuItem, hidden ---------- *) PROCEDURE (this: MenuItem) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: MenuItem) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: MenuItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: MenuItem) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: MenuItem) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: MenuItem) Checked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 599) END Checked; PROCEDURE (this: MenuItem) PUTChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 599, p1) END PUTChecked; PROCEDURE (this: MenuItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: MenuItem) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: MenuItem) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: MenuItem) HelpContextID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 355) END HelpContextID; PROCEDURE (this: MenuItem) PUTHelpContextID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 355, p1) END PUTHelpContextID; PROCEDURE (this: MenuItem) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 360) END HelpFile; PROCEDURE (this: MenuItem) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 360, p1) END PUTHelpFile; PROCEDURE (this: MenuItem) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: MenuItem) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: MenuItem) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: MenuItem) StatusBar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 386) END StatusBar; PROCEDURE (this: MenuItem) PUTStatusBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 386, p1) END PUTStatusBar; (* ---------- Charts ---------- *) PROCEDURE (this: Charts) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Charts) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Charts) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Charts) Add* ((* optional *) Before: CtlT.Any; After: CtlT.Any; Count: CtlT.Any): Chart, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[2]); CtlC.AnyVar(After, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN This_Chart(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Charts) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Charts) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Charts) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Charts) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Charts) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: Charts) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Charts) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: Charts) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: Charts) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Charts) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: Charts) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: Charts) Visible* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 558) END Visible; PROCEDURE (this: Charts) PUTVisible* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 558, p1) END PUTVisible; PROCEDURE (this: Charts) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: Charts) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- DrawingObjects, hidden ---------- *) PROCEDURE (this: DrawingObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DrawingObjects) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DrawingObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DrawingObjects) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: DrawingObjects) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: DrawingObjects) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: DrawingObjects) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: DrawingObjects) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DrawingObjects) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: DrawingObjects) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: DrawingObjects) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: DrawingObjects) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: DrawingObjects) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: DrawingObjects) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DrawingObjects) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DrawingObjects) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: DrawingObjects) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: DrawingObjects) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: DrawingObjects) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: DrawingObjects) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: DrawingObjects) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: DrawingObjects) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: DrawingObjects) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: DrawingObjects) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DrawingObjects) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: DrawingObjects) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DrawingObjects) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DrawingObjects) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: DrawingObjects) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: DrawingObjects) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: DrawingObjects) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: DrawingObjects) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: DrawingObjects) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: DrawingObjects) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: DrawingObjects) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: DrawingObjects) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: DrawingObjects) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: DrawingObjects) AddItem* (Text: CtlT.Any; (* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, ret); RETURN CtlC.VarAny(ret) END AddItem; PROCEDURE (this: DrawingObjects) ArrowHeadLength* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END ArrowHeadLength; PROCEDURE (this: DrawingObjects) PUTArrowHeadLength* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTArrowHeadLength; PROCEDURE (this: DrawingObjects) ArrowHeadStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END ArrowHeadStyle; PROCEDURE (this: DrawingObjects) PUTArrowHeadStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTArrowHeadStyle; PROCEDURE (this: DrawingObjects) ArrowHeadWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 613) END ArrowHeadWidth; PROCEDURE (this: DrawingObjects) PUTArrowHeadWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 613, p1) END PUTArrowHeadWidth; PROCEDURE (this: DrawingObjects) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: DrawingObjects) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: DrawingObjects) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DrawingObjects) CancelButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 858) END CancelButton; PROCEDURE (this: DrawingObjects) PUTCancelButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 858, p1) END PUTCancelButton; PROCEDURE (this: DrawingObjects) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DrawingObjects) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DrawingObjects) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DrawingObjects) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: DrawingObjects) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: DrawingObjects) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: DrawingObjects) DefaultButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 857) END DefaultButton; PROCEDURE (this: DrawingObjects) PUTDefaultButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 857, p1) END PUTDefaultButton; PROCEDURE (this: DrawingObjects) DismissButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 859) END DismissButton; PROCEDURE (this: DrawingObjects) PUTDismissButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 859, p1) END PUTDismissButton; PROCEDURE (this: DrawingObjects) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: DrawingObjects) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: DrawingObjects) DisplayVerticalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 922) END DisplayVerticalScrollBar; PROCEDURE (this: DrawingObjects) PUTDisplayVerticalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 922, p1) END PUTDisplayVerticalScrollBar; PROCEDURE (this: DrawingObjects) DropDownLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 848) END DropDownLines; PROCEDURE (this: DrawingObjects) PUTDropDownLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 848, p1) END PUTDropDownLines; PROCEDURE (this: DrawingObjects) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DrawingObjects) HelpButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 860) END HelpButton; PROCEDURE (this: DrawingObjects) PUTHelpButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 860, p1) END PUTHelpButton; PROCEDURE (this: DrawingObjects) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DrawingObjects) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DrawingObjects) InputType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 854) END InputType; PROCEDURE (this: DrawingObjects) PUTInputType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 854, p1) END PUTInputType; PROCEDURE (this: DrawingObjects) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DrawingObjects) LargeChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 845) END LargeChange; PROCEDURE (this: DrawingObjects) PUTLargeChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 845, p1) END PUTLargeChange; PROCEDURE (this: DrawingObjects) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: DrawingObjects) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: DrawingObjects) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: DrawingObjects) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: DrawingObjects) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: DrawingObjects) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: DrawingObjects) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: DrawingObjects) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: DrawingObjects) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: DrawingObjects) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: DrawingObjects) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: DrawingObjects) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: DrawingObjects) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: DrawingObjects) MultiLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 855) END MultiLine; PROCEDURE (this: DrawingObjects) PUTMultiLine* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 855, p1) END PUTMultiLine; PROCEDURE (this: DrawingObjects) MultiSelect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 32) END MultiSelect; PROCEDURE (this: DrawingObjects) PUTMultiSelect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 32, p1) END PUTMultiSelect; PROCEDURE (this: DrawingObjects) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DrawingObjects) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DrawingObjects) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: DrawingObjects) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: DrawingObjects) RemoveAllItems* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 853, ret); RETURN CtlC.VarAny(ret) END RemoveAllItems; PROCEDURE (this: DrawingObjects) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, ret); RETURN CtlC.VarAny(ret) END RemoveItem; PROCEDURE (this: DrawingObjects) Reshape* (Vertex: INTEGER; Insert: CtlT.Any; (* optional *) Left: CtlT.Any; Top: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Vertex, arg[3]); CtlC.AnyVar(Insert, arg[2]); CtlC.AnyVar(Left, arg[1]); CtlC.AnyVar(Top, arg[0]); CtlC.CallParMethod(this, 604, arg, ret); RETURN CtlC.VarAny(ret) END Reshape; PROCEDURE (this: DrawingObjects) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: DrawingObjects) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: DrawingObjects) Selected* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1123, arg, ret); RETURN CtlC.VarAny(ret) END Selected; PROCEDURE (this: DrawingObjects) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DrawingObjects) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DrawingObjects) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: DrawingObjects) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: DrawingObjects) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DrawingObjects) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DrawingObjects) Ungroup* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN CtlC.VarObj(ret) END Ungroup; PROCEDURE (this: DrawingObjects) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: DrawingObjects) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: DrawingObjects) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DrawingObjects) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DrawingObjects) Vertices* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallParMethod(this, 621, arg, ret); RETURN CtlC.VarAny(ret) END Vertices; PROCEDURE (this: DrawingObjects) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DrawingObjects) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DrawingObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: DrawingObjects) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: DrawingObjects) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: DrawingObjects) LinkCombo* ((* optional *) Link: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Link, arg[0]); CtlC.CallParMethod(this, 856, arg, ret); RETURN CtlC.VarAny(ret) END LinkCombo; PROCEDURE (this: DrawingObjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- PivotCache ---------- *) PROCEDURE (this: PivotCache) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotCache) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotCache) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotCache) BackgroundQuery* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1427) END BackgroundQuery; PROCEDURE (this: PivotCache) PUTBackgroundQuery* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1427, p1) END PUTBackgroundQuery; PROCEDURE (this: PivotCache) Connection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1432) END Connection; PROCEDURE (this: PivotCache) PUTConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1432, p1) END PUTConnection; PROCEDURE (this: PivotCache) EnableRefresh* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1477) END EnableRefresh; PROCEDURE (this: PivotCache) PUTEnableRefresh* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1477, p1) END PUTEnableRefresh; PROCEDURE (this: PivotCache) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: PivotCache) MemoryUsed* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 372) END MemoryUsed; PROCEDURE (this: PivotCache) OptimizeCache* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1428) END OptimizeCache; PROCEDURE (this: PivotCache) PUTOptimizeCache* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1428, p1) END PUTOptimizeCache; PROCEDURE (this: PivotCache) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1478) END RecordCount; PROCEDURE (this: PivotCache) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1417, NIL); END Refresh; PROCEDURE (this: PivotCache) RefreshDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 696) END RefreshDate; PROCEDURE (this: PivotCache) RefreshName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 697) END RefreshName; PROCEDURE (this: PivotCache) RefreshOnFileOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1479) END RefreshOnFileOpen; PROCEDURE (this: PivotCache) PUTRefreshOnFileOpen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1479, p1) END PUTRefreshOnFileOpen; PROCEDURE (this: PivotCache) Sql* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1480) END Sql; PROCEDURE (this: PivotCache) PUTSql* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1480, p1) END PUTSql; PROCEDURE (this: PivotCache) SavePassword* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1481) END SavePassword; PROCEDURE (this: PivotCache) PUTSavePassword* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1481, p1) END PUTSavePassword; PROCEDURE (this: PivotCache) SourceData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 686) END SourceData; PROCEDURE (this: PivotCache) PUTSourceData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 686, p1) END PUTSourceData; PROCEDURE (this: PivotCache) CommandText* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1829) END CommandText; PROCEDURE (this: PivotCache) PUTCommandText* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1829, p1) END PUTCommandText; PROCEDURE (this: PivotCache) CommandType* (): XlCmdType, NEW; BEGIN RETURN CtlC.GetInt(this, 1830) END CommandType; PROCEDURE (this: PivotCache) PUTCommandType* (p1: XlCmdType), NEW; BEGIN CtlC.PutInt(this, 1830, p1) END PUTCommandType; PROCEDURE (this: PivotCache) QueryType* (): xlQueryType, NEW; BEGIN RETURN CtlC.GetInt(this, 1831) END QueryType; PROCEDURE (this: PivotCache) MaintainConnection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1832) END MaintainConnection; PROCEDURE (this: PivotCache) PUTMaintainConnection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1832, p1) END PUTMaintainConnection; PROCEDURE (this: PivotCache) RefreshPeriod* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1833) END RefreshPeriod; PROCEDURE (this: PivotCache) PUTRefreshPeriod* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1833, p1) END PUTRefreshPeriod; PROCEDURE (this: PivotCache) Recordset* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1165) END Recordset; PROCEDURE (this: PivotCache) PUTREFRecordset* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1165, arg, NIL); END PUTREFRecordset; PROCEDURE (this: PivotCache) ResetTimer* (), NEW; BEGIN CtlC.CallMethod(this, 1834, NIL); END ResetTimer; PROCEDURE (this: PivotCache) LocalConnection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1835) END LocalConnection; PROCEDURE (this: PivotCache) PUTLocalConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1835, p1) END PUTLocalConnection; PROCEDURE (this: PivotCache) CreatePivotTable* (TableDestination: CtlT.Any; (* optional *) TableName: CtlT.Any; ReadData: CtlT.Any): PivotTable, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(TableDestination, arg[2]); CtlC.AnyVar(TableName, arg[1]); CtlC.AnyVar(ReadData, arg[0]); CtlC.CallParMethod(this, 1836, arg, ret); RETURN ThisPivotTable(CtlC.VarAny(ret)) END CreatePivotTable; PROCEDURE (this: PivotCache) UseLocalConnection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1837) END UseLocalConnection; PROCEDURE (this: PivotCache) PUTUseLocalConnection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1837, p1) END PUTUseLocalConnection; (* ---------- PivotCaches ---------- *) PROCEDURE (this: PivotCaches) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotCaches) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotCaches) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotCaches) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PivotCaches) Item* (Index: CtlT.Any): PivotCache, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPivotCache(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PivotCaches) _Default* (Index: CtlT.Any): PivotCache, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPivotCache(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: PivotCaches) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: PivotCaches) Add* (SourceType: XlPivotTableSourceType; (* optional *) SourceData: CtlT.Any): PivotCache, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SourceType, arg[1]); CtlC.AnyVar(SourceData, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPivotCache(CtlC.VarAny(ret)) END Add; (* ---------- PivotFormula ---------- *) PROCEDURE (this: PivotFormula) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotFormula) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotFormula) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotFormula) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: PivotFormula) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: PivotFormula) PUT_Default* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUT_Default; PROCEDURE (this: PivotFormula) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: PivotFormula) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: PivotFormula) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: PivotFormula) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTValue; PROCEDURE (this: PivotFormula) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: PivotFormula) PUTIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 486, p1) END PUTIndex; (* ---------- PivotFormulas ---------- *) PROCEDURE (this: PivotFormulas) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotFormulas) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotFormulas) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotFormulas) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PivotFormulas) Add* (Formula: ARRAY OF CHAR): PivotFormula, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Formula, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPivotFormula(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PivotFormulas) Item* (Index: CtlT.Any): PivotFormula, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPivotFormula(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PivotFormulas) _Default* (Index: CtlT.Any): PivotFormula, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPivotFormula(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: PivotFormulas) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- PivotTable ---------- *) PROCEDURE (this: PivotTable) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotTable) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotTable) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotTable) AddFields* ((* optional *) RowFields: CtlT.Any; ColumnFields: CtlT.Any; PageFields: CtlT.Any; AddToTable: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowFields, arg[3]); CtlC.AnyVar(ColumnFields, arg[2]); CtlC.AnyVar(PageFields, arg[1]); CtlC.AnyVar(AddToTable, arg[0]); CtlC.CallParMethod(this, 708, arg, ret); RETURN CtlC.VarAny(ret) END AddFields; PROCEDURE (this: PivotTable) ColumnFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 713, arg, ret); RETURN CtlC.VarObj(ret) END ColumnFields; PROCEDURE (this: PivotTable) ColumnGrand* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 694) END ColumnGrand; PROCEDURE (this: PivotTable) PUTColumnGrand* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 694, p1) END PUTColumnGrand; PROCEDURE (this: PivotTable) ColumnRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 702)) END ColumnRange; PROCEDURE (this: PivotTable) ShowPages* ((* optional *) PageField: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(PageField, arg[0]); CtlC.CallParMethod(this, 706, arg, ret); RETURN CtlC.VarAny(ret) END ShowPages; PROCEDURE (this: PivotTable) DataBodyRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 705)) END DataBodyRange; PROCEDURE (this: PivotTable) DataFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 715, arg, ret); RETURN CtlC.VarObj(ret) END DataFields; PROCEDURE (this: PivotTable) DataLabelRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 704)) END DataLabelRange; PROCEDURE (this: PivotTable) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: PivotTable) PUT_Default* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUT_Default; PROCEDURE (this: PivotTable) HasAutoFormat* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 695) END HasAutoFormat; PROCEDURE (this: PivotTable) PUTHasAutoFormat* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 695, p1) END PUTHasAutoFormat; PROCEDURE (this: PivotTable) HiddenFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 711, arg, ret); RETURN CtlC.VarObj(ret) END HiddenFields; PROCEDURE (this: PivotTable) InnerDetail* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 698) END InnerDetail; PROCEDURE (this: PivotTable) PUTInnerDetail* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 698, p1) END PUTInnerDetail; PROCEDURE (this: PivotTable) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: PivotTable) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: PivotTable) PageFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 714, arg, ret); RETURN CtlC.VarObj(ret) END PageFields; PROCEDURE (this: PivotTable) PageRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 703)) END PageRange; PROCEDURE (this: PivotTable) PageRangeCells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1482)) END PageRangeCells; PROCEDURE (this: PivotTable) PivotFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 718, arg, ret); RETURN CtlC.VarObj(ret) END PivotFields; PROCEDURE (this: PivotTable) RefreshDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 696) END RefreshDate; PROCEDURE (this: PivotTable) RefreshName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 697) END RefreshName; PROCEDURE (this: PivotTable) RefreshTable* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 717, ret); RETURN CtlC.VarBool(ret) END RefreshTable; PROCEDURE (this: PivotTable) RowFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 712, arg, ret); RETURN CtlC.VarObj(ret) END RowFields; PROCEDURE (this: PivotTable) RowGrand* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 693) END RowGrand; PROCEDURE (this: PivotTable) PUTRowGrand* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 693, p1) END PUTRowGrand; PROCEDURE (this: PivotTable) RowRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 701)) END RowRange; PROCEDURE (this: PivotTable) SaveData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 692) END SaveData; PROCEDURE (this: PivotTable) PUTSaveData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 692, p1) END PUTSaveData; PROCEDURE (this: PivotTable) SourceData* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 686) END SourceData; PROCEDURE (this: PivotTable) PUTSourceData* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 686, p1) END PUTSourceData; PROCEDURE (this: PivotTable) TableRange1* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 699)) END TableRange1; PROCEDURE (this: PivotTable) TableRange2* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 700)) END TableRange2; PROCEDURE (this: PivotTable) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: PivotTable) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTValue; PROCEDURE (this: PivotTable) VisibleFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 710, arg, ret); RETURN CtlC.VarObj(ret) END VisibleFields; PROCEDURE (this: PivotTable) CacheIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1483) END CacheIndex; PROCEDURE (this: PivotTable) PUTCacheIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1483, p1) END PUTCacheIndex; PROCEDURE (this: PivotTable) CalculatedFields* (): CalculatedFields, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1484, ret); RETURN ThisCalculatedFields(CtlC.VarAny(ret)) END CalculatedFields; PROCEDURE (this: PivotTable) DisplayErrorString* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1485) END DisplayErrorString; PROCEDURE (this: PivotTable) PUTDisplayErrorString* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1485, p1) END PUTDisplayErrorString; PROCEDURE (this: PivotTable) DisplayNullString* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1486) END DisplayNullString; PROCEDURE (this: PivotTable) PUTDisplayNullString* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1486, p1) END PUTDisplayNullString; PROCEDURE (this: PivotTable) EnableDrilldown* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1487) END EnableDrilldown; PROCEDURE (this: PivotTable) PUTEnableDrilldown* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1487, p1) END PUTEnableDrilldown; PROCEDURE (this: PivotTable) EnableFieldDialog* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1488) END EnableFieldDialog; PROCEDURE (this: PivotTable) PUTEnableFieldDialog* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1488, p1) END PUTEnableFieldDialog; PROCEDURE (this: PivotTable) EnableWizard* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1489) END EnableWizard; PROCEDURE (this: PivotTable) PUTEnableWizard* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1489, p1) END PUTEnableWizard; PROCEDURE (this: PivotTable) ErrorString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1490) END ErrorString; PROCEDURE (this: PivotTable) PUTErrorString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1490, p1) END PUTErrorString; PROCEDURE (this: PivotTable) GetData* (Name: ARRAY OF CHAR): REAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1491, arg, ret); RETURN CtlC.VarReal(ret) END GetData; PROCEDURE (this: PivotTable) ListFormulas* (), NEW; BEGIN CtlC.CallMethod(this, 1492, NIL); END ListFormulas; PROCEDURE (this: PivotTable) ManualUpdate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1493) END ManualUpdate; PROCEDURE (this: PivotTable) PUTManualUpdate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1493, p1) END PUTManualUpdate; PROCEDURE (this: PivotTable) MergeLabels* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1494) END MergeLabels; PROCEDURE (this: PivotTable) PUTMergeLabels* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1494, p1) END PUTMergeLabels; PROCEDURE (this: PivotTable) NullString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1495) END NullString; PROCEDURE (this: PivotTable) PUTNullString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1495, p1) END PUTNullString; PROCEDURE (this: PivotTable) PivotCache* (): PivotCache, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1496, ret); RETURN ThisPivotCache(CtlC.VarAny(ret)) END PivotCache; PROCEDURE (this: PivotTable) PivotFormulas* (): PivotFormulas, NEW; BEGIN RETURN ThisPivotFormulas(CtlC.GetAny(this, 1497)) END PivotFormulas; PROCEDURE (this: PivotTable) PivotTableWizard* ((* optional *) SourceType: CtlT.Any; SourceData: CtlT.Any; TableDestination: CtlT.Any; TableName: CtlT.Any; RowGrand: CtlT.Any; ColumnGrand: CtlT.Any; SaveData: CtlT.Any; HasAutoFormat: CtlT.Any; AutoPage: CtlT.Any; Reserved: CtlT.Any; BackgroundQuery: CtlT.Any; OptimizeCache: CtlT.Any; PageFieldOrder: CtlT.Any; PageFieldWrapCount: CtlT.Any; ReadData: CtlT.Any; Connection: CtlT.Any), NEW; VAR arg: ARRAY 16 OF CtlT.Variant; BEGIN CtlC.AnyVar(SourceType, arg[15]); CtlC.AnyVar(SourceData, arg[14]); CtlC.AnyVar(TableDestination, arg[13]); CtlC.AnyVar(TableName, arg[12]); CtlC.AnyVar(RowGrand, arg[11]); CtlC.AnyVar(ColumnGrand, arg[10]); CtlC.AnyVar(SaveData, arg[9]); CtlC.AnyVar(HasAutoFormat, arg[8]); CtlC.AnyVar(AutoPage, arg[7]); CtlC.AnyVar(Reserved, arg[6]); CtlC.AnyVar(BackgroundQuery, arg[5]); CtlC.AnyVar(OptimizeCache, arg[4]); CtlC.AnyVar(PageFieldOrder, arg[3]); CtlC.AnyVar(PageFieldWrapCount, arg[2]); CtlC.AnyVar(ReadData, arg[1]); CtlC.AnyVar(Connection, arg[0]); CtlC.CallParMethod(this, 684, arg, NIL); END PivotTableWizard; PROCEDURE (this: PivotTable) SubtotalHiddenPageItems* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1498) END SubtotalHiddenPageItems; PROCEDURE (this: PivotTable) PUTSubtotalHiddenPageItems* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1498, p1) END PUTSubtotalHiddenPageItems; PROCEDURE (this: PivotTable) PageFieldOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1429) END PageFieldOrder; PROCEDURE (this: PivotTable) PUTPageFieldOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1429, p1) END PUTPageFieldOrder; PROCEDURE (this: PivotTable) PageFieldStyle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1499) END PageFieldStyle; PROCEDURE (this: PivotTable) PUTPageFieldStyle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1499, p1) END PUTPageFieldStyle; PROCEDURE (this: PivotTable) PageFieldWrapCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1430) END PageFieldWrapCount; PROCEDURE (this: PivotTable) PUTPageFieldWrapCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1430, p1) END PUTPageFieldWrapCount; PROCEDURE (this: PivotTable) PreserveFormatting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1500) END PreserveFormatting; PROCEDURE (this: PivotTable) PUTPreserveFormatting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1500, p1) END PUTPreserveFormatting; PROCEDURE (this: PivotTable) PivotSelect* (Name: ARRAY OF CHAR; Mode: XlPTSelectionMode), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.IntVar(Mode, arg[0]); CtlC.CallParMethod(this, 1501, arg, NIL); END PivotSelect; PROCEDURE (this: PivotTable) PivotSelection* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1502) END PivotSelection; PROCEDURE (this: PivotTable) PUTPivotSelection* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1502, p1) END PUTPivotSelection; PROCEDURE (this: PivotTable) SelectionMode* (): XlPTSelectionMode, NEW; BEGIN RETURN CtlC.GetInt(this, 1503) END SelectionMode; PROCEDURE (this: PivotTable) PUTSelectionMode* (p1: XlPTSelectionMode), NEW; BEGIN CtlC.PutInt(this, 1503, p1) END PUTSelectionMode; PROCEDURE (this: PivotTable) TableStyle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1504) END TableStyle; PROCEDURE (this: PivotTable) PUTTableStyle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1504, p1) END PUTTableStyle; PROCEDURE (this: PivotTable) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1505) END Tag; PROCEDURE (this: PivotTable) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1505, p1) END PUTTag; PROCEDURE (this: PivotTable) Update* (), NEW; BEGIN CtlC.CallMethod(this, 680, NIL); END Update; PROCEDURE (this: PivotTable) VacatedStyle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1506) END VacatedStyle; PROCEDURE (this: PivotTable) PUTVacatedStyle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1506, p1) END PUTVacatedStyle; PROCEDURE (this: PivotTable) Format* (Format: xlPivotFormatType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 116, arg, NIL); END Format; PROCEDURE (this: PivotTable) PrintTitles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1838) END PrintTitles; PROCEDURE (this: PivotTable) PUTPrintTitles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1838, p1) END PUTPrintTitles; PROCEDURE (this: PivotTable) CubeFields* (): CubeFields, NEW; BEGIN RETURN ThisCubeFields(CtlC.GetAny(this, 1839)) END CubeFields; PROCEDURE (this: PivotTable) GrandTotalName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1840) END GrandTotalName; PROCEDURE (this: PivotTable) PUTGrandTotalName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1840, p1) END PUTGrandTotalName; PROCEDURE (this: PivotTable) SmallGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1841) END SmallGrid; PROCEDURE (this: PivotTable) PUTSmallGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1841, p1) END PUTSmallGrid; PROCEDURE (this: PivotTable) RepeatItemsOnEachPrintedPage* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1842) END RepeatItemsOnEachPrintedPage; PROCEDURE (this: PivotTable) PUTRepeatItemsOnEachPrintedPage* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1842, p1) END PUTRepeatItemsOnEachPrintedPage; PROCEDURE (this: PivotTable) TotalsAnnotation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1843) END TotalsAnnotation; PROCEDURE (this: PivotTable) PUTTotalsAnnotation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1843, p1) END PUTTotalsAnnotation; (* ---------- PivotTables ---------- *) PROCEDURE (this: PivotTables) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotTables) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotTables) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotTables) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PivotTables) Item* (Index: CtlT.Any): PivotTable, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPivotTable(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PivotTables) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: PivotTables) Add* (pivotCache: PivotCache; TableDestination: CtlT.Any; (* optional *) TableName: CtlT.Any; ReadData: CtlT.Any): PivotTable, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(pivotCache, arg[3]); CtlC.AnyVar(TableDestination, arg[2]); CtlC.AnyVar(TableName, arg[1]); CtlC.AnyVar(ReadData, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPivotTable(CtlC.VarAny(ret)) END Add; (* ---------- PivotField ---------- *) PROCEDURE (this: PivotField) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotField) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotField) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotField) Calculation* (): XlPivotFieldCalculation, NEW; BEGIN RETURN CtlC.GetInt(this, 316) END Calculation; PROCEDURE (this: PivotField) PUTCalculation* (p1: XlPivotFieldCalculation), NEW; BEGIN CtlC.PutInt(this, 316, p1) END PUTCalculation; PROCEDURE (this: PivotField) ChildField* (): PivotField, NEW; BEGIN RETURN ThisPivotField(CtlC.GetAny(this, 736)) END ChildField; PROCEDURE (this: PivotField) ChildItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 730, arg, ret); RETURN CtlC.VarAny(ret) END ChildItems; PROCEDURE (this: PivotField) CurrentPage* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 738) END CurrentPage; PROCEDURE (this: PivotField) PUTCurrentPage* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 738, p1) END PUTCurrentPage; PROCEDURE (this: PivotField) DataRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 720)) END DataRange; PROCEDURE (this: PivotField) DataType* (): XlPivotFieldDataType, NEW; BEGIN RETURN CtlC.GetInt(this, 722) END DataType; PROCEDURE (this: PivotField) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: PivotField) PUT_Default* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUT_Default; PROCEDURE (this: PivotField) Function* (): XlConsolidationFunction, NEW; BEGIN RETURN CtlC.GetInt(this, 899) END Function; PROCEDURE (this: PivotField) PUTFunction* (p1: XlConsolidationFunction), NEW; BEGIN CtlC.PutInt(this, 899, p1) END PUTFunction; PROCEDURE (this: PivotField) GroupLevel* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 723) END GroupLevel; PROCEDURE (this: PivotField) HiddenItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 728, arg, ret); RETURN CtlC.VarAny(ret) END HiddenItems; PROCEDURE (this: PivotField) LabelRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 719)) END LabelRange; PROCEDURE (this: PivotField) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: PivotField) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: PivotField) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: PivotField) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: PivotField) Orientation* (): XlPivotFieldOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: PivotField) PUTOrientation* (p1: XlPivotFieldOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: PivotField) ShowAllItems* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 452) END ShowAllItems; PROCEDURE (this: PivotField) PUTShowAllItems* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 452, p1) END PUTShowAllItems; PROCEDURE (this: PivotField) ParentField* (): PivotField, NEW; BEGIN RETURN ThisPivotField(CtlC.GetAny(this, 732)) END ParentField; PROCEDURE (this: PivotField) ParentItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 729, arg, ret); RETURN CtlC.VarAny(ret) END ParentItems; PROCEDURE (this: PivotField) PivotItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 737, arg, ret); RETURN CtlC.VarAny(ret) END PivotItems; PROCEDURE (this: PivotField) Position* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 133) END Position; PROCEDURE (this: PivotField) PUTPosition* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 133, p1) END PUTPosition; PROCEDURE (this: PivotField) SourceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 721) END SourceName; PROCEDURE (this: PivotField) Subtotals* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 733, arg, ret); RETURN CtlC.VarAny(ret) END Subtotals; PROCEDURE (this: PivotField) PUTSubtotals* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 733, arg, NIL); END PUTSubtotals; PROCEDURE (this: PivotField) BaseField* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 734) END BaseField; PROCEDURE (this: PivotField) PUTBaseField* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 734, p1) END PUTBaseField; PROCEDURE (this: PivotField) BaseItem* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 735) END BaseItem; PROCEDURE (this: PivotField) PUTBaseItem* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 735, p1) END PUTBaseItem; PROCEDURE (this: PivotField) TotalLevels* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 724) END TotalLevels; PROCEDURE (this: PivotField) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: PivotField) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTValue; PROCEDURE (this: PivotField) VisibleItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 727, arg, ret); RETURN CtlC.VarAny(ret) END VisibleItems; PROCEDURE (this: PivotField) CalculatedItems* (): CalculatedItems, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1507, ret); RETURN ThisCalculatedItems(CtlC.VarAny(ret)) END CalculatedItems; PROCEDURE (this: PivotField) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: PivotField) DragToColumn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1508) END DragToColumn; PROCEDURE (this: PivotField) PUTDragToColumn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1508, p1) END PUTDragToColumn; PROCEDURE (this: PivotField) DragToHide* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1509) END DragToHide; PROCEDURE (this: PivotField) PUTDragToHide* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1509, p1) END PUTDragToHide; PROCEDURE (this: PivotField) DragToPage* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1510) END DragToPage; PROCEDURE (this: PivotField) PUTDragToPage* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1510, p1) END PUTDragToPage; PROCEDURE (this: PivotField) DragToRow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1511) END DragToRow; PROCEDURE (this: PivotField) PUTDragToRow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1511, p1) END PUTDragToRow; PROCEDURE (this: PivotField) DragToData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1844) END DragToData; PROCEDURE (this: PivotField) PUTDragToData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1844, p1) END PUTDragToData; PROCEDURE (this: PivotField) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: PivotField) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: PivotField) IsCalculated* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1512) END IsCalculated; PROCEDURE (this: PivotField) MemoryUsed* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 372) END MemoryUsed; PROCEDURE (this: PivotField) ServerBased* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1513) END ServerBased; PROCEDURE (this: PivotField) PUTServerBased* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1513, p1) END PUTServerBased; PROCEDURE (this: PivotField) AutoSort* (Order: INTEGER; Field: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Order, arg[1]); CtlC.StrVar(Field, arg[0]); CtlC.CallParMethod(this, 1514, arg, NIL); END AutoSort; PROCEDURE (this: PivotField) AutoShow* (Type: INTEGER; Range: INTEGER; Count: INTEGER; Field: ARRAY OF CHAR), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Range, arg[2]); CtlC.IntVar(Count, arg[1]); CtlC.StrVar(Field, arg[0]); CtlC.CallParMethod(this, 1515, arg, NIL); END AutoShow; PROCEDURE (this: PivotField) AutoSortOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1516) END AutoSortOrder; PROCEDURE (this: PivotField) AutoSortField* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1517) END AutoSortField; PROCEDURE (this: PivotField) AutoShowType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1518) END AutoShowType; PROCEDURE (this: PivotField) AutoShowRange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1519) END AutoShowRange; PROCEDURE (this: PivotField) AutoShowCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1520) END AutoShowCount; PROCEDURE (this: PivotField) AutoShowField* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1521) END AutoShowField; PROCEDURE (this: PivotField) LayoutBlankLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1845) END LayoutBlankLine; PROCEDURE (this: PivotField) PUTLayoutBlankLine* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1845, p1) END PUTLayoutBlankLine; PROCEDURE (this: PivotField) LayoutSubtotalLocation* (): xLSubtototalLocationType, NEW; BEGIN RETURN CtlC.GetInt(this, 1846) END LayoutSubtotalLocation; PROCEDURE (this: PivotField) PUTLayoutSubtotalLocation* (p1: xLSubtototalLocationType), NEW; BEGIN CtlC.PutInt(this, 1846, p1) END PUTLayoutSubtotalLocation; PROCEDURE (this: PivotField) LayoutPageBreak* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1847) END LayoutPageBreak; PROCEDURE (this: PivotField) PUTLayoutPageBreak* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1847, p1) END PUTLayoutPageBreak; PROCEDURE (this: PivotField) LayoutForm* (): XlLayoutFormType, NEW; BEGIN RETURN CtlC.GetInt(this, 1848) END LayoutForm; PROCEDURE (this: PivotField) PUTLayoutForm* (p1: XlLayoutFormType), NEW; BEGIN CtlC.PutInt(this, 1848, p1) END PUTLayoutForm; PROCEDURE (this: PivotField) SubtotalName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1849) END SubtotalName; PROCEDURE (this: PivotField) PUTSubtotalName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1849, p1) END PUTSubtotalName; PROCEDURE (this: PivotField) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: PivotField) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: PivotField) DrilledDown* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1850) END DrilledDown; PROCEDURE (this: PivotField) PUTDrilledDown* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1850, p1) END PUTDrilledDown; PROCEDURE (this: PivotField) CubeField* (): CubeField, NEW; BEGIN RETURN ThisCubeField(CtlC.GetAny(this, 1851)) END CubeField; PROCEDURE (this: PivotField) CurrentPageName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1852) END CurrentPageName; PROCEDURE (this: PivotField) PUTCurrentPageName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1852, p1) END PUTCurrentPageName; (* ---------- PivotFields ---------- *) PROCEDURE (this: PivotFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotFields) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotFields) Parent* (): PivotTable, NEW; BEGIN RETURN ThisPivotTable(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: PivotFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PivotFields) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: PivotFields) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- CalculatedFields ---------- *) PROCEDURE (this: CalculatedFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CalculatedFields) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CalculatedFields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CalculatedFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: CalculatedFields) Add* (Name: ARRAY OF CHAR; Formula: ARRAY OF CHAR): PivotField, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(Formula, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPivotField(CtlC.VarAny(ret)) END Add; PROCEDURE (this: CalculatedFields) Item* (Index: CtlT.Any): PivotField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPivotField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CalculatedFields) _Default* (Field: CtlT.Any): PivotField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Field, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPivotField(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: CalculatedFields) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- PivotItem ---------- *) PROCEDURE (this: PivotItem) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotItem) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotItem) Parent* (): PivotField, NEW; BEGIN RETURN ThisPivotField(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: PivotItem) ChildItems* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 730, arg, ret); RETURN CtlC.VarAny(ret) END ChildItems; PROCEDURE (this: PivotItem) DataRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 720)) END DataRange; PROCEDURE (this: PivotItem) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: PivotItem) PUT_Default* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUT_Default; PROCEDURE (this: PivotItem) LabelRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 719)) END LabelRange; PROCEDURE (this: PivotItem) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: PivotItem) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: PivotItem) ParentItem* (): PivotItem, NEW; BEGIN RETURN ThisPivotItem(CtlC.GetAny(this, 741)) END ParentItem; PROCEDURE (this: PivotItem) ParentShowDetail* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 739) END ParentShowDetail; PROCEDURE (this: PivotItem) Position* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: PivotItem) PUTPosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: PivotItem) ShowDetail* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 585) END ShowDetail; PROCEDURE (this: PivotItem) PUTShowDetail* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 585, p1) END PUTShowDetail; PROCEDURE (this: PivotItem) SourceName* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 721) END SourceName; PROCEDURE (this: PivotItem) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: PivotItem) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTValue; PROCEDURE (this: PivotItem) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: PivotItem) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: PivotItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: PivotItem) IsCalculated* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1512) END IsCalculated; PROCEDURE (this: PivotItem) RecordCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1478) END RecordCount; PROCEDURE (this: PivotItem) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: PivotItem) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: PivotItem) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: PivotItem) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: PivotItem) DrilledDown* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1850) END DrilledDown; PROCEDURE (this: PivotItem) PUTDrilledDown* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1850, p1) END PUTDrilledDown; (* ---------- PivotItems ---------- *) PROCEDURE (this: PivotItems) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotItems) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotItems) Parent* (): PivotField, NEW; BEGIN RETURN ThisPivotField(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: PivotItems) Add* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, NIL); END Add; PROCEDURE (this: PivotItems) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PivotItems) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: PivotItems) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- CalculatedItems ---------- *) PROCEDURE (this: CalculatedItems) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CalculatedItems) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CalculatedItems) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CalculatedItems) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: CalculatedItems) Add* (Name: ARRAY OF CHAR; Formula: ARRAY OF CHAR): PivotItem, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(Formula, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPivotItem(CtlC.VarAny(ret)) END Add; PROCEDURE (this: CalculatedItems) Item* (Index: CtlT.Any): PivotItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPivotItem(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CalculatedItems) _Default* (Field: CtlT.Any): PivotItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Field, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPivotItem(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: CalculatedItems) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Characters ---------- *) PROCEDURE (this: Characters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Characters) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Characters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Characters) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Characters) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Characters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Characters) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Characters) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Characters) Insert* (String: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 252, arg, ret); RETURN CtlC.VarAny(ret) END Insert; PROCEDURE (this: Characters) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Characters) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Characters) PhoneticCharacters* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1522) END PhoneticCharacters; PROCEDURE (this: Characters) PUTPhoneticCharacters* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1522, p1) END PUTPhoneticCharacters; (* ---------- Dialogs ---------- *) PROCEDURE (this: Dialogs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Dialogs) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Dialogs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Dialogs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Dialogs) Item* (Index: XlBuiltInDialog): Dialog, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisDialog(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Dialogs) _Default* (Index: XlBuiltInDialog): Dialog, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisDialog(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Dialogs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Dialog ---------- *) PROCEDURE (this: Dialog) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Dialog) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Dialog) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Dialog) Show* ((* optional *) Arg1: CtlT.Any; Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any; Arg5: CtlT.Any; Arg6: CtlT.Any; Arg7: CtlT.Any; Arg8: CtlT.Any; Arg9: CtlT.Any; Arg10: CtlT.Any; Arg11: CtlT.Any; Arg12: CtlT.Any; Arg13: CtlT.Any; Arg14: CtlT.Any; Arg15: CtlT.Any; Arg16: CtlT.Any; Arg17: CtlT.Any; Arg18: CtlT.Any; Arg19: CtlT.Any; Arg20: CtlT.Any; Arg21: CtlT.Any; Arg22: CtlT.Any; Arg23: CtlT.Any; Arg24: CtlT.Any; Arg25: CtlT.Any; Arg26: CtlT.Any; Arg27: CtlT.Any; Arg28: CtlT.Any; Arg29: CtlT.Any; Arg30: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 30 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Arg1, arg[29]); CtlC.AnyVar(Arg2, arg[28]); CtlC.AnyVar(Arg3, arg[27]); CtlC.AnyVar(Arg4, arg[26]); CtlC.AnyVar(Arg5, arg[25]); CtlC.AnyVar(Arg6, arg[24]); CtlC.AnyVar(Arg7, arg[23]); CtlC.AnyVar(Arg8, arg[22]); CtlC.AnyVar(Arg9, arg[21]); CtlC.AnyVar(Arg10, arg[20]); CtlC.AnyVar(Arg11, arg[19]); CtlC.AnyVar(Arg12, arg[18]); CtlC.AnyVar(Arg13, arg[17]); CtlC.AnyVar(Arg14, arg[16]); CtlC.AnyVar(Arg15, arg[15]); CtlC.AnyVar(Arg16, arg[14]); CtlC.AnyVar(Arg17, arg[13]); CtlC.AnyVar(Arg18, arg[12]); CtlC.AnyVar(Arg19, arg[11]); CtlC.AnyVar(Arg20, arg[10]); CtlC.AnyVar(Arg21, arg[9]); CtlC.AnyVar(Arg22, arg[8]); CtlC.AnyVar(Arg23, arg[7]); CtlC.AnyVar(Arg24, arg[6]); CtlC.AnyVar(Arg25, arg[5]); CtlC.AnyVar(Arg26, arg[4]); CtlC.AnyVar(Arg27, arg[3]); CtlC.AnyVar(Arg28, arg[2]); CtlC.AnyVar(Arg29, arg[1]); CtlC.AnyVar(Arg30, arg[0]); CtlC.CallParMethod(this, 496, arg, ret); RETURN CtlC.VarBool(ret) END Show; (* ---------- SoundNote ---------- *) PROCEDURE (this: SoundNote) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: SoundNote) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: SoundNote) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: SoundNote) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: SoundNote) Import* (Filename: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[0]); CtlC.CallParMethod(this, 917, arg, ret); RETURN CtlC.VarAny(ret) END Import; PROCEDURE (this: SoundNote) Play* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 918, ret); RETURN CtlC.VarAny(ret) END Play; PROCEDURE (this: SoundNote) Record* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 919, ret); RETURN CtlC.VarAny(ret) END Record; (* ---------- Button, hidden ---------- *) PROCEDURE (this: Button) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Button) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Button) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Button) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Button) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Button) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Button) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Button) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Button) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Button) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Button) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Button) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Button) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Button) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Button) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Button) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Button) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Button) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Button) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Button) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Button) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Button) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Button) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Button) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Button) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Button) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Button) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Button) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Button) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Button) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Button) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Button) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Button) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Button) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Button) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Button) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Button) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Button) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Button) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Button) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Button) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Button) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Button) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Button) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Button) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Button) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Button) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Button) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Button) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Button) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Button) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Button) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Button) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Button) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Button) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Button) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Button) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Button) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Button) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Button) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Button) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Button) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Button) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Button) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: Button) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: Button) CancelButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 858) END CancelButton; PROCEDURE (this: Button) PUTCancelButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 858, p1) END PUTCancelButton; PROCEDURE (this: Button) DefaultButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 857) END DefaultButton; PROCEDURE (this: Button) PUTDefaultButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 857, p1) END PUTDefaultButton; PROCEDURE (this: Button) DismissButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 859) END DismissButton; PROCEDURE (this: Button) PUTDismissButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 859, p1) END PUTDismissButton; PROCEDURE (this: Button) HelpButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 860) END HelpButton; PROCEDURE (this: Button) PUTHelpButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 860, p1) END PUTHelpButton; PROCEDURE (this: Button) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: Button) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; (* ---------- Buttons, hidden ---------- *) PROCEDURE (this: Buttons) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Buttons) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Buttons) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Buttons) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Buttons) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Buttons) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Buttons) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Buttons) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Buttons) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Buttons) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Buttons) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Buttons) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Buttons) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Buttons) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Buttons) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Buttons) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Buttons) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Buttons) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Buttons) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Buttons) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Buttons) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Buttons) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Buttons) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Buttons) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Buttons) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Buttons) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Buttons) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Buttons) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Buttons) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Buttons) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Buttons) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Buttons) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Buttons) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Buttons) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Buttons) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Buttons) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Buttons) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Buttons) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Buttons) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Buttons) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Buttons) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Buttons) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Buttons) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Buttons) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Buttons) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Buttons) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Buttons) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Buttons) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Buttons) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Buttons) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Buttons) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Buttons) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Buttons) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Buttons) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Buttons) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Buttons) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Buttons) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Buttons) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Buttons) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: Buttons) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: Buttons) CancelButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 858) END CancelButton; PROCEDURE (this: Buttons) PUTCancelButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 858, p1) END PUTCancelButton; PROCEDURE (this: Buttons) DefaultButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 857) END DefaultButton; PROCEDURE (this: Buttons) PUTDefaultButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 857, p1) END PUTDefaultButton; PROCEDURE (this: Buttons) DismissButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 859) END DismissButton; PROCEDURE (this: Buttons) PUTDismissButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 859, p1) END PUTDismissButton; PROCEDURE (this: Buttons) HelpButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 860) END HelpButton; PROCEDURE (this: Buttons) PUTHelpButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 860, p1) END PUTHelpButton; PROCEDURE (this: Buttons) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: Buttons) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: Buttons) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Button, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisButton(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Buttons) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Buttons) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Buttons) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Buttons) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- CheckBox, hidden ---------- *) PROCEDURE (this: CheckBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CheckBox) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CheckBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CheckBox) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: CheckBox) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: CheckBox) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: CheckBox) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: CheckBox) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: CheckBox) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: CheckBox) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: CheckBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: CheckBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: CheckBox) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: CheckBox) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: CheckBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: CheckBox) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: CheckBox) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: CheckBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: CheckBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: CheckBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: CheckBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: CheckBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: CheckBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: CheckBox) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: CheckBox) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: CheckBox) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: CheckBox) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: CheckBox) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: CheckBox) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: CheckBox) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: CheckBox) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: CheckBox) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: CheckBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: CheckBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: CheckBox) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: CheckBox) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: CheckBox) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: CheckBox) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: CheckBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: CheckBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: CheckBox) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: CheckBox) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: CheckBox) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: CheckBox) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: CheckBox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: CheckBox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: CheckBox) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: CheckBox) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: CheckBox) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: CheckBox) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: CheckBox) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: CheckBox) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: CheckBox) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: CheckBox) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: CheckBox) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: CheckBox) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: CheckBox) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: CheckBox) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: CheckBox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: CheckBox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; (* ---------- CheckBoxes, hidden ---------- *) PROCEDURE (this: CheckBoxes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CheckBoxes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CheckBoxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CheckBoxes) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: CheckBoxes) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: CheckBoxes) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: CheckBoxes) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: CheckBoxes) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: CheckBoxes) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: CheckBoxes) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: CheckBoxes) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: CheckBoxes) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: CheckBoxes) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: CheckBoxes) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: CheckBoxes) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: CheckBoxes) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: CheckBoxes) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: CheckBoxes) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: CheckBoxes) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: CheckBoxes) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: CheckBoxes) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: CheckBoxes) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: CheckBoxes) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: CheckBoxes) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: CheckBoxes) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: CheckBoxes) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: CheckBoxes) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: CheckBoxes) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: CheckBoxes) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: CheckBoxes) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: CheckBoxes) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: CheckBoxes) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: CheckBoxes) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: CheckBoxes) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: CheckBoxes) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: CheckBoxes) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: CheckBoxes) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: CheckBoxes) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: CheckBoxes) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: CheckBoxes) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: CheckBoxes) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: CheckBoxes) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: CheckBoxes) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: CheckBoxes) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: CheckBoxes) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: CheckBoxes) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: CheckBoxes) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: CheckBoxes) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: CheckBoxes) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: CheckBoxes) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: CheckBoxes) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: CheckBoxes) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: CheckBoxes) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: CheckBoxes) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: CheckBoxes) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: CheckBoxes) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): CheckBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisCheckBox(CtlC.VarAny(ret)) END Add; PROCEDURE (this: CheckBoxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: CheckBoxes) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: CheckBoxes) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: CheckBoxes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- OptionButton, hidden ---------- *) PROCEDURE (this: OptionButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OptionButton) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OptionButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OptionButton) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: OptionButton) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: OptionButton) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: OptionButton) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: OptionButton) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: OptionButton) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: OptionButton) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: OptionButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: OptionButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: OptionButton) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: OptionButton) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: OptionButton) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: OptionButton) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: OptionButton) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: OptionButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: OptionButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: OptionButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: OptionButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: OptionButton) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: OptionButton) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: OptionButton) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: OptionButton) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: OptionButton) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: OptionButton) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: OptionButton) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: OptionButton) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: OptionButton) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: OptionButton) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: OptionButton) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: OptionButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: OptionButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: OptionButton) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: OptionButton) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: OptionButton) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: OptionButton) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: OptionButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: OptionButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: OptionButton) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: OptionButton) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: OptionButton) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: OptionButton) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: OptionButton) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: OptionButton) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: OptionButton) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: OptionButton) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: OptionButton) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: OptionButton) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: OptionButton) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: OptionButton) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: OptionButton) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: OptionButton) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: OptionButton) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: OptionButton) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: OptionButton) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: OptionButton) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: OptionButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: OptionButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: OptionButton) GroupBox* (): GroupBox, NEW; BEGIN RETURN ThisGroupBox(CtlC.GetAny(this, 833)) END GroupBox; (* ---------- OptionButtons, hidden ---------- *) PROCEDURE (this: OptionButtons) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OptionButtons) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OptionButtons) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OptionButtons) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: OptionButtons) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: OptionButtons) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: OptionButtons) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: OptionButtons) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: OptionButtons) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: OptionButtons) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: OptionButtons) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: OptionButtons) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: OptionButtons) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: OptionButtons) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: OptionButtons) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: OptionButtons) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: OptionButtons) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: OptionButtons) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: OptionButtons) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: OptionButtons) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: OptionButtons) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: OptionButtons) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: OptionButtons) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: OptionButtons) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: OptionButtons) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: OptionButtons) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: OptionButtons) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: OptionButtons) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: OptionButtons) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: OptionButtons) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: OptionButtons) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: OptionButtons) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: OptionButtons) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: OptionButtons) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: OptionButtons) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: OptionButtons) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: OptionButtons) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: OptionButtons) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: OptionButtons) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: OptionButtons) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: OptionButtons) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: OptionButtons) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: OptionButtons) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: OptionButtons) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: OptionButtons) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: OptionButtons) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: OptionButtons) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: OptionButtons) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: OptionButtons) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: OptionButtons) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: OptionButtons) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: OptionButtons) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: OptionButtons) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: OptionButtons) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: OptionButtons) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: OptionButtons) GroupBox* (): GroupBox, NEW; BEGIN RETURN ThisGroupBox(CtlC.GetAny(this, 833)) END GroupBox; PROCEDURE (this: OptionButtons) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): OptionButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisOptionButton(CtlC.VarAny(ret)) END Add; PROCEDURE (this: OptionButtons) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: OptionButtons) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: OptionButtons) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: OptionButtons) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- EditBox, hidden ---------- *) PROCEDURE (this: EditBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: EditBox) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: EditBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: EditBox) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: EditBox) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: EditBox) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: EditBox) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: EditBox) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: EditBox) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: EditBox) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: EditBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: EditBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: EditBox) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: EditBox) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: EditBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: EditBox) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: EditBox) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: EditBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: EditBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: EditBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: EditBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: EditBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: EditBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: EditBox) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: EditBox) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: EditBox) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: EditBox) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: EditBox) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: EditBox) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: EditBox) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: EditBox) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: EditBox) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: EditBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: EditBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: EditBox) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: EditBox) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: EditBox) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: EditBox) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: EditBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: EditBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: EditBox) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: EditBox) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: EditBox) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: EditBox) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: EditBox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: EditBox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: EditBox) DisplayVerticalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 922) END DisplayVerticalScrollBar; PROCEDURE (this: EditBox) PUTDisplayVerticalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 922, p1) END PUTDisplayVerticalScrollBar; PROCEDURE (this: EditBox) InputType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 854) END InputType; PROCEDURE (this: EditBox) PUTInputType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 854, p1) END PUTInputType; PROCEDURE (this: EditBox) LinkedObject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 862) END LinkedObject; PROCEDURE (this: EditBox) MultiLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 855) END MultiLine; PROCEDURE (this: EditBox) PUTMultiLine* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 855, p1) END PUTMultiLine; PROCEDURE (this: EditBox) PasswordEdit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1162) END PasswordEdit; PROCEDURE (this: EditBox) PUTPasswordEdit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1162, p1) END PUTPasswordEdit; (* ---------- EditBoxes, hidden ---------- *) PROCEDURE (this: EditBoxes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: EditBoxes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: EditBoxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: EditBoxes) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: EditBoxes) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: EditBoxes) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: EditBoxes) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: EditBoxes) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: EditBoxes) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: EditBoxes) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: EditBoxes) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: EditBoxes) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: EditBoxes) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: EditBoxes) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: EditBoxes) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: EditBoxes) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: EditBoxes) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: EditBoxes) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: EditBoxes) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: EditBoxes) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: EditBoxes) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: EditBoxes) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: EditBoxes) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: EditBoxes) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: EditBoxes) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: EditBoxes) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: EditBoxes) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: EditBoxes) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: EditBoxes) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: EditBoxes) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: EditBoxes) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: EditBoxes) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: EditBoxes) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: EditBoxes) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: EditBoxes) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: EditBoxes) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: EditBoxes) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: EditBoxes) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: EditBoxes) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: EditBoxes) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: EditBoxes) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: EditBoxes) DisplayVerticalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 922) END DisplayVerticalScrollBar; PROCEDURE (this: EditBoxes) PUTDisplayVerticalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 922, p1) END PUTDisplayVerticalScrollBar; PROCEDURE (this: EditBoxes) InputType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 854) END InputType; PROCEDURE (this: EditBoxes) PUTInputType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 854, p1) END PUTInputType; PROCEDURE (this: EditBoxes) MultiLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 855) END MultiLine; PROCEDURE (this: EditBoxes) PUTMultiLine* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 855, p1) END PUTMultiLine; PROCEDURE (this: EditBoxes) PasswordEdit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1162) END PasswordEdit; PROCEDURE (this: EditBoxes) PUTPasswordEdit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1162, p1) END PUTPasswordEdit; PROCEDURE (this: EditBoxes) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): EditBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisEditBox(CtlC.VarAny(ret)) END Add; PROCEDURE (this: EditBoxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: EditBoxes) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: EditBoxes) Item* (Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarAny(ret) END Item; PROCEDURE (this: EditBoxes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- ScrollBar, hidden ---------- *) PROCEDURE (this: ScrollBar) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ScrollBar) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ScrollBar) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ScrollBar) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: ScrollBar) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ScrollBar) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ScrollBar) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ScrollBar) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ScrollBar) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ScrollBar) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ScrollBar) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ScrollBar) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ScrollBar) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ScrollBar) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ScrollBar) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: ScrollBar) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ScrollBar) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ScrollBar) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ScrollBar) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ScrollBar) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ScrollBar) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: ScrollBar) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ScrollBar) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ScrollBar) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ScrollBar) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ScrollBar) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ScrollBar) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ScrollBar) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ScrollBar) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ScrollBar) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ScrollBar) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ScrollBar) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: ScrollBar) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ScrollBar) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ScrollBar) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ScrollBar) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ScrollBar) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: ScrollBar) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ScrollBar) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ScrollBar) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: ScrollBar) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: ScrollBar) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: ScrollBar) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: ScrollBar) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: ScrollBar) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: ScrollBar) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: ScrollBar) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: ScrollBar) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: ScrollBar) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: ScrollBar) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: ScrollBar) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: ScrollBar) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: ScrollBar) LargeChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 845) END LargeChange; PROCEDURE (this: ScrollBar) PUTLargeChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 845, p1) END PUTLargeChange; (* ---------- ScrollBars, hidden ---------- *) PROCEDURE (this: ScrollBars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ScrollBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ScrollBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ScrollBars) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ScrollBars) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ScrollBars) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ScrollBars) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ScrollBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ScrollBars) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ScrollBars) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ScrollBars) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ScrollBars) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ScrollBars) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ScrollBars) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ScrollBars) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ScrollBars) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ScrollBars) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ScrollBars) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ScrollBars) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ScrollBars) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ScrollBars) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ScrollBars) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ScrollBars) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ScrollBars) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ScrollBars) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ScrollBars) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ScrollBars) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ScrollBars) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ScrollBars) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ScrollBars) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ScrollBars) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ScrollBars) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: ScrollBars) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ScrollBars) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ScrollBars) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: ScrollBars) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: ScrollBars) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: ScrollBars) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: ScrollBars) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: ScrollBars) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: ScrollBars) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: ScrollBars) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: ScrollBars) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: ScrollBars) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: ScrollBars) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: ScrollBars) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: ScrollBars) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: ScrollBars) LargeChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 845) END LargeChange; PROCEDURE (this: ScrollBars) PUTLargeChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 845, p1) END PUTLargeChange; PROCEDURE (this: ScrollBars) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): ScrollBar, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisScrollBar(CtlC.VarAny(ret)) END Add; PROCEDURE (this: ScrollBars) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ScrollBars) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ScrollBars) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: ScrollBars) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- ListBox, hidden ---------- *) PROCEDURE (this: ListBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ListBox) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ListBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ListBox) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: ListBox) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ListBox) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ListBox) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ListBox) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ListBox) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ListBox) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ListBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ListBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ListBox) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ListBox) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ListBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: ListBox) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ListBox) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ListBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ListBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ListBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ListBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: ListBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ListBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ListBox) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ListBox) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ListBox) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ListBox) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ListBox) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ListBox) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ListBox) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ListBox) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ListBox) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: ListBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ListBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ListBox) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ListBox) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ListBox) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: ListBox) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ListBox) AddItem* (Text: CtlT.Any; (* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, ret); RETURN CtlC.VarAny(ret) END AddItem; PROCEDURE (this: ListBox) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: ListBox) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: ListBox) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ListBox) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: ListBox) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: ListBox) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: ListBox) LinkedObject* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 862) END LinkedObject; PROCEDURE (this: ListBox) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: ListBox) PUTList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 861, arg, NIL); END PUTList; PROCEDURE (this: ListBox) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 849) END ListCount; PROCEDURE (this: ListBox) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: ListBox) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: ListBox) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: ListBox) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: ListBox) MultiSelect* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32) END MultiSelect; PROCEDURE (this: ListBox) PUTMultiSelect* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 32, p1) END PUTMultiSelect; PROCEDURE (this: ListBox) RemoveAllItems* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 853, ret); RETURN CtlC.VarAny(ret) END RemoveAllItems; PROCEDURE (this: ListBox) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, ret); RETURN CtlC.VarAny(ret) END RemoveItem; PROCEDURE (this: ListBox) Selected* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1123, arg, ret); RETURN CtlC.VarAny(ret) END Selected; PROCEDURE (this: ListBox) PUTSelected* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1123, arg, NIL); END PUTSelected; PROCEDURE (this: ListBox) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: ListBox) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; (* ---------- ListBoxes, hidden ---------- *) PROCEDURE (this: ListBoxes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ListBoxes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ListBoxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ListBoxes) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ListBoxes) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ListBoxes) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ListBoxes) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ListBoxes) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ListBoxes) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ListBoxes) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ListBoxes) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ListBoxes) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ListBoxes) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ListBoxes) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ListBoxes) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ListBoxes) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ListBoxes) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ListBoxes) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ListBoxes) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ListBoxes) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ListBoxes) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ListBoxes) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ListBoxes) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ListBoxes) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ListBoxes) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ListBoxes) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ListBoxes) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ListBoxes) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ListBoxes) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ListBoxes) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ListBoxes) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ListBoxes) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: ListBoxes) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ListBoxes) AddItem* (Text: CtlT.Any; (* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, ret); RETURN CtlC.VarAny(ret) END AddItem; PROCEDURE (this: ListBoxes) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: ListBoxes) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: ListBoxes) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ListBoxes) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: ListBoxes) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: ListBoxes) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: ListBoxes) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: ListBoxes) PUTList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 861, arg, NIL); END PUTList; PROCEDURE (this: ListBoxes) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: ListBoxes) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: ListBoxes) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: ListBoxes) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: ListBoxes) MultiSelect* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32) END MultiSelect; PROCEDURE (this: ListBoxes) PUTMultiSelect* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 32, p1) END PUTMultiSelect; PROCEDURE (this: ListBoxes) RemoveAllItems* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 853, ret); RETURN CtlC.VarAny(ret) END RemoveAllItems; PROCEDURE (this: ListBoxes) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, ret); RETURN CtlC.VarAny(ret) END RemoveItem; PROCEDURE (this: ListBoxes) Selected* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1123, arg, ret); RETURN CtlC.VarAny(ret) END Selected; PROCEDURE (this: ListBoxes) PUTSelected* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1123, arg, NIL); END PUTSelected; PROCEDURE (this: ListBoxes) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: ListBoxes) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: ListBoxes) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): ListBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisListBox(CtlC.VarAny(ret)) END Add; PROCEDURE (this: ListBoxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ListBoxes) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ListBoxes) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: ListBoxes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- GroupBox, hidden ---------- *) PROCEDURE (this: GroupBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: GroupBox) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: GroupBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: GroupBox) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: GroupBox) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: GroupBox) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: GroupBox) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: GroupBox) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: GroupBox) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: GroupBox) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: GroupBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: GroupBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: GroupBox) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: GroupBox) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: GroupBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: GroupBox) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: GroupBox) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: GroupBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: GroupBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: GroupBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: GroupBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: GroupBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: GroupBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: GroupBox) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: GroupBox) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: GroupBox) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: GroupBox) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: GroupBox) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: GroupBox) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: GroupBox) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: GroupBox) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: GroupBox) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: GroupBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: GroupBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: GroupBox) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: GroupBox) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: GroupBox) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: GroupBox) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: GroupBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: GroupBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: GroupBox) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: GroupBox) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: GroupBox) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: GroupBox) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: GroupBox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: GroupBox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: GroupBox) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: GroupBox) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: GroupBox) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: GroupBox) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: GroupBox) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: GroupBox) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; (* ---------- GroupBoxes, hidden ---------- *) PROCEDURE (this: GroupBoxes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: GroupBoxes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: GroupBoxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: GroupBoxes) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: GroupBoxes) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: GroupBoxes) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: GroupBoxes) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: GroupBoxes) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: GroupBoxes) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: GroupBoxes) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: GroupBoxes) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: GroupBoxes) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: GroupBoxes) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: GroupBoxes) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: GroupBoxes) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: GroupBoxes) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: GroupBoxes) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: GroupBoxes) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: GroupBoxes) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: GroupBoxes) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: GroupBoxes) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: GroupBoxes) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: GroupBoxes) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: GroupBoxes) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: GroupBoxes) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: GroupBoxes) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: GroupBoxes) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: GroupBoxes) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: GroupBoxes) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: GroupBoxes) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: GroupBoxes) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: GroupBoxes) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: GroupBoxes) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: GroupBoxes) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: GroupBoxes) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: GroupBoxes) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: GroupBoxes) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: GroupBoxes) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: GroupBoxes) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: GroupBoxes) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: GroupBoxes) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: GroupBoxes) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: GroupBoxes) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: GroupBoxes) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: GroupBoxes) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: GroupBoxes) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: GroupBoxes) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: GroupBoxes) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): GroupBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisGroupBox(CtlC.VarAny(ret)) END Add; PROCEDURE (this: GroupBoxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: GroupBoxes) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: GroupBoxes) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: GroupBoxes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- DropDown, hidden ---------- *) PROCEDURE (this: DropDown) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DropDown) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DropDown) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DropDown) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: DropDown) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: DropDown) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: DropDown) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: DropDown) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: DropDown) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DropDown) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: DropDown) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: DropDown) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: DropDown) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: DropDown) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: DropDown) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: DropDown) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DropDown) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DropDown) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: DropDown) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: DropDown) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DropDown) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: DropDown) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: DropDown) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: DropDown) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: DropDown) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: DropDown) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: DropDown) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: DropDown) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DropDown) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: DropDown) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DropDown) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DropDown) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: DropDown) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: DropDown) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: DropDown) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: DropDown) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: DropDown) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: DropDown) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: DropDown) AddItem* (Text: CtlT.Any; (* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, ret); RETURN CtlC.VarAny(ret) END AddItem; PROCEDURE (this: DropDown) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: DropDown) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: DropDown) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: DropDown) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: DropDown) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: DropDown) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: DropDown) LinkedObject* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 862) END LinkedObject; PROCEDURE (this: DropDown) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: DropDown) PUTList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 861, arg, NIL); END PUTList; PROCEDURE (this: DropDown) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 849) END ListCount; PROCEDURE (this: DropDown) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: DropDown) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: DropDown) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: DropDown) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: DropDown) RemoveAllItems* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 853, ret); RETURN CtlC.VarAny(ret) END RemoveAllItems; PROCEDURE (this: DropDown) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, ret); RETURN CtlC.VarAny(ret) END RemoveItem; PROCEDURE (this: DropDown) Selected* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1123, arg, ret); RETURN CtlC.VarAny(ret) END Selected; PROCEDURE (this: DropDown) PUTSelected* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1123, arg, NIL); END PUTSelected; PROCEDURE (this: DropDown) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: DropDown) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: DropDown) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DropDown) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DropDown) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DropDown) DropDownLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 848) END DropDownLines; PROCEDURE (this: DropDown) PUTDropDownLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 848, p1) END PUTDropDownLines; PROCEDURE (this: DropDown) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DropDown) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; (* ---------- DropDowns, hidden ---------- *) PROCEDURE (this: DropDowns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DropDowns) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DropDowns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DropDowns) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: DropDowns) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: DropDowns) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: DropDowns) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: DropDowns) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DropDowns) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: DropDowns) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: DropDowns) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: DropDowns) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: DropDowns) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: DropDowns) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DropDowns) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DropDowns) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: DropDowns) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: DropDowns) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: DropDowns) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: DropDowns) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: DropDowns) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: DropDowns) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: DropDowns) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: DropDowns) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DropDowns) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: DropDowns) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DropDowns) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DropDowns) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: DropDowns) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: DropDowns) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: DropDowns) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: DropDowns) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: DropDowns) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: DropDowns) AddItem* (Text: CtlT.Any; (* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, ret); RETURN CtlC.VarAny(ret) END AddItem; PROCEDURE (this: DropDowns) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: DropDowns) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: DropDowns) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: DropDowns) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: DropDowns) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: DropDowns) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: DropDowns) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: DropDowns) PUTList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 861, arg, NIL); END PUTList; PROCEDURE (this: DropDowns) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: DropDowns) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: DropDowns) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: DropDowns) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: DropDowns) RemoveAllItems* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 853, ret); RETURN CtlC.VarAny(ret) END RemoveAllItems; PROCEDURE (this: DropDowns) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, ret); RETURN CtlC.VarAny(ret) END RemoveItem; PROCEDURE (this: DropDowns) Selected* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1123, arg, ret); RETURN CtlC.VarAny(ret) END Selected; PROCEDURE (this: DropDowns) PUTSelected* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1123, arg, NIL); END PUTSelected; PROCEDURE (this: DropDowns) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: DropDowns) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: DropDowns) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DropDowns) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DropDowns) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DropDowns) DropDownLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 848) END DropDownLines; PROCEDURE (this: DropDowns) PUTDropDownLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 848, p1) END PUTDropDownLines; PROCEDURE (this: DropDowns) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DropDowns) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DropDowns) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL; (* optional *) Editable: CtlT.Any): DropDown, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[4]); CtlC.RealVar(Top, arg[3]); CtlC.RealVar(Width, arg[2]); CtlC.RealVar(Height, arg[1]); CtlC.AnyVar(Editable, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisDropDown(CtlC.VarAny(ret)) END Add; PROCEDURE (this: DropDowns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: DropDowns) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: DropDowns) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: DropDowns) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Spinner, hidden ---------- *) PROCEDURE (this: Spinner) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Spinner) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Spinner) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Spinner) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Spinner) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Spinner) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Spinner) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Spinner) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Spinner) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Spinner) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Spinner) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Spinner) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Spinner) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Spinner) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Spinner) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Spinner) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Spinner) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Spinner) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Spinner) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Spinner) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Spinner) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Spinner) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Spinner) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Spinner) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Spinner) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Spinner) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Spinner) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Spinner) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Spinner) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Spinner) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Spinner) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Spinner) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Spinner) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Spinner) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Spinner) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Spinner) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Spinner) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Spinner) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Spinner) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: Spinner) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: Spinner) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: Spinner) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: Spinner) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: Spinner) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: Spinner) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: Spinner) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: Spinner) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: Spinner) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: Spinner) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: Spinner) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: Spinner) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: Spinner) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; (* ---------- Spinners, hidden ---------- *) PROCEDURE (this: Spinners) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Spinners) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Spinners) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Spinners) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Spinners) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Spinners) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Spinners) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Spinners) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Spinners) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Spinners) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Spinners) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Spinners) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Spinners) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Spinners) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Spinners) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Spinners) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Spinners) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Spinners) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Spinners) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Spinners) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Spinners) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Spinners) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Spinners) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Spinners) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Spinners) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Spinners) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Spinners) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Spinners) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Spinners) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Spinners) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Spinners) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Spinners) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Spinners) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Spinners) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: Spinners) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: Spinners) Display3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1122) END Display3DShading; PROCEDURE (this: Spinners) PUTDisplay3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1122, p1) END PUTDisplay3DShading; PROCEDURE (this: Spinners) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: Spinners) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: Spinners) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: Spinners) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: Spinners) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: Spinners) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: Spinners) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: Spinners) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: Spinners) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: Spinners) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; PROCEDURE (this: Spinners) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Spinner, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisSpinner(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Spinners) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Spinners) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Spinners) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Spinners) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- DialogFrame, hidden ---------- *) PROCEDURE (this: DialogFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DialogFrame) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DialogFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DialogFrame) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: DialogFrame) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: DialogFrame) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: DialogFrame) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DialogFrame) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DialogFrame) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: DialogFrame) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: DialogFrame) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DialogFrame) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: DialogFrame) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: DialogFrame) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: DialogFrame) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DialogFrame) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DialogFrame) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DialogFrame) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: DialogFrame) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: DialogFrame) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: DialogFrame) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DialogFrame) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DialogFrame) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DialogFrame) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: DialogFrame) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: DialogFrame) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: DialogFrame) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DialogFrame) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; (* ---------- Label, hidden ---------- *) PROCEDURE (this: Label) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Label) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Label) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Label) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Label) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Label) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Label) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Label) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Label) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Label) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Label) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Label) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Label) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Label) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Label) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Label) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Label) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Label) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Label) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Label) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Label) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Label) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Label) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Label) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Label) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Label) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Label) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Label) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Label) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Label) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Label) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Label) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Label) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Label) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Label) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Label) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Label) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Label) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Label) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Label) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Label) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Label) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Label) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Label) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Label) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Label) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Label) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: Label) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: Label) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: Label) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; (* ---------- Labels, hidden ---------- *) PROCEDURE (this: Labels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Labels) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Labels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Labels) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Labels) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Labels) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Labels) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Labels) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Labels) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Labels) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Labels) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Labels) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Labels) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Labels) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Labels) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Labels) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Labels) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Labels) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Labels) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Labels) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Labels) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Labels) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Labels) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Labels) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Labels) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Labels) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Labels) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Labels) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Labels) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Labels) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Labels) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Labels) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Labels) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Labels) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Labels) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Labels) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Labels) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Labels) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Labels) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Labels) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Labels) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Labels) Accelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 846) END Accelerator; PROCEDURE (this: Labels) PUTAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 846, p1) END PUTAccelerator; PROCEDURE (this: Labels) PhoneticAccelerator* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1121) END PhoneticAccelerator; PROCEDURE (this: Labels) PUTPhoneticAccelerator* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1121, p1) END PUTPhoneticAccelerator; PROCEDURE (this: Labels) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Label, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisLabel(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Labels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Labels) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Labels) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Labels) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Panes ---------- *) PROCEDURE (this: Panes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Panes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Panes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Panes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Panes) Item* (Index: INTEGER): Pane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisPane(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Panes) _Default* (Index: INTEGER): Pane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPane(CtlC.VarAny(ret)) END _Default; (* ---------- Pane ---------- *) PROCEDURE (this: Pane) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Pane) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Pane) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Pane) Activate* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 304, ret); RETURN CtlC.VarBool(ret) END Activate; PROCEDURE (this: Pane) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Pane) LargeScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 547, arg, ret); RETURN CtlC.VarAny(ret) END LargeScroll; PROCEDURE (this: Pane) ScrollColumn* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 654) END ScrollColumn; PROCEDURE (this: Pane) PUTScrollColumn* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 654, p1) END PUTScrollColumn; PROCEDURE (this: Pane) ScrollRow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 655) END ScrollRow; PROCEDURE (this: Pane) PUTScrollRow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 655, p1) END PUTScrollRow; PROCEDURE (this: Pane) SmallScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 548, arg, ret); RETURN CtlC.VarAny(ret) END SmallScroll; PROCEDURE (this: Pane) VisibleRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1118)) END VisibleRange; PROCEDURE (this: Pane) ScrollIntoView* (Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[4]); CtlC.IntVar(Top, arg[3]); CtlC.IntVar(Width, arg[2]); CtlC.IntVar(Height, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 1781, arg, NIL); END ScrollIntoView; (* ---------- Scenarios ---------- *) PROCEDURE (this: Scenarios) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Scenarios) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Scenarios) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Scenarios) Add* (Name: ARRAY OF CHAR; ChangingCells: CtlT.Any; (* optional *) Values: CtlT.Any; Comment: CtlT.Any; Locked: CtlT.Any; Hidden: CtlT.Any): Scenario, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[5]); CtlC.AnyVar(ChangingCells, arg[4]); CtlC.AnyVar(Values, arg[3]); CtlC.AnyVar(Comment, arg[2]); CtlC.AnyVar(Locked, arg[1]); CtlC.AnyVar(Hidden, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisScenario(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Scenarios) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Scenarios) CreateSummary* (ReportType: XlSummaryReportType; (* optional *) ResultCells: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ReportType, arg[1]); CtlC.AnyVar(ResultCells, arg[0]); CtlC.CallParMethod(this, 913, arg, ret); RETURN CtlC.VarAny(ret) END CreateSummary; PROCEDURE (this: Scenarios) Item* (Index: CtlT.Any): Scenario, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisScenario(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Scenarios) Merge* (Source: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[0]); CtlC.CallParMethod(this, 564, arg, ret); RETURN CtlC.VarAny(ret) END Merge; PROCEDURE (this: Scenarios) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Scenario ---------- *) PROCEDURE (this: Scenario) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Scenario) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Scenario) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Scenario) ChangeScenario* (ChangingCells: CtlT.Any; (* optional *) Values: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ChangingCells, arg[1]); CtlC.AnyVar(Values, arg[0]); CtlC.CallParMethod(this, 912, arg, ret); RETURN CtlC.VarAny(ret) END ChangeScenario; PROCEDURE (this: Scenario) ChangingCells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 911)) END ChangingCells; PROCEDURE (this: Scenario) Comment* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 910) END Comment; PROCEDURE (this: Scenario) PUTComment* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 910, p1) END PUTComment; PROCEDURE (this: Scenario) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Scenario) Hidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 268) END Hidden; PROCEDURE (this: Scenario) PUTHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 268, p1) END PUTHidden; PROCEDURE (this: Scenario) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Scenario) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Scenario) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Scenario) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Scenario) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Scenario) Show* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 496, ret); RETURN CtlC.VarAny(ret) END Show; PROCEDURE (this: Scenario) Values* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 164, arg, ret); RETURN CtlC.VarAny(ret) END Values; (* ---------- GroupObject, hidden ---------- *) PROCEDURE (this: GroupObject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: GroupObject) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: GroupObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: GroupObject) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: GroupObject) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: GroupObject) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: GroupObject) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: GroupObject) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: GroupObject) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: GroupObject) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: GroupObject) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: GroupObject) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: GroupObject) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: GroupObject) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: GroupObject) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: GroupObject) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: GroupObject) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: GroupObject) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: GroupObject) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: GroupObject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: GroupObject) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: GroupObject) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: GroupObject) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: GroupObject) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: GroupObject) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: GroupObject) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: GroupObject) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: GroupObject) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: GroupObject) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: GroupObject) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: GroupObject) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: GroupObject) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: GroupObject) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: GroupObject) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: GroupObject) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: GroupObject) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: GroupObject) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: GroupObject) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: GroupObject) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: GroupObject) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: GroupObject) ArrowHeadLength* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END ArrowHeadLength; PROCEDURE (this: GroupObject) PUTArrowHeadLength* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTArrowHeadLength; PROCEDURE (this: GroupObject) ArrowHeadStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END ArrowHeadStyle; PROCEDURE (this: GroupObject) PUTArrowHeadStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTArrowHeadStyle; PROCEDURE (this: GroupObject) ArrowHeadWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 613) END ArrowHeadWidth; PROCEDURE (this: GroupObject) PUTArrowHeadWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 613, p1) END PUTArrowHeadWidth; PROCEDURE (this: GroupObject) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: GroupObject) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: GroupObject) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: GroupObject) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: GroupObject) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: GroupObject) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: GroupObject) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: GroupObject) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: GroupObject) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: GroupObject) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: GroupObject) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: GroupObject) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: GroupObject) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: GroupObject) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: GroupObject) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: GroupObject) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: GroupObject) Ungroup* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN CtlC.VarObj(ret) END Ungroup; PROCEDURE (this: GroupObject) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: GroupObject) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: GroupObject) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: GroupObject) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; (* ---------- GroupObjects, hidden ---------- *) PROCEDURE (this: GroupObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: GroupObjects) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: GroupObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: GroupObjects) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: GroupObjects) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: GroupObjects) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: GroupObjects) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: GroupObjects) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: GroupObjects) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: GroupObjects) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: GroupObjects) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: GroupObjects) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: GroupObjects) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: GroupObjects) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: GroupObjects) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: GroupObjects) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: GroupObjects) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: GroupObjects) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: GroupObjects) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: GroupObjects) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: GroupObjects) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: GroupObjects) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: GroupObjects) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: GroupObjects) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: GroupObjects) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: GroupObjects) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: GroupObjects) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: GroupObjects) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: GroupObjects) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: GroupObjects) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: GroupObjects) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: GroupObjects) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: GroupObjects) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: GroupObjects) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: GroupObjects) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: GroupObjects) ArrowHeadLength* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END ArrowHeadLength; PROCEDURE (this: GroupObjects) PUTArrowHeadLength* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTArrowHeadLength; PROCEDURE (this: GroupObjects) ArrowHeadStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END ArrowHeadStyle; PROCEDURE (this: GroupObjects) PUTArrowHeadStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTArrowHeadStyle; PROCEDURE (this: GroupObjects) ArrowHeadWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 613) END ArrowHeadWidth; PROCEDURE (this: GroupObjects) PUTArrowHeadWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 613, p1) END PUTArrowHeadWidth; PROCEDURE (this: GroupObjects) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: GroupObjects) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: GroupObjects) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: GroupObjects) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: GroupObjects) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: GroupObjects) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: GroupObjects) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: GroupObjects) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: GroupObjects) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: GroupObjects) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: GroupObjects) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: GroupObjects) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: GroupObjects) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: GroupObjects) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: GroupObjects) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: GroupObjects) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: GroupObjects) Ungroup* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN CtlC.VarObj(ret) END Ungroup; PROCEDURE (this: GroupObjects) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: GroupObjects) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: GroupObjects) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: GroupObjects) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: GroupObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: GroupObjects) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: GroupObjects) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: GroupObjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Line, hidden ---------- *) PROCEDURE (this: Line) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Line) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Line) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Line) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Line) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Line) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Line) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Line) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Line) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Line) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Line) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Line) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Line) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Line) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Line) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Line) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Line) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Line) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Line) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Line) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Line) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Line) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Line) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Line) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Line) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Line) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Line) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Line) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Line) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Line) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Line) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Line) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Line) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Line) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Line) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Line) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Line) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Line) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Line) ArrowHeadLength* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END ArrowHeadLength; PROCEDURE (this: Line) PUTArrowHeadLength* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTArrowHeadLength; PROCEDURE (this: Line) ArrowHeadStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END ArrowHeadStyle; PROCEDURE (this: Line) PUTArrowHeadStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTArrowHeadStyle; PROCEDURE (this: Line) ArrowHeadWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 613) END ArrowHeadWidth; PROCEDURE (this: Line) PUTArrowHeadWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 613, p1) END PUTArrowHeadWidth; PROCEDURE (this: Line) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; (* ---------- Lines, hidden ---------- *) PROCEDURE (this: Lines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Lines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Lines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Lines) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Lines) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Lines) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Lines) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Lines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Lines) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Lines) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Lines) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Lines) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Lines) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Lines) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Lines) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Lines) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Lines) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Lines) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Lines) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Lines) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Lines) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Lines) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Lines) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Lines) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Lines) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Lines) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Lines) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Lines) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Lines) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Lines) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Lines) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Lines) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Lines) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Lines) ArrowHeadLength* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END ArrowHeadLength; PROCEDURE (this: Lines) PUTArrowHeadLength* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTArrowHeadLength; PROCEDURE (this: Lines) ArrowHeadStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END ArrowHeadStyle; PROCEDURE (this: Lines) PUTArrowHeadStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTArrowHeadStyle; PROCEDURE (this: Lines) ArrowHeadWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 613) END ArrowHeadWidth; PROCEDURE (this: Lines) PUTArrowHeadWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 613, p1) END PUTArrowHeadWidth; PROCEDURE (this: Lines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Lines) Add* (X1: REAL; Y1: REAL; X2: REAL; Y2: REAL): Line, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(X1, arg[3]); CtlC.RealVar(Y1, arg[2]); CtlC.RealVar(X2, arg[1]); CtlC.RealVar(Y2, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisLine(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Lines) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Lines) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Lines) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Lines) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Rectangle, hidden ---------- *) PROCEDURE (this: Rectangle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Rectangle) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Rectangle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Rectangle) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Rectangle) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Rectangle) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Rectangle) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Rectangle) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Rectangle) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Rectangle) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Rectangle) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Rectangle) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Rectangle) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Rectangle) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Rectangle) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Rectangle) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Rectangle) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Rectangle) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Rectangle) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Rectangle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Rectangle) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Rectangle) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Rectangle) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Rectangle) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Rectangle) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Rectangle) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Rectangle) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Rectangle) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Rectangle) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Rectangle) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Rectangle) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Rectangle) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Rectangle) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Rectangle) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Rectangle) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Rectangle) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Rectangle) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Rectangle) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Rectangle) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Rectangle) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Rectangle) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Rectangle) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Rectangle) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Rectangle) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Rectangle) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Rectangle) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Rectangle) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Rectangle) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Rectangle) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Rectangle) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Rectangle) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Rectangle) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Rectangle) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Rectangle) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Rectangle) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Rectangle) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Rectangle) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Rectangle) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Rectangle) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Rectangle) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Rectangle) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Rectangle) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Rectangle) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Rectangle) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Rectangle) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Rectangle) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Rectangle) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Rectangle) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: Rectangle) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; (* ---------- Rectangles, hidden ---------- *) PROCEDURE (this: Rectangles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Rectangles) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Rectangles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Rectangles) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Rectangles) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Rectangles) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Rectangles) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Rectangles) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Rectangles) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Rectangles) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Rectangles) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Rectangles) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Rectangles) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Rectangles) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Rectangles) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Rectangles) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Rectangles) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Rectangles) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Rectangles) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Rectangles) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Rectangles) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Rectangles) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Rectangles) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Rectangles) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Rectangles) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Rectangles) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Rectangles) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Rectangles) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Rectangles) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Rectangles) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Rectangles) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Rectangles) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Rectangles) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Rectangles) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Rectangles) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Rectangles) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Rectangles) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Rectangles) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Rectangles) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Rectangles) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Rectangles) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Rectangles) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Rectangles) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Rectangles) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Rectangles) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Rectangles) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Rectangles) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Rectangles) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Rectangles) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Rectangles) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Rectangles) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Rectangles) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Rectangles) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Rectangles) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Rectangles) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Rectangles) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Rectangles) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Rectangles) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Rectangles) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Rectangles) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Rectangles) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Rectangles) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Rectangles) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: Rectangles) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: Rectangles) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Rectangle, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisRectangle(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Rectangles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Rectangles) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Rectangles) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Rectangles) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Oval, hidden ---------- *) PROCEDURE (this: Oval) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Oval) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Oval) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Oval) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Oval) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Oval) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Oval) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Oval) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Oval) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Oval) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Oval) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Oval) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Oval) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Oval) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Oval) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Oval) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Oval) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Oval) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Oval) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Oval) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Oval) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Oval) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Oval) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Oval) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Oval) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Oval) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Oval) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Oval) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Oval) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Oval) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Oval) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Oval) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Oval) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Oval) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Oval) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Oval) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Oval) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Oval) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Oval) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Oval) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Oval) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Oval) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Oval) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Oval) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Oval) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Oval) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Oval) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Oval) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Oval) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Oval) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Oval) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Oval) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Oval) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Oval) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Oval) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Oval) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Oval) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Oval) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Oval) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Oval) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Oval) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Oval) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Oval) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Oval) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Oval) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Oval) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Oval) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; (* ---------- Ovals, hidden ---------- *) PROCEDURE (this: Ovals) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Ovals) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Ovals) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Ovals) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Ovals) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Ovals) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Ovals) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Ovals) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Ovals) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Ovals) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Ovals) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Ovals) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Ovals) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Ovals) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Ovals) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Ovals) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Ovals) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Ovals) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Ovals) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Ovals) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Ovals) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Ovals) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Ovals) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Ovals) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Ovals) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Ovals) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Ovals) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Ovals) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Ovals) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Ovals) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Ovals) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Ovals) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Ovals) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Ovals) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Ovals) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Ovals) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Ovals) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Ovals) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Ovals) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Ovals) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Ovals) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Ovals) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Ovals) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Ovals) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Ovals) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Ovals) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Ovals) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Ovals) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Ovals) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Ovals) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Ovals) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Ovals) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Ovals) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Ovals) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Ovals) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Ovals) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Ovals) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Ovals) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Ovals) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Ovals) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Ovals) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Ovals) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Ovals) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Oval, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisOval(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Ovals) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Ovals) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Ovals) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Ovals) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Arc, hidden ---------- *) PROCEDURE (this: Arc) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Arc) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Arc) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Arc) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Arc) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Arc) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Arc) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Arc) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Arc) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Arc) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Arc) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Arc) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Arc) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Arc) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Arc) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Arc) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Arc) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Arc) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Arc) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Arc) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Arc) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Arc) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Arc) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Arc) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Arc) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Arc) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Arc) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Arc) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Arc) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Arc) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Arc) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Arc) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Arc) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Arc) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Arc) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Arc) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Arc) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Arc) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Arc) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Arc) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Arc) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Arc) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Arc) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Arc) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Arc) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Arc) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Arc) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Arc) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Arc) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Arc) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Arc) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Arc) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Arc) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Arc) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Arc) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Arc) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Arc) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Arc) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Arc) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Arc) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Arc) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Arc) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Arc) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Arc) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Arc) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; (* ---------- Arcs, hidden ---------- *) PROCEDURE (this: Arcs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Arcs) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Arcs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Arcs) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Arcs) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Arcs) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Arcs) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Arcs) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Arcs) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Arcs) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Arcs) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Arcs) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Arcs) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Arcs) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Arcs) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Arcs) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Arcs) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Arcs) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Arcs) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Arcs) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Arcs) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Arcs) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Arcs) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Arcs) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Arcs) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Arcs) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Arcs) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Arcs) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Arcs) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Arcs) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Arcs) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Arcs) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Arcs) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Arcs) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Arcs) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Arcs) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Arcs) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Arcs) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Arcs) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Arcs) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Arcs) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Arcs) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Arcs) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Arcs) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Arcs) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Arcs) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Arcs) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Arcs) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Arcs) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Arcs) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Arcs) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Arcs) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Arcs) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Arcs) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Arcs) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Arcs) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Arcs) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Arcs) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Arcs) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Arcs) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Arcs) Add* (X1: REAL; Y1: REAL; X2: REAL; Y2: REAL): Arc, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(X1, arg[3]); CtlC.RealVar(Y1, arg[2]); CtlC.RealVar(X2, arg[1]); CtlC.RealVar(Y2, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisArc(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Arcs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Arcs) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Arcs) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Arcs) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- OLEObjectEvents, hidden ---------- *) PROCEDURE (this: OLEObjectEvents) GotFocus* (), NEW, ABSTRACT; PROCEDURE (this: OLEObjectEvents) LostFocus* (), NEW, ABSTRACT; PROCEDURE (this: OLEObjectEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1541: ASSERT(n = 0, 11); this.GotFocus() | 1542: ASSERT(n = 0, 11); this.LostFocus() END END Invoke; PROCEDURE (this: OLEObjectEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00024410-0000-0000-C000-000000000046}" END GetIID; (* ---------- _OLEObject ---------- *) PROCEDURE (this: _OLEObject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, -2147417964)) END Application; PROCEDURE (this: _OLEObject) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, -2147417963) END Creator; PROCEDURE (this: _OLEObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147417962) END Parent; PROCEDURE (this: _OLEObject) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, -2147417497)) END BottomRightCell; PROCEDURE (this: _OLEObject) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417510, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: _OLEObject) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417561, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: _OLEObject) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, -2147417899, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: _OLEObject) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417547, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: _OLEObject) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417995, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: _OLEObject) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417073, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: _OLEObject) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147417512) END Enabled; PROCEDURE (this: _OLEObject) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147417512, p1) END PUTEnabled; PROCEDURE (this: _OLEObject) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, -2147417989) END Height; PROCEDURE (this: _OLEObject) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, -2147417989, p1) END PUTHeight; PROCEDURE (this: _OLEObject) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147417626) END Index; PROCEDURE (this: _OLEObject) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, -2147417985) END Left; PROCEDURE (this: _OLEObject) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, -2147417985, p1) END PUTLeft; PROCEDURE (this: _OLEObject) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147417843) END Locked; PROCEDURE (this: _OLEObject) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147417843, p1) END PUTLocked; PROCEDURE (this: _OLEObject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418002) END Name; PROCEDURE (this: _OLEObject) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418002, p1) END PUTName; PROCEDURE (this: _OLEObject) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147417516) END OnAction; PROCEDURE (this: _OLEObject) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147417516, p1) END PUTOnAction; PROCEDURE (this: _OLEObject) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -2147417495) END Placement; PROCEDURE (this: _OLEObject) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, -2147417495, p1) END PUTPlacement; PROCEDURE (this: _OLEObject) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147417494) END PrintObject; PROCEDURE (this: _OLEObject) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147417494, p1) END PUTPrintObject; PROCEDURE (this: _OLEObject) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, -2147417877, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: _OLEObject) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417507, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: _OLEObject) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, -2147417986) END Top; PROCEDURE (this: _OLEObject) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, -2147417986, p1) END PUTTop; PROCEDURE (this: _OLEObject) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, -2147417492)) END TopLeftCell; PROCEDURE (this: _OLEObject) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147417554) END Visible; PROCEDURE (this: _OLEObject) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147417554, p1) END PUTVisible; PROCEDURE (this: _OLEObject) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, -2147417990) END Width; PROCEDURE (this: _OLEObject) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, -2147417990, p1) END PUTWidth; PROCEDURE (this: _OLEObject) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147417490) END ZOrder; PROCEDURE (this: _OLEObject) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, -2147416584)) END ShapeRange; PROCEDURE (this: _OLEObject) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, -2147417984)) END Border; PROCEDURE (this: _OLEObject) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, -2147417983)) END Interior; PROCEDURE (this: _OLEObject) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418009) END Shadow; PROCEDURE (this: _OLEObject) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418009, p1) END PUTShadow; PROCEDURE (this: _OLEObject) Activate* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417808, ret); RETURN CtlC.VarAny(ret) END Activate; PROCEDURE (this: _OLEObject) AutoLoad* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147416926) END AutoLoad; PROCEDURE (this: _OLEObject) PUTAutoLoad* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147416926, p1) END PUTAutoLoad; PROCEDURE (this: _OLEObject) AutoUpdate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147417064) END AutoUpdate; PROCEDURE (this: _OLEObject) PUTAutoUpdate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147417064, p1) END PUTAutoUpdate; PROCEDURE (this: _OLEObject) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147417063) END Object; PROCEDURE (this: _OLEObject) OLEType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -2147417058) END OLEType; PROCEDURE (this: _OLEObject) SourceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147417391) END SourceName; PROCEDURE (this: _OLEObject) PUTSourceName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147417391, p1) END PUTSourceName; PROCEDURE (this: _OLEObject) Update* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -2147417432, ret); RETURN CtlC.VarAny(ret) END Update; PROCEDURE (this: _OLEObject) Verb* (Verb: XlOLEVerb): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Verb, arg[0]); CtlC.CallParMethod(this, -2147417506, arg, ret); RETURN CtlC.VarAny(ret) END Verb; PROCEDURE (this: _OLEObject) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147417054) END LinkedCell; PROCEDURE (this: _OLEObject) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147417054, p1) END PUTLinkedCell; PROCEDURE (this: _OLEObject) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147417265) END ListFillRange; PROCEDURE (this: _OLEObject) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147417265, p1) END PUTListFillRange; PROCEDURE (this: _OLEObject) ProgId* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147416589) END ProgId; PROCEDURE (this: _OLEObject) AltHTML* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147416259) END AltHTML; PROCEDURE (this: _OLEObject) PUTAltHTML* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147416259, p1) END PUTAltHTML; (* ---------- OLEObjects ---------- *) PROCEDURE (this: OLEObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OLEObjects) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OLEObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OLEObjects) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: OLEObjects) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: OLEObjects) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: OLEObjects) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: OLEObjects) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: OLEObjects) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: OLEObjects) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: OLEObjects) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: OLEObjects) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: OLEObjects) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: OLEObjects) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: OLEObjects) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: OLEObjects) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: OLEObjects) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: OLEObjects) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: OLEObjects) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: OLEObjects) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: OLEObjects) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: OLEObjects) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: OLEObjects) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: OLEObjects) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: OLEObjects) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: OLEObjects) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: OLEObjects) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: OLEObjects) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: OLEObjects) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: OLEObjects) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: OLEObjects) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: OLEObjects) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: OLEObjects) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: OLEObjects) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: OLEObjects) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: OLEObjects) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: OLEObjects) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: OLEObjects) AutoLoad* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1186) END AutoLoad; PROCEDURE (this: OLEObjects) PUTAutoLoad* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1186, p1) END PUTAutoLoad; PROCEDURE (this: OLEObjects) SourceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 721) END SourceName; PROCEDURE (this: OLEObjects) PUTSourceName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 721, p1) END PUTSourceName; PROCEDURE (this: OLEObjects) Add* ((* optional *) ClassType: CtlT.Any; Filename: CtlT.Any; Link: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any): OLEObject, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[10]); CtlC.AnyVar(Filename, arg[9]); CtlC.AnyVar(Link, arg[8]); CtlC.AnyVar(DisplayAsIcon, arg[7]); CtlC.AnyVar(IconFileName, arg[6]); CtlC.AnyVar(IconIndex, arg[5]); CtlC.AnyVar(IconLabel, arg[4]); CtlC.AnyVar(Left, arg[3]); CtlC.AnyVar(Top, arg[2]); CtlC.AnyVar(Width, arg[1]); CtlC.AnyVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN This_OLEObject(CtlC.VarAny(ret)) END Add; PROCEDURE (this: OLEObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: OLEObjects) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: OLEObjects) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: OLEObjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- TextBox, hidden ---------- *) PROCEDURE (this: TextBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TextBox) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TextBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TextBox) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: TextBox) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: TextBox) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: TextBox) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: TextBox) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: TextBox) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: TextBox) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: TextBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: TextBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: TextBox) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: TextBox) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: TextBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: TextBox) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: TextBox) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: TextBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: TextBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: TextBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: TextBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: TextBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: TextBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: TextBox) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: TextBox) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: TextBox) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: TextBox) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: TextBox) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: TextBox) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: TextBox) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: TextBox) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: TextBox) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: TextBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: TextBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: TextBox) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: TextBox) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: TextBox) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: TextBox) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: TextBox) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: TextBox) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: TextBox) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: TextBox) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: TextBox) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: TextBox) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: TextBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: TextBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: TextBox) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: TextBox) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: TextBox) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: TextBox) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: TextBox) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: TextBox) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: TextBox) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: TextBox) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: TextBox) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: TextBox) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: TextBox) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: TextBox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: TextBox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: TextBox) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: TextBox) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: TextBox) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: TextBox) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: TextBox) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: TextBox) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: TextBox) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: TextBox) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: TextBox) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: TextBox) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; (* ---------- TextBoxes, hidden ---------- *) PROCEDURE (this: TextBoxes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TextBoxes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TextBoxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TextBoxes) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: TextBoxes) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: TextBoxes) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: TextBoxes) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: TextBoxes) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: TextBoxes) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: TextBoxes) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: TextBoxes) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: TextBoxes) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: TextBoxes) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: TextBoxes) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: TextBoxes) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: TextBoxes) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: TextBoxes) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: TextBoxes) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: TextBoxes) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: TextBoxes) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: TextBoxes) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: TextBoxes) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: TextBoxes) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: TextBoxes) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: TextBoxes) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: TextBoxes) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: TextBoxes) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: TextBoxes) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: TextBoxes) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: TextBoxes) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: TextBoxes) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: TextBoxes) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: TextBoxes) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: TextBoxes) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: TextBoxes) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: TextBoxes) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: TextBoxes) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: TextBoxes) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: TextBoxes) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: TextBoxes) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: TextBoxes) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: TextBoxes) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: TextBoxes) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: TextBoxes) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: TextBoxes) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: TextBoxes) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: TextBoxes) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: TextBoxes) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: TextBoxes) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: TextBoxes) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: TextBoxes) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: TextBoxes) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: TextBoxes) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: TextBoxes) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: TextBoxes) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: TextBoxes) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: TextBoxes) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: TextBoxes) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: TextBoxes) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: TextBoxes) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: TextBoxes) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: TextBoxes) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: TextBoxes) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: TextBoxes) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: TextBoxes) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): TextBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisTextBox(CtlC.VarAny(ret)) END Add; PROCEDURE (this: TextBoxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: TextBoxes) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: TextBoxes) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: TextBoxes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Picture, hidden ---------- *) PROCEDURE (this: Picture) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Picture) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Picture) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Picture) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Picture) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Picture) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Picture) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Picture) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Picture) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Picture) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Picture) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Picture) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Picture) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Picture) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Picture) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Picture) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Picture) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Picture) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Picture) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Picture) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Picture) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Picture) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Picture) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Picture) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Picture) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Picture) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Picture) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Picture) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Picture) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Picture) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Picture) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Picture) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Picture) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Picture) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Picture) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Picture) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Picture) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Picture) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Picture) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Picture) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Picture) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Picture) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Picture) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Picture) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; (* ---------- Pictures, hidden ---------- *) PROCEDURE (this: Pictures) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Pictures) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Pictures) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Pictures) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Pictures) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Pictures) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Pictures) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Pictures) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Pictures) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Pictures) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Pictures) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Pictures) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Pictures) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Pictures) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Pictures) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Pictures) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Pictures) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Pictures) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Pictures) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Pictures) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Pictures) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Pictures) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Pictures) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Pictures) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Pictures) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Pictures) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Pictures) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Pictures) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Pictures) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Pictures) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Pictures) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Pictures) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Pictures) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Pictures) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Pictures) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Pictures) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Pictures) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Pictures) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Pictures) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Pictures) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): Picture, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPicture(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Pictures) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Pictures) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Pictures) Insert* (Filename: ARRAY OF CHAR; (* optional *) Converter: CtlT.Any): Picture, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[1]); CtlC.AnyVar(Converter, arg[0]); CtlC.CallParMethod(this, 252, arg, ret); RETURN ThisPicture(CtlC.VarAny(ret)) END Insert; PROCEDURE (this: Pictures) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Pictures) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: Pictures) Paste* ((* optional *) Link: CtlT.Any): Picture, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Link, arg[0]); CtlC.CallParMethod(this, 211, arg, ret); RETURN ThisPicture(CtlC.VarAny(ret)) END Paste; (* ---------- Drawing, hidden ---------- *) PROCEDURE (this: Drawing) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Drawing) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Drawing) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Drawing) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Drawing) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Drawing) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Drawing) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Drawing) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Drawing) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Drawing) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Drawing) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Drawing) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Drawing) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Drawing) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Drawing) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Drawing) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Drawing) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Drawing) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Drawing) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Drawing) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Drawing) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Drawing) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Drawing) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Drawing) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Drawing) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Drawing) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Drawing) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Drawing) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Drawing) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Drawing) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Drawing) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Drawing) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Drawing) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Drawing) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Drawing) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Drawing) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Drawing) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Drawing) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Drawing) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Drawing) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Drawing) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Drawing) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Drawing) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Drawing) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Drawing) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Drawing) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Drawing) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Drawing) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Drawing) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Drawing) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Drawing) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Drawing) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Drawing) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Drawing) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Drawing) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Drawing) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Drawing) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Drawing) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Drawing) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Drawing) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Drawing) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Drawing) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Drawing) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Drawing) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Drawing) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Drawing) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Drawing) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Drawing) AddVertex* (Left: REAL; Top: REAL): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[1]); CtlC.RealVar(Top, arg[0]); CtlC.CallParMethod(this, 601, arg, ret); RETURN CtlC.VarAny(ret) END AddVertex; PROCEDURE (this: Drawing) Reshape* (Vertex: INTEGER; Insert: BOOLEAN; (* optional *) Left: CtlT.Any; Top: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Vertex, arg[3]); CtlC.BoolVar(Insert, arg[2]); CtlC.AnyVar(Left, arg[1]); CtlC.AnyVar(Top, arg[0]); CtlC.CallParMethod(this, 604, arg, ret); RETURN CtlC.VarAny(ret) END Reshape; PROCEDURE (this: Drawing) Vertices* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallGetMethod(this, 621, arg, ret); RETURN CtlC.VarAny(ret) END Vertices; (* ---------- Drawings, hidden ---------- *) PROCEDURE (this: Drawings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Drawings) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Drawings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Drawings) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: Drawings) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Drawings) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: Drawings) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: Drawings) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Drawings) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: Drawings) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: Drawings) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: Drawings) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Drawings) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Drawings) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Drawings) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Drawings) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Drawings) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Drawings) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Drawings) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Drawings) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: Drawings) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: Drawings) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: Drawings) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: Drawings) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Drawings) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: Drawings) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Drawings) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Drawings) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Drawings) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Drawings) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Drawings) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Drawings) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: Drawings) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: Drawings) AddIndent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1063) END AddIndent; PROCEDURE (this: Drawings) PUTAddIndent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1063, p1) END PUTAddIndent; PROCEDURE (this: Drawings) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Drawings) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: Drawings) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: Drawings) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: Drawings) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: Drawings) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: Drawings) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: Drawings) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarAny(ret) END CheckSpelling; PROCEDURE (this: Drawings) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Drawings) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Drawings) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Drawings) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: Drawings) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: Drawings) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: Drawings) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: Drawings) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: Drawings) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: Drawings) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Drawings) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Drawings) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: Drawings) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: Drawings) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: Drawings) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: Drawings) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Drawings) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Drawings) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Drawings) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Drawings) Reshape* (Vertex: INTEGER; Insert: BOOLEAN; (* optional *) Left: CtlT.Any; Top: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Vertex, arg[3]); CtlC.BoolVar(Insert, arg[2]); CtlC.AnyVar(Left, arg[1]); CtlC.AnyVar(Top, arg[0]); CtlC.CallParMethod(this, 604, arg, ret); RETURN CtlC.VarAny(ret) END Reshape; PROCEDURE (this: Drawings) Add* (X1: REAL; Y1: REAL; X2: REAL; Y2: REAL; Closed: BOOLEAN): Drawing, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(X1, arg[4]); CtlC.RealVar(Y1, arg[3]); CtlC.RealVar(X2, arg[2]); CtlC.RealVar(Y2, arg[1]); CtlC.BoolVar(Closed, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisDrawing(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Drawings) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Drawings) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: Drawings) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Drawings) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- RoutingSlip ---------- *) PROCEDURE (this: RoutingSlip) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: RoutingSlip) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: RoutingSlip) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: RoutingSlip) Delivery* (): XlRoutingSlipDelivery, NEW; BEGIN RETURN CtlC.GetInt(this, 955) END Delivery; PROCEDURE (this: RoutingSlip) PUTDelivery* (p1: XlRoutingSlipDelivery), NEW; BEGIN CtlC.PutInt(this, 955, p1) END PUTDelivery; PROCEDURE (this: RoutingSlip) Message* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 954) END Message; PROCEDURE (this: RoutingSlip) PUTMessage* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 954, p1) END PUTMessage; PROCEDURE (this: RoutingSlip) Recipients* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 952, arg, ret); RETURN CtlC.VarAny(ret) END Recipients; PROCEDURE (this: RoutingSlip) PUTRecipients* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 952, arg, NIL); END PUTRecipients; PROCEDURE (this: RoutingSlip) Reset* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 555, ret); RETURN CtlC.VarAny(ret) END Reset; PROCEDURE (this: RoutingSlip) ReturnWhenDone* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 956) END ReturnWhenDone; PROCEDURE (this: RoutingSlip) PUTReturnWhenDone* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 956, p1) END PUTReturnWhenDone; PROCEDURE (this: RoutingSlip) Status* (): XlRoutingSlipStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 958) END Status; PROCEDURE (this: RoutingSlip) Subject* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 953) END Subject; PROCEDURE (this: RoutingSlip) PUTSubject* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 953, p1) END PUTSubject; PROCEDURE (this: RoutingSlip) TrackStatus* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 957) END TrackStatus; PROCEDURE (this: RoutingSlip) PUTTrackStatus* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 957, p1) END PUTTrackStatus; (* ---------- Outline ---------- *) PROCEDURE (this: Outline) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Outline) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Outline) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Outline) AutomaticStyles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 959) END AutomaticStyles; PROCEDURE (this: Outline) PUTAutomaticStyles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 959, p1) END PUTAutomaticStyles; PROCEDURE (this: Outline) ShowLevels* ((* optional *) RowLevels: CtlT.Any; ColumnLevels: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowLevels, arg[1]); CtlC.AnyVar(ColumnLevels, arg[0]); CtlC.CallParMethod(this, 960, arg, ret); RETURN CtlC.VarAny(ret) END ShowLevels; PROCEDURE (this: Outline) SummaryColumn* (): XlSummaryColumn, NEW; BEGIN RETURN CtlC.GetInt(this, 961) END SummaryColumn; PROCEDURE (this: Outline) PUTSummaryColumn* (p1: XlSummaryColumn), NEW; BEGIN CtlC.PutInt(this, 961, p1) END PUTSummaryColumn; PROCEDURE (this: Outline) SummaryRow* (): XlSummaryRow, NEW; BEGIN RETURN CtlC.GetInt(this, 902) END SummaryRow; PROCEDURE (this: Outline) PUTSummaryRow* (p1: XlSummaryRow), NEW; BEGIN CtlC.PutInt(this, 902, p1) END PUTSummaryRow; (* ---------- Module, hidden ---------- *) PROCEDURE (this: Module) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Module) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Module) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Module) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: Module) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Module) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Module) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1373) END CodeName; PROCEDURE (this: Module) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: Module) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: Module) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Module) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: Module) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Module) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Module) Next* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 502) END Next; PROCEDURE (this: Module) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 628) END OnDoubleClick; PROCEDURE (this: Module) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 628, p1) END PUTOnDoubleClick; PROCEDURE (this: Module) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: Module) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: Module) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: Module) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: Module) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 998)) END PageSetup; PROCEDURE (this: Module) Previous* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 503) END Previous; PROCEDURE (this: Module) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: Module) Protect* ((* optional *) Password: CtlT.Any; DrawingObjects: CtlT.Any; Contents: CtlT.Any; Scenarios: CtlT.Any; UserInterfaceOnly: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[4]); CtlC.AnyVar(DrawingObjects, arg[3]); CtlC.AnyVar(Contents, arg[2]); CtlC.AnyVar(Scenarios, arg[1]); CtlC.AnyVar(UserInterfaceOnly, arg[0]); CtlC.CallParMethod(this, 282, arg, NIL); END Protect; PROCEDURE (this: Module) ProtectContents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 292) END ProtectContents; PROCEDURE (this: Module) ProtectionMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1159) END ProtectionMode; PROCEDURE (this: Module) SaveAs* (Filename: ARRAY OF CHAR; (* optional *) FileFormat: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; AddToMru: CtlT.Any; TextCodepage: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[8]); CtlC.AnyVar(FileFormat, arg[7]); CtlC.AnyVar(Password, arg[6]); CtlC.AnyVar(WriteResPassword, arg[5]); CtlC.AnyVar(ReadOnlyRecommended, arg[4]); CtlC.AnyVar(CreateBackup, arg[3]); CtlC.AnyVar(AddToMru, arg[2]); CtlC.AnyVar(TextCodepage, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: Module) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Module) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 285, arg, NIL); END Unprotect; PROCEDURE (this: Module) Visible* (): XlSheetVisibility, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: Module) PUTVisible* (p1: XlSheetVisibility), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: Module) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 1377)) END Shapes; PROCEDURE (this: Module) InsertFile* (Filename: CtlT.Any; (* optional *) Merge: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Filename, arg[1]); CtlC.AnyVar(Merge, arg[0]); CtlC.CallParMethod(this, 584, arg, ret); RETURN CtlC.VarAny(ret) END InsertFile; (* ---------- Modules, hidden ---------- *) PROCEDURE (this: Modules) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Modules) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Modules) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Modules) Add* ((* optional *) Before: CtlT.Any; After: CtlT.Any; Count: CtlT.Any): Module, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[2]); CtlC.AnyVar(After, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisModule(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Modules) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Modules) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Modules) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Modules) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Modules) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: Modules) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Modules) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: Modules) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Modules) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: Modules) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: Modules) Visible* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 558) END Visible; PROCEDURE (this: Modules) PUTVisible* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 558, p1) END PUTVisible; PROCEDURE (this: Modules) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: Modules) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- DialogSheet, hidden ---------- *) PROCEDURE (this: DialogSheet) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DialogSheet) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DialogSheet) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DialogSheet) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: DialogSheet) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: DialogSheet) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: DialogSheet) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1373) END CodeName; PROCEDURE (this: DialogSheet) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: DialogSheet) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: DialogSheet) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: DialogSheet) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: DialogSheet) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DialogSheet) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: DialogSheet) Next* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 502) END Next; PROCEDURE (this: DialogSheet) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 628) END OnDoubleClick; PROCEDURE (this: DialogSheet) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 628, p1) END PUTOnDoubleClick; PROCEDURE (this: DialogSheet) OnSheetActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1031) END OnSheetActivate; PROCEDURE (this: DialogSheet) PUTOnSheetActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1031, p1) END PUTOnSheetActivate; PROCEDURE (this: DialogSheet) OnSheetDeactivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1081) END OnSheetDeactivate; PROCEDURE (this: DialogSheet) PUTOnSheetDeactivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1081, p1) END PUTOnSheetDeactivate; PROCEDURE (this: DialogSheet) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 998)) END PageSetup; PROCEDURE (this: DialogSheet) Previous* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 503) END Previous; PROCEDURE (this: DialogSheet) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: DialogSheet) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: DialogSheet) Protect* ((* optional *) Password: CtlT.Any; DrawingObjects: CtlT.Any; Contents: CtlT.Any; Scenarios: CtlT.Any; UserInterfaceOnly: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[4]); CtlC.AnyVar(DrawingObjects, arg[3]); CtlC.AnyVar(Contents, arg[2]); CtlC.AnyVar(Scenarios, arg[1]); CtlC.AnyVar(UserInterfaceOnly, arg[0]); CtlC.CallParMethod(this, 282, arg, NIL); END Protect; PROCEDURE (this: DialogSheet) ProtectContents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 292) END ProtectContents; PROCEDURE (this: DialogSheet) ProtectDrawingObjects* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 293) END ProtectDrawingObjects; PROCEDURE (this: DialogSheet) ProtectionMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1159) END ProtectionMode; PROCEDURE (this: DialogSheet) ProtectScenarios* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END ProtectScenarios; PROCEDURE (this: DialogSheet) SaveAs* (Filename: ARRAY OF CHAR; (* optional *) FileFormat: CtlT.Any; Password: CtlT.Any; WriteResPassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; CreateBackup: CtlT.Any; AddToMru: CtlT.Any; TextCodepage: CtlT.Any; TextVisualLayout: CtlT.Any), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[8]); CtlC.AnyVar(FileFormat, arg[7]); CtlC.AnyVar(Password, arg[6]); CtlC.AnyVar(WriteResPassword, arg[5]); CtlC.AnyVar(ReadOnlyRecommended, arg[4]); CtlC.AnyVar(CreateBackup, arg[3]); CtlC.AnyVar(AddToMru, arg[2]); CtlC.AnyVar(TextCodepage, arg[1]); CtlC.AnyVar(TextVisualLayout, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: DialogSheet) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: DialogSheet) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 285, arg, NIL); END Unprotect; PROCEDURE (this: DialogSheet) Visible* (): XlSheetVisibility, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: DialogSheet) PUTVisible* (p1: XlSheetVisibility), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: DialogSheet) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 1377)) END Shapes; PROCEDURE (this: DialogSheet) Arcs* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 760, arg, ret); RETURN CtlC.VarObj(ret) END Arcs; PROCEDURE (this: DialogSheet) Buttons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 557, arg, ret); RETURN CtlC.VarObj(ret) END Buttons; PROCEDURE (this: DialogSheet) EnableCalculation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1424) END EnableCalculation; PROCEDURE (this: DialogSheet) PUTEnableCalculation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1424, p1) END PUTEnableCalculation; PROCEDURE (this: DialogSheet) ChartObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1060, arg, ret); RETURN CtlC.VarObj(ret) END ChartObjects; PROCEDURE (this: DialogSheet) CheckBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 824, arg, ret); RETURN CtlC.VarObj(ret) END CheckBoxes; PROCEDURE (this: DialogSheet) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[3]); CtlC.AnyVar(IgnoreUppercase, arg[2]); CtlC.AnyVar(AlwaysSuggest, arg[1]); CtlC.AnyVar(SpellLang, arg[0]); CtlC.CallParMethod(this, 505, arg, NIL); END CheckSpelling; PROCEDURE (this: DialogSheet) DisplayAutomaticPageBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 643) END DisplayAutomaticPageBreaks; PROCEDURE (this: DialogSheet) PUTDisplayAutomaticPageBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 643, p1) END PUTDisplayAutomaticPageBreaks; PROCEDURE (this: DialogSheet) Drawings* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 772, arg, ret); RETURN CtlC.VarObj(ret) END Drawings; PROCEDURE (this: DialogSheet) DrawingObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 88, arg, ret); RETURN CtlC.VarObj(ret) END DrawingObjects; PROCEDURE (this: DialogSheet) DropDowns* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 836, arg, ret); RETURN CtlC.VarObj(ret) END DropDowns; PROCEDURE (this: DialogSheet) EnableAutoFilter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1156) END EnableAutoFilter; PROCEDURE (this: DialogSheet) PUTEnableAutoFilter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1156, p1) END PUTEnableAutoFilter; PROCEDURE (this: DialogSheet) EnableSelection* (): XlEnableSelection, NEW; BEGIN RETURN CtlC.GetInt(this, 1425) END EnableSelection; PROCEDURE (this: DialogSheet) PUTEnableSelection* (p1: XlEnableSelection), NEW; BEGIN CtlC.PutInt(this, 1425, p1) END PUTEnableSelection; PROCEDURE (this: DialogSheet) EnableOutlining* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1157) END EnableOutlining; PROCEDURE (this: DialogSheet) PUTEnableOutlining* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1157, p1) END PUTEnableOutlining; PROCEDURE (this: DialogSheet) EnablePivotTable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1158) END EnablePivotTable; PROCEDURE (this: DialogSheet) PUTEnablePivotTable* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1158, p1) END PUTEnablePivotTable; PROCEDURE (this: DialogSheet) Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: DialogSheet) _Evaluate* (Name: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, -5, arg, ret); RETURN CtlC.VarAny(ret) END _Evaluate; PROCEDURE (this: DialogSheet) ResetAllPageBreaks* (), NEW; BEGIN CtlC.CallMethod(this, 1426, NIL); END ResetAllPageBreaks; PROCEDURE (this: DialogSheet) GroupBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 834, arg, ret); RETURN CtlC.VarObj(ret) END GroupBoxes; PROCEDURE (this: DialogSheet) GroupObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1113, arg, ret); RETURN CtlC.VarObj(ret) END GroupObjects; PROCEDURE (this: DialogSheet) Labels* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 841, arg, ret); RETURN CtlC.VarObj(ret) END Labels; PROCEDURE (this: DialogSheet) Lines* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 767, arg, ret); RETURN CtlC.VarObj(ret) END Lines; PROCEDURE (this: DialogSheet) ListBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 832, arg, ret); RETURN CtlC.VarObj(ret) END ListBoxes; PROCEDURE (this: DialogSheet) Names* (): Names, NEW; BEGIN RETURN ThisNames(CtlC.GetAny(this, 442)) END Names; PROCEDURE (this: DialogSheet) OLEObjects* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 799, arg, ret); RETURN CtlC.VarObj(ret) END OLEObjects; PROCEDURE (this: DialogSheet) OptionButtons* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 826, arg, ret); RETURN CtlC.VarObj(ret) END OptionButtons; PROCEDURE (this: DialogSheet) Ovals* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 801, arg, ret); RETURN CtlC.VarObj(ret) END Ovals; PROCEDURE (this: DialogSheet) Paste* ((* optional *) Destination: CtlT.Any; Link: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[1]); CtlC.AnyVar(Link, arg[0]); CtlC.CallParMethod(this, 211, arg, NIL); END Paste; PROCEDURE (this: DialogSheet) PasteSpecial* ((* optional *) Format: CtlT.Any; Link: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[5]); CtlC.AnyVar(Link, arg[4]); CtlC.AnyVar(DisplayAsIcon, arg[3]); CtlC.AnyVar(IconFileName, arg[2]); CtlC.AnyVar(IconIndex, arg[1]); CtlC.AnyVar(IconLabel, arg[0]); CtlC.CallParMethod(this, 1027, arg, NIL); END PasteSpecial; PROCEDURE (this: DialogSheet) Pictures* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 771, arg, ret); RETURN CtlC.VarObj(ret) END Pictures; PROCEDURE (this: DialogSheet) Rectangles* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 774, arg, ret); RETURN CtlC.VarObj(ret) END Rectangles; PROCEDURE (this: DialogSheet) ScrollArea* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1433) END ScrollArea; PROCEDURE (this: DialogSheet) PUTScrollArea* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1433, p1) END PUTScrollArea; PROCEDURE (this: DialogSheet) ScrollBars* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 830, arg, ret); RETURN CtlC.VarObj(ret) END ScrollBars; PROCEDURE (this: DialogSheet) Spinners* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 838, arg, ret); RETURN CtlC.VarObj(ret) END Spinners; PROCEDURE (this: DialogSheet) TextBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 777, arg, ret); RETURN CtlC.VarObj(ret) END TextBoxes; PROCEDURE (this: DialogSheet) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: DialogSheet) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: DialogSheet) QueryTables* (): QueryTables, NEW; BEGIN RETURN ThisQueryTables(CtlC.GetAny(this, 1434)) END QueryTables; PROCEDURE (this: DialogSheet) DisplayPageBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1435) END DisplayPageBreaks; PROCEDURE (this: DialogSheet) PUTDisplayPageBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1435, p1) END PUTDisplayPageBreaks; PROCEDURE (this: DialogSheet) Comments* (): Comments, NEW; BEGIN RETURN ThisComments(CtlC.GetAny(this, 575)) END Comments; PROCEDURE (this: DialogSheet) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 1393)) END Hyperlinks; PROCEDURE (this: DialogSheet) ClearCircles* (), NEW; BEGIN CtlC.CallMethod(this, 1436, NIL); END ClearCircles; PROCEDURE (this: DialogSheet) CircleInvalid* (), NEW; BEGIN CtlC.CallMethod(this, 1437, NIL); END CircleInvalid; PROCEDURE (this: DialogSheet) _DisplayRightToLeft* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 648) END _DisplayRightToLeft; PROCEDURE (this: DialogSheet) PUT_DisplayRightToLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 648, p1) END PUT_DisplayRightToLeft; PROCEDURE (this: DialogSheet) AutoFilter* (): AutoFilter, NEW; BEGIN RETURN ThisAutoFilter(CtlC.GetAny(this, 793)) END AutoFilter; PROCEDURE (this: DialogSheet) DisplayRightToLeft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1774) END DisplayRightToLeft; PROCEDURE (this: DialogSheet) PUTDisplayRightToLeft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1774, p1) END PUTDisplayRightToLeft; PROCEDURE (this: DialogSheet) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 1816)) END Scripts; PROCEDURE (this: DialogSheet) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; PROCEDURE (this: DialogSheet) _CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; SpellLang: CtlT.Any; IgnoreFinalYaa: CtlT.Any; SpellScript: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[5]); CtlC.AnyVar(IgnoreUppercase, arg[4]); CtlC.AnyVar(AlwaysSuggest, arg[3]); CtlC.AnyVar(SpellLang, arg[2]); CtlC.AnyVar(IgnoreFinalYaa, arg[1]); CtlC.AnyVar(SpellScript, arg[0]); CtlC.CallParMethod(this, 1817, arg, NIL); END _CheckSpelling; PROCEDURE (this: DialogSheet) DefaultButton* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 857) END DefaultButton; PROCEDURE (this: DialogSheet) PUTDefaultButton* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 857, p1) END PUTDefaultButton; PROCEDURE (this: DialogSheet) DialogFrame* (): DialogFrame, NEW; BEGIN RETURN ThisDialogFrame(CtlC.GetAny(this, 839)) END DialogFrame; PROCEDURE (this: DialogSheet) EditBoxes* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 828, arg, ret); RETURN CtlC.VarObj(ret) END EditBoxes; PROCEDURE (this: DialogSheet) Focus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 814) END Focus; PROCEDURE (this: DialogSheet) PUTFocus* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 814, p1) END PUTFocus; PROCEDURE (this: DialogSheet) Hide* ((* optional *) Cancel: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cancel, arg[0]); CtlC.CallParMethod(this, 813, arg, ret); RETURN CtlC.VarBool(ret) END Hide; PROCEDURE (this: DialogSheet) Show* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 496, ret); RETURN CtlC.VarBool(ret) END Show; (* ---------- DialogSheets, hidden ---------- *) PROCEDURE (this: DialogSheets) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DialogSheets) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DialogSheets) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DialogSheets) Add* ((* optional *) Before: CtlT.Any; After: CtlT.Any; Count: CtlT.Any): DialogSheet, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[2]); CtlC.AnyVar(After, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisDialogSheet(CtlC.VarAny(ret)) END Add; PROCEDURE (this: DialogSheets) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: DialogSheets) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: DialogSheets) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: DialogSheets) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: DialogSheets) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: DialogSheets) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: DialogSheets) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: DialogSheets) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: DialogSheets) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: DialogSheets) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: DialogSheets) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: DialogSheets) Visible* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 558) END Visible; PROCEDURE (this: DialogSheets) PUTVisible* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 558, p1) END PUTVisible; PROCEDURE (this: DialogSheets) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: DialogSheets) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- Worksheets ---------- *) PROCEDURE (this: Worksheets) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Worksheets) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Worksheets) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Worksheets) Add* ((* optional *) Before: CtlT.Any; After: CtlT.Any; Count: CtlT.Any; Type: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[3]); CtlC.AnyVar(After, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN CtlC.VarObj(ret) END Add; PROCEDURE (this: Worksheets) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Worksheets) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Worksheets) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Worksheets) FillAcrossSheets* (range: Range; Type: XlFillWith), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[1]); CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 469, arg, NIL); END FillAcrossSheets; PROCEDURE (this: Worksheets) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Worksheets) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 637, arg, NIL); END Move; PROCEDURE (this: Worksheets) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Worksheets) _PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[6]); CtlC.AnyVar(To, arg[5]); CtlC.AnyVar(Copies, arg[4]); CtlC.AnyVar(Preview, arg[3]); CtlC.AnyVar(ActivePrinter, arg[2]); CtlC.AnyVar(PrintToFile, arg[1]); CtlC.AnyVar(Collate, arg[0]); CtlC.CallParMethod(this, 905, arg, NIL); END _PrintOut; PROCEDURE (this: Worksheets) PrintPreview* ((* optional *) EnableChanges: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(EnableChanges, arg[0]); CtlC.CallParMethod(this, 281, arg, NIL); END PrintPreview; PROCEDURE (this: Worksheets) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Worksheets) HPageBreaks* (): HPageBreaks, NEW; BEGIN RETURN ThisHPageBreaks(CtlC.GetAny(this, 1418)) END HPageBreaks; PROCEDURE (this: Worksheets) VPageBreaks* (): VPageBreaks, NEW; BEGIN RETURN ThisVPageBreaks(CtlC.GetAny(this, 1419)) END VPageBreaks; PROCEDURE (this: Worksheets) Visible* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 558) END Visible; PROCEDURE (this: Worksheets) PUTVisible* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 558, p1) END PUTVisible; PROCEDURE (this: Worksheets) _Default* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: Worksheets) PrintOut* ((* optional *) From: CtlT.Any; To: CtlT.Any; Copies: CtlT.Any; Preview: CtlT.Any; ActivePrinter: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; PrToFileName: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.AnyVar(From, arg[7]); CtlC.AnyVar(To, arg[6]); CtlC.AnyVar(Copies, arg[5]); CtlC.AnyVar(Preview, arg[4]); CtlC.AnyVar(ActivePrinter, arg[3]); CtlC.AnyVar(PrintToFile, arg[2]); CtlC.AnyVar(Collate, arg[1]); CtlC.AnyVar(PrToFileName, arg[0]); CtlC.CallParMethod(this, 1772, arg, NIL); END PrintOut; (* ---------- PageSetup ---------- *) PROCEDURE (this: PageSetup) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PageSetup) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PageSetup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PageSetup) BlackAndWhite* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1009) END BlackAndWhite; PROCEDURE (this: PageSetup) PUTBlackAndWhite* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1009, p1) END PUTBlackAndWhite; PROCEDURE (this: PageSetup) BottomMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1002) END BottomMargin; PROCEDURE (this: PageSetup) PUTBottomMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1002, p1) END PUTBottomMargin; PROCEDURE (this: PageSetup) CenterFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1010) END CenterFooter; PROCEDURE (this: PageSetup) PUTCenterFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1010, p1) END PUTCenterFooter; PROCEDURE (this: PageSetup) CenterHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1011) END CenterHeader; PROCEDURE (this: PageSetup) PUTCenterHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1011, p1) END PUTCenterHeader; PROCEDURE (this: PageSetup) CenterHorizontally* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1005) END CenterHorizontally; PROCEDURE (this: PageSetup) PUTCenterHorizontally* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1005, p1) END PUTCenterHorizontally; PROCEDURE (this: PageSetup) CenterVertically* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1006) END CenterVertically; PROCEDURE (this: PageSetup) PUTCenterVertically* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1006, p1) END PUTCenterVertically; PROCEDURE (this: PageSetup) ChartSize* (): XlObjectSize, NEW; BEGIN RETURN CtlC.GetInt(this, 1012) END ChartSize; PROCEDURE (this: PageSetup) PUTChartSize* (p1: XlObjectSize), NEW; BEGIN CtlC.PutInt(this, 1012, p1) END PUTChartSize; PROCEDURE (this: PageSetup) Draft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1020) END Draft; PROCEDURE (this: PageSetup) PUTDraft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1020, p1) END PUTDraft; PROCEDURE (this: PageSetup) FirstPageNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1008) END FirstPageNumber; PROCEDURE (this: PageSetup) PUTFirstPageNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1008, p1) END PUTFirstPageNumber; PROCEDURE (this: PageSetup) FitToPagesTall* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1013) END FitToPagesTall; PROCEDURE (this: PageSetup) PUTFitToPagesTall* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1013, p1) END PUTFitToPagesTall; PROCEDURE (this: PageSetup) FitToPagesWide* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1014) END FitToPagesWide; PROCEDURE (this: PageSetup) PUTFitToPagesWide* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1014, p1) END PUTFitToPagesWide; PROCEDURE (this: PageSetup) FooterMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1015) END FooterMargin; PROCEDURE (this: PageSetup) PUTFooterMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1015, p1) END PUTFooterMargin; PROCEDURE (this: PageSetup) HeaderMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1016) END HeaderMargin; PROCEDURE (this: PageSetup) PUTHeaderMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1016, p1) END PUTHeaderMargin; PROCEDURE (this: PageSetup) LeftFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1017) END LeftFooter; PROCEDURE (this: PageSetup) PUTLeftFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1017, p1) END PUTLeftFooter; PROCEDURE (this: PageSetup) LeftHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1018) END LeftHeader; PROCEDURE (this: PageSetup) PUTLeftHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1018, p1) END PUTLeftHeader; PROCEDURE (this: PageSetup) LeftMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 999) END LeftMargin; PROCEDURE (this: PageSetup) PUTLeftMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 999, p1) END PUTLeftMargin; PROCEDURE (this: PageSetup) Order* (): XlOrder, NEW; BEGIN RETURN CtlC.GetInt(this, 192) END Order; PROCEDURE (this: PageSetup) PUTOrder* (p1: XlOrder), NEW; BEGIN CtlC.PutInt(this, 192, p1) END PUTOrder; PROCEDURE (this: PageSetup) Orientation* (): XlPageOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: PageSetup) PUTOrientation* (p1: XlPageOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: PageSetup) PaperSize* (): XlPaperSize, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END PaperSize; PROCEDURE (this: PageSetup) PUTPaperSize* (p1: XlPaperSize), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTPaperSize; PROCEDURE (this: PageSetup) PrintArea* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1019) END PrintArea; PROCEDURE (this: PageSetup) PUTPrintArea* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1019, p1) END PUTPrintArea; PROCEDURE (this: PageSetup) PrintGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1004) END PrintGridlines; PROCEDURE (this: PageSetup) PUTPrintGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1004, p1) END PUTPrintGridlines; PROCEDURE (this: PageSetup) PrintHeadings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1003) END PrintHeadings; PROCEDURE (this: PageSetup) PUTPrintHeadings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1003, p1) END PUTPrintHeadings; PROCEDURE (this: PageSetup) PrintNotes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1021) END PrintNotes; PROCEDURE (this: PageSetup) PUTPrintNotes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1021, p1) END PUTPrintNotes; PROCEDURE (this: PageSetup) PrintQuality* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1022, arg, ret); RETURN CtlC.VarAny(ret) END PrintQuality; PROCEDURE (this: PageSetup) PUTPrintQuality* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1022, arg, NIL); END PUTPrintQuality; PROCEDURE (this: PageSetup) PrintTitleColumns* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1023) END PrintTitleColumns; PROCEDURE (this: PageSetup) PUTPrintTitleColumns* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1023, p1) END PUTPrintTitleColumns; PROCEDURE (this: PageSetup) PrintTitleRows* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1024) END PrintTitleRows; PROCEDURE (this: PageSetup) PUTPrintTitleRows* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1024, p1) END PUTPrintTitleRows; PROCEDURE (this: PageSetup) RightFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1025) END RightFooter; PROCEDURE (this: PageSetup) PUTRightFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1025, p1) END PUTRightFooter; PROCEDURE (this: PageSetup) RightHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1026) END RightHeader; PROCEDURE (this: PageSetup) PUTRightHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1026, p1) END PUTRightHeader; PROCEDURE (this: PageSetup) RightMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1000) END RightMargin; PROCEDURE (this: PageSetup) PUTRightMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1000, p1) END PUTRightMargin; PROCEDURE (this: PageSetup) TopMargin* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1001) END TopMargin; PROCEDURE (this: PageSetup) PUTTopMargin* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1001, p1) END PUTTopMargin; PROCEDURE (this: PageSetup) Zoom* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 663) END Zoom; PROCEDURE (this: PageSetup) PUTZoom* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 663, p1) END PUTZoom; PROCEDURE (this: PageSetup) PrintComments* (): XlPrintLocation, NEW; BEGIN RETURN CtlC.GetInt(this, 1524) END PrintComments; PROCEDURE (this: PageSetup) PUTPrintComments* (p1: XlPrintLocation), NEW; BEGIN CtlC.PutInt(this, 1524, p1) END PUTPrintComments; (* ---------- Names ---------- *) PROCEDURE (this: Names) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Names) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Names) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Names) Add* ((* optional *) name: CtlT.Any; RefersTo: CtlT.Any; Visible: CtlT.Any; MacroType: CtlT.Any; ShortcutKey: CtlT.Any; Category: CtlT.Any; NameLocal: CtlT.Any; RefersToLocal: CtlT.Any; CategoryLocal: CtlT.Any; RefersToR1C1: CtlT.Any; RefersToR1C1Local: CtlT.Any): Name, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(name, arg[10]); CtlC.AnyVar(RefersTo, arg[9]); CtlC.AnyVar(Visible, arg[8]); CtlC.AnyVar(MacroType, arg[7]); CtlC.AnyVar(ShortcutKey, arg[6]); CtlC.AnyVar(Category, arg[5]); CtlC.AnyVar(NameLocal, arg[4]); CtlC.AnyVar(RefersToLocal, arg[3]); CtlC.AnyVar(CategoryLocal, arg[2]); CtlC.AnyVar(RefersToR1C1, arg[1]); CtlC.AnyVar(RefersToR1C1Local, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisName(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Names) Item* ((* optional *) Index: CtlT.Any; IndexLocal: CtlT.Any; RefersTo: CtlT.Any): Name, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[2]); CtlC.AnyVar(IndexLocal, arg[1]); CtlC.AnyVar(RefersTo, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisName(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Names) _Default* ((* optional *) Index: CtlT.Any; IndexLocal: CtlT.Any; RefersTo: CtlT.Any): Name, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[2]); CtlC.AnyVar(IndexLocal, arg[1]); CtlC.AnyVar(RefersTo, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisName(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Names) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Names) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Name ---------- *) PROCEDURE (this: Name) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Name) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Name) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Name) _Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END _Default; PROCEDURE (this: Name) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Name) Category* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 934) END Category; PROCEDURE (this: Name) PUTCategory* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 934, p1) END PUTCategory; PROCEDURE (this: Name) CategoryLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 935) END CategoryLocal; PROCEDURE (this: Name) PUTCategoryLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 935, p1) END PUTCategoryLocal; PROCEDURE (this: Name) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Name) MacroType* (): XlXLMMacroType, NEW; BEGIN RETURN CtlC.GetInt(this, 936) END MacroType; PROCEDURE (this: Name) PUTMacroType* (p1: XlXLMMacroType), NEW; BEGIN CtlC.PutInt(this, 936, p1) END PUTMacroType; PROCEDURE (this: Name) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Name) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Name) RefersTo* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 938) END RefersTo; PROCEDURE (this: Name) PUTRefersTo* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 938, p1) END PUTRefersTo; PROCEDURE (this: Name) ShortcutKey* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 597) END ShortcutKey; PROCEDURE (this: Name) PUTShortcutKey* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 597, p1) END PUTShortcutKey; PROCEDURE (this: Name) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Value; PROCEDURE (this: Name) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTValue; PROCEDURE (this: Name) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Name) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Name) NameLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 937) END NameLocal; PROCEDURE (this: Name) PUTNameLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 937, p1) END PUTNameLocal; PROCEDURE (this: Name) RefersToLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 939) END RefersToLocal; PROCEDURE (this: Name) PUTRefersToLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 939, p1) END PUTRefersToLocal; PROCEDURE (this: Name) RefersToR1C1* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 940) END RefersToR1C1; PROCEDURE (this: Name) PUTRefersToR1C1* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 940, p1) END PUTRefersToR1C1; PROCEDURE (this: Name) RefersToR1C1Local* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 941) END RefersToR1C1Local; PROCEDURE (this: Name) PUTRefersToR1C1Local* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 941, p1) END PUTRefersToR1C1Local; PROCEDURE (this: Name) RefersToRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1160)) END RefersToRange; (* ---------- ChartObject ---------- *) PROCEDURE (this: ChartObject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartObject) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartObject) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: ChartObject) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ChartObject) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ChartObject) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ChartObject) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ChartObject) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ChartObject) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ChartObject) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ChartObject) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ChartObject) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ChartObject) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ChartObject) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: ChartObject) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartObject) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartObject) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ChartObject) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ChartObject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ChartObject) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: ChartObject) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ChartObject) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ChartObject) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ChartObject) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ChartObject) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ChartObject) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ChartObject) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ChartObject) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ChartObject) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartObject) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartObject) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: ChartObject) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ChartObject) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ChartObject) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ChartObject) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ChartObject) ZOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 622) END ZOrder; PROCEDURE (this: ChartObject) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ChartObject) Activate* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 304, ret); RETURN CtlC.VarAny(ret) END Activate; PROCEDURE (this: ChartObject) Chart* (): Chart, NEW; BEGIN RETURN This_Chart(CtlC.GetAny(this, 7)) END Chart; PROCEDURE (this: ChartObject) ProtectChartObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1529) END ProtectChartObject; PROCEDURE (this: ChartObject) PUTProtectChartObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1529, p1) END PUTProtectChartObject; PROCEDURE (this: ChartObject) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: ChartObject) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: ChartObject) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartObject) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartObject) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartObject) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; (* ---------- ChartObjects ---------- *) PROCEDURE (this: ChartObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartObjects) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartObjects) BringToFront* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 602, ret); RETURN CtlC.VarAny(ret) END BringToFront; PROCEDURE (this: ChartObjects) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ChartObjects) CopyPicture* (Appearance: XlPictureAppearance; Format: XlCopyPictureFormat): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Appearance, arg[1]); CtlC.IntVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, ret); RETURN CtlC.VarAny(ret) END CopyPicture; PROCEDURE (this: ChartObjects) Cut* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 565, ret); RETURN CtlC.VarAny(ret) END Cut; PROCEDURE (this: ChartObjects) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ChartObjects) Duplicate* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN CtlC.VarObj(ret) END Duplicate; PROCEDURE (this: ChartObjects) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ChartObjects) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ChartObjects) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ChartObjects) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ChartObjects) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartObjects) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartObjects) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: ChartObjects) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: ChartObjects) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: ChartObjects) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: ChartObjects) Placement* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 617) END Placement; PROCEDURE (this: ChartObjects) PUTPlacement* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 617, p1) END PUTPlacement; PROCEDURE (this: ChartObjects) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ChartObjects) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ChartObjects) Select* ((* optional *) Replace: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ChartObjects) SendToBack* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 605, ret); RETURN CtlC.VarAny(ret) END SendToBack; PROCEDURE (this: ChartObjects) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartObjects) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartObjects) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: ChartObjects) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: ChartObjects) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ChartObjects) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ChartObjects) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1528)) END ShapeRange; PROCEDURE (this: ChartObjects) RoundedCorners* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 619) END RoundedCorners; PROCEDURE (this: ChartObjects) PUTRoundedCorners* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 619, p1) END PUTRoundedCorners; PROCEDURE (this: ChartObjects) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartObjects) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartObjects) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartObjects) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: ChartObjects) Add* (Left: REAL; Top: REAL; Width: REAL; Height: REAL): ChartObject, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RealVar(Left, arg[3]); CtlC.RealVar(Top, arg[2]); CtlC.RealVar(Width, arg[1]); CtlC.RealVar(Height, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisChartObject(CtlC.VarAny(ret)) END Add; PROCEDURE (this: ChartObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ChartObjects) Group* (): GroupObject, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisGroupObject(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ChartObjects) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: ChartObjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Mailer ---------- *) PROCEDURE (this: Mailer) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Mailer) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Mailer) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Mailer) BCCRecipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 983) END BCCRecipients; PROCEDURE (this: Mailer) PUTBCCRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 983, p1) END PUTBCCRecipients; PROCEDURE (this: Mailer) CCRecipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 982) END CCRecipients; PROCEDURE (this: Mailer) PUTCCRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 982, p1) END PUTCCRecipients; PROCEDURE (this: Mailer) Enclosures* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 984) END Enclosures; PROCEDURE (this: Mailer) PUTEnclosures* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 984, p1) END PUTEnclosures; PROCEDURE (this: Mailer) Received* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 986) END Received; PROCEDURE (this: Mailer) SendDateTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 987) END SendDateTime; PROCEDURE (this: Mailer) Sender* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 988) END Sender; PROCEDURE (this: Mailer) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 953) END Subject; PROCEDURE (this: Mailer) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 953, p1) END PUTSubject; PROCEDURE (this: Mailer) ToRecipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 981) END ToRecipients; PROCEDURE (this: Mailer) PUTToRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 981, p1) END PUTToRecipients; PROCEDURE (this: Mailer) WhichAddress* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 974) END WhichAddress; PROCEDURE (this: Mailer) PUTWhichAddress* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 974, p1) END PUTWhichAddress; (* ---------- CustomViews ---------- *) PROCEDURE (this: CustomViews) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CustomViews) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CustomViews) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CustomViews) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: CustomViews) Item* (ViewName: CtlT.Any): CustomView, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ViewName, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisCustomView(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CustomViews) Add* (ViewName: ARRAY OF CHAR; (* optional *) PrintSettings: CtlT.Any; RowColSettings: CtlT.Any): CustomView, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ViewName, arg[2]); CtlC.AnyVar(PrintSettings, arg[1]); CtlC.AnyVar(RowColSettings, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisCustomView(CtlC.VarAny(ret)) END Add; PROCEDURE (this: CustomViews) _Default* (ViewName: CtlT.Any): CustomView, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ViewName, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisCustomView(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: CustomViews) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- CustomView ---------- *) PROCEDURE (this: CustomView) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: CustomView) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: CustomView) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: CustomView) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: CustomView) PrintSettings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1577) END PrintSettings; PROCEDURE (this: CustomView) RowColSettings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1578) END RowColSettings; PROCEDURE (this: CustomView) Show* (), NEW; BEGIN CtlC.CallMethod(this, 496, NIL); END Show; PROCEDURE (this: CustomView) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- FormatConditions ---------- *) PROCEDURE (this: FormatConditions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: FormatConditions) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: FormatConditions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: FormatConditions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: FormatConditions) Item* (Index: CtlT.Any): FormatCondition, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisFormatCondition(CtlC.VarAny(ret)) END Item; PROCEDURE (this: FormatConditions) Add* (Type: XlFormatConditionType; (* optional *) Operator: CtlT.Any; Formula1: CtlT.Any; Formula2: CtlT.Any): FormatCondition, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(Operator, arg[2]); CtlC.AnyVar(Formula1, arg[1]); CtlC.AnyVar(Formula2, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisFormatCondition(CtlC.VarAny(ret)) END Add; PROCEDURE (this: FormatConditions) _Default* (Index: CtlT.Any): FormatCondition, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisFormatCondition(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: FormatConditions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FormatConditions) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- FormatCondition ---------- *) PROCEDURE (this: FormatCondition) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: FormatCondition) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: FormatCondition) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: FormatCondition) Modify* (Type: XlFormatConditionType; (* optional *) Operator: CtlT.Any; Formula1: CtlT.Any; Formula2: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(Operator, arg[2]); CtlC.AnyVar(Formula1, arg[1]); CtlC.AnyVar(Formula2, arg[0]); CtlC.CallParMethod(this, 1581, arg, NIL); END Modify; PROCEDURE (this: FormatCondition) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: FormatCondition) Operator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 797) END Operator; PROCEDURE (this: FormatCondition) Formula1* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1579) END Formula1; PROCEDURE (this: FormatCondition) Formula2* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1580) END Formula2; PROCEDURE (this: FormatCondition) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: FormatCondition) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 435)) END Borders; PROCEDURE (this: FormatCondition) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: FormatCondition) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- Comments ---------- *) PROCEDURE (this: Comments) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Comments) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Comments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Comments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Comments) Item* (Index: INTEGER): Comment, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisComment(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Comments) _Default* (Index: INTEGER): Comment, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisComment(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Comments) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Comment ---------- *) PROCEDURE (this: Comment) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Comment) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Comment) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Comment) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 574) END Author; PROCEDURE (this: Comment) Shape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1582)) END Shape; PROCEDURE (this: Comment) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Comment) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Comment) Text* ((* optional *) Text: CtlT.Any; Start: CtlT.Any; Overwrite: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Text, arg[2]); CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Overwrite, arg[0]); CtlC.CallParMethod(this, 138, arg, ret); RETURN CtlC.VarStr(ret) END Text; PROCEDURE (this: Comment) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Comment) Next* (): Comment, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 502, ret); RETURN ThisComment(CtlC.VarAny(ret)) END Next; PROCEDURE (this: Comment) Previous* (): Comment, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 503, ret); RETURN ThisComment(CtlC.VarAny(ret)) END Previous; (* ---------- RefreshEvents, hidden ---------- *) PROCEDURE (this: RefreshEvents) BeforeRefresh* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: RefreshEvents) AfterRefresh* (Success: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: RefreshEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1596: ASSERT(n = 1, 11); this.BeforeRefresh(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 1597: ASSERT(n = 1, 11); this.AfterRefresh(CtlC.VarBool(par[0])) END END Invoke; PROCEDURE (this: RefreshEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0002441B-0000-0000-C000-000000000046}" END GetIID; (* ---------- _QueryTable ---------- *) PROCEDURE (this: _QueryTable) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _QueryTable) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _QueryTable) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: _QueryTable) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: _QueryTable) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: _QueryTable) FieldNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1584) END FieldNames; PROCEDURE (this: _QueryTable) PUTFieldNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1584, p1) END PUTFieldNames; PROCEDURE (this: _QueryTable) RowNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1585) END RowNumbers; PROCEDURE (this: _QueryTable) PUTRowNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1585, p1) END PUTRowNumbers; PROCEDURE (this: _QueryTable) FillAdjacentFormulas* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1586) END FillAdjacentFormulas; PROCEDURE (this: _QueryTable) PUTFillAdjacentFormulas* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1586, p1) END PUTFillAdjacentFormulas; PROCEDURE (this: _QueryTable) HasAutoFormat* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 695) END HasAutoFormat; PROCEDURE (this: _QueryTable) PUTHasAutoFormat* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 695, p1) END PUTHasAutoFormat; PROCEDURE (this: _QueryTable) RefreshOnFileOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1479) END RefreshOnFileOpen; PROCEDURE (this: _QueryTable) PUTRefreshOnFileOpen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1479, p1) END PUTRefreshOnFileOpen; PROCEDURE (this: _QueryTable) Refreshing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1587) END Refreshing; PROCEDURE (this: _QueryTable) FetchedRowOverflow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1588) END FetchedRowOverflow; PROCEDURE (this: _QueryTable) BackgroundQuery* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1427) END BackgroundQuery; PROCEDURE (this: _QueryTable) PUTBackgroundQuery* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1427, p1) END PUTBackgroundQuery; PROCEDURE (this: _QueryTable) CancelRefresh* (), NEW; BEGIN CtlC.CallMethod(this, 1589, NIL); END CancelRefresh; PROCEDURE (this: _QueryTable) RefreshStyle* (): XlCellInsertionMode, NEW; BEGIN RETURN CtlC.GetInt(this, 1590) END RefreshStyle; PROCEDURE (this: _QueryTable) PUTRefreshStyle* (p1: XlCellInsertionMode), NEW; BEGIN CtlC.PutInt(this, 1590, p1) END PUTRefreshStyle; PROCEDURE (this: _QueryTable) EnableRefresh* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1477) END EnableRefresh; PROCEDURE (this: _QueryTable) PUTEnableRefresh* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1477, p1) END PUTEnableRefresh; PROCEDURE (this: _QueryTable) SavePassword* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1481) END SavePassword; PROCEDURE (this: _QueryTable) PUTSavePassword* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1481, p1) END PUTSavePassword; PROCEDURE (this: _QueryTable) Destination* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 681)) END Destination; PROCEDURE (this: _QueryTable) Connection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1432) END Connection; PROCEDURE (this: _QueryTable) PUTConnection* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1432, p1) END PUTConnection; PROCEDURE (this: _QueryTable) Sql* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1480) END Sql; PROCEDURE (this: _QueryTable) PUTSql* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1480, p1) END PUTSql; PROCEDURE (this: _QueryTable) PostText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1591) END PostText; PROCEDURE (this: _QueryTable) PUTPostText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1591, p1) END PUTPostText; PROCEDURE (this: _QueryTable) ResultRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1592)) END ResultRange; PROCEDURE (this: _QueryTable) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: _QueryTable) Refresh* ((* optional *) BackgroundQuery: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(BackgroundQuery, arg[0]); CtlC.CallParMethod(this, 1417, arg, ret); RETURN CtlC.VarBool(ret) END Refresh; PROCEDURE (this: _QueryTable) Parameters* (): Parameters, NEW; BEGIN RETURN ThisParameters(CtlC.GetAny(this, 1593)) END Parameters; PROCEDURE (this: _QueryTable) Recordset* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1165) END Recordset; PROCEDURE (this: _QueryTable) PUTREFRecordset* (p1: CtlT.Object), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1165, arg, NIL); END PUTREFRecordset; PROCEDURE (this: _QueryTable) SaveData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 692) END SaveData; PROCEDURE (this: _QueryTable) PUTSaveData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 692, p1) END PUTSaveData; PROCEDURE (this: _QueryTable) TablesOnlyFromHTML* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1594) END TablesOnlyFromHTML; PROCEDURE (this: _QueryTable) PUTTablesOnlyFromHTML* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1594, p1) END PUTTablesOnlyFromHTML; PROCEDURE (this: _QueryTable) EnableEditing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1595) END EnableEditing; PROCEDURE (this: _QueryTable) PUTEnableEditing* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1595, p1) END PUTEnableEditing; PROCEDURE (this: _QueryTable) TextFilePlatform* (): XlPlatform, NEW; BEGIN RETURN CtlC.GetInt(this, 1855) END TextFilePlatform; PROCEDURE (this: _QueryTable) PUTTextFilePlatform* (p1: XlPlatform), NEW; BEGIN CtlC.PutInt(this, 1855, p1) END PUTTextFilePlatform; PROCEDURE (this: _QueryTable) TextFileStartRow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1856) END TextFileStartRow; PROCEDURE (this: _QueryTable) PUTTextFileStartRow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1856, p1) END PUTTextFileStartRow; PROCEDURE (this: _QueryTable) TextFileParseType* (): XlTextParsingType, NEW; BEGIN RETURN CtlC.GetInt(this, 1857) END TextFileParseType; PROCEDURE (this: _QueryTable) PUTTextFileParseType* (p1: XlTextParsingType), NEW; BEGIN CtlC.PutInt(this, 1857, p1) END PUTTextFileParseType; PROCEDURE (this: _QueryTable) TextFileTextQualifier* (): XlTextQualifier, NEW; BEGIN RETURN CtlC.GetInt(this, 1858) END TextFileTextQualifier; PROCEDURE (this: _QueryTable) PUTTextFileTextQualifier* (p1: XlTextQualifier), NEW; BEGIN CtlC.PutInt(this, 1858, p1) END PUTTextFileTextQualifier; PROCEDURE (this: _QueryTable) TextFileConsecutiveDelimiter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1859) END TextFileConsecutiveDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileConsecutiveDelimiter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1859, p1) END PUTTextFileConsecutiveDelimiter; PROCEDURE (this: _QueryTable) TextFileTabDelimiter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1860) END TextFileTabDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileTabDelimiter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1860, p1) END PUTTextFileTabDelimiter; PROCEDURE (this: _QueryTable) TextFileSemicolonDelimiter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1861) END TextFileSemicolonDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileSemicolonDelimiter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1861, p1) END PUTTextFileSemicolonDelimiter; PROCEDURE (this: _QueryTable) TextFileCommaDelimiter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1862) END TextFileCommaDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileCommaDelimiter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1862, p1) END PUTTextFileCommaDelimiter; PROCEDURE (this: _QueryTable) TextFileSpaceDelimiter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1863) END TextFileSpaceDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileSpaceDelimiter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1863, p1) END PUTTextFileSpaceDelimiter; PROCEDURE (this: _QueryTable) TextFileOtherDelimiter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1864) END TextFileOtherDelimiter; PROCEDURE (this: _QueryTable) PUTTextFileOtherDelimiter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1864, p1) END PUTTextFileOtherDelimiter; PROCEDURE (this: _QueryTable) TextFileColumnDataTypes* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1865) END TextFileColumnDataTypes; PROCEDURE (this: _QueryTable) PUTTextFileColumnDataTypes* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1865, p1) END PUTTextFileColumnDataTypes; PROCEDURE (this: _QueryTable) TextFileFixedColumnWidths* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1866) END TextFileFixedColumnWidths; PROCEDURE (this: _QueryTable) PUTTextFileFixedColumnWidths* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1866, p1) END PUTTextFileFixedColumnWidths; PROCEDURE (this: _QueryTable) PreserveColumnInfo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1867) END PreserveColumnInfo; PROCEDURE (this: _QueryTable) PUTPreserveColumnInfo* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1867, p1) END PUTPreserveColumnInfo; PROCEDURE (this: _QueryTable) PreserveFormatting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1500) END PreserveFormatting; PROCEDURE (this: _QueryTable) PUTPreserveFormatting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1500, p1) END PUTPreserveFormatting; PROCEDURE (this: _QueryTable) AdjustColumnWidth* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1868) END AdjustColumnWidth; PROCEDURE (this: _QueryTable) PUTAdjustColumnWidth* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1868, p1) END PUTAdjustColumnWidth; PROCEDURE (this: _QueryTable) CommandText* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1829) END CommandText; PROCEDURE (this: _QueryTable) PUTCommandText* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1829, p1) END PUTCommandText; PROCEDURE (this: _QueryTable) CommandType* (): XlCmdType, NEW; BEGIN RETURN CtlC.GetInt(this, 1830) END CommandType; PROCEDURE (this: _QueryTable) PUTCommandType* (p1: XlCmdType), NEW; BEGIN CtlC.PutInt(this, 1830, p1) END PUTCommandType; PROCEDURE (this: _QueryTable) TextFilePromptOnRefresh* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1869) END TextFilePromptOnRefresh; PROCEDURE (this: _QueryTable) PUTTextFilePromptOnRefresh* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1869, p1) END PUTTextFilePromptOnRefresh; PROCEDURE (this: _QueryTable) QueryType* (): xlQueryType, NEW; BEGIN RETURN CtlC.GetInt(this, 1831) END QueryType; PROCEDURE (this: _QueryTable) MaintainConnection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1832) END MaintainConnection; PROCEDURE (this: _QueryTable) PUTMaintainConnection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1832, p1) END PUTMaintainConnection; PROCEDURE (this: _QueryTable) TextFileDecimalSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1870) END TextFileDecimalSeparator; PROCEDURE (this: _QueryTable) PUTTextFileDecimalSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1870, p1) END PUTTextFileDecimalSeparator; PROCEDURE (this: _QueryTable) TextFileThousandsSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1871) END TextFileThousandsSeparator; PROCEDURE (this: _QueryTable) PUTTextFileThousandsSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1871, p1) END PUTTextFileThousandsSeparator; PROCEDURE (this: _QueryTable) RefreshPeriod* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1833) END RefreshPeriod; PROCEDURE (this: _QueryTable) PUTRefreshPeriod* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1833, p1) END PUTRefreshPeriod; PROCEDURE (this: _QueryTable) ResetTimer* (), NEW; BEGIN CtlC.CallMethod(this, 1834, NIL); END ResetTimer; PROCEDURE (this: _QueryTable) WebSelectionType* (): xlWebSelectionType, NEW; BEGIN RETURN CtlC.GetInt(this, 1872) END WebSelectionType; PROCEDURE (this: _QueryTable) PUTWebSelectionType* (p1: xlWebSelectionType), NEW; BEGIN CtlC.PutInt(this, 1872, p1) END PUTWebSelectionType; PROCEDURE (this: _QueryTable) WebFormatting* (): xlWebFormatting, NEW; BEGIN RETURN CtlC.GetInt(this, 1873) END WebFormatting; PROCEDURE (this: _QueryTable) PUTWebFormatting* (p1: xlWebFormatting), NEW; BEGIN CtlC.PutInt(this, 1873, p1) END PUTWebFormatting; PROCEDURE (this: _QueryTable) WebTables* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1874) END WebTables; PROCEDURE (this: _QueryTable) PUTWebTables* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1874, p1) END PUTWebTables; PROCEDURE (this: _QueryTable) WebPreFormattedTextToColumns* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1875) END WebPreFormattedTextToColumns; PROCEDURE (this: _QueryTable) PUTWebPreFormattedTextToColumns* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1875, p1) END PUTWebPreFormattedTextToColumns; PROCEDURE (this: _QueryTable) WebSingleBlockTextImport* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1876) END WebSingleBlockTextImport; PROCEDURE (this: _QueryTable) PUTWebSingleBlockTextImport* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1876, p1) END PUTWebSingleBlockTextImport; PROCEDURE (this: _QueryTable) WebDisableDateRecognition* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1877) END WebDisableDateRecognition; PROCEDURE (this: _QueryTable) PUTWebDisableDateRecognition* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1877, p1) END PUTWebDisableDateRecognition; PROCEDURE (this: _QueryTable) WebConsecutiveDelimitersAsOne* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1878) END WebConsecutiveDelimitersAsOne; PROCEDURE (this: _QueryTable) PUTWebConsecutiveDelimitersAsOne* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1878, p1) END PUTWebConsecutiveDelimitersAsOne; (* ---------- QueryTables ---------- *) PROCEDURE (this: QueryTables) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: QueryTables) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: QueryTables) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: QueryTables) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: QueryTables) Add* (Connection: CtlT.Any; Destination: Range; (* optional *) Sql: CtlT.Any): QueryTable, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Connection, arg[2]); CtlC.ObjVar(Destination, arg[1]); CtlC.AnyVar(Sql, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN This_QueryTable(CtlC.VarAny(ret)) END Add; PROCEDURE (this: QueryTables) Item* (Index: CtlT.Any): QueryTable, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN This_QueryTable(CtlC.VarAny(ret)) END Item; PROCEDURE (this: QueryTables) _Default* (Index: CtlT.Any): QueryTable, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN This_QueryTable(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: QueryTables) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Parameter ---------- *) PROCEDURE (this: Parameter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Parameter) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Parameter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Parameter) DataType* (): XlParameterDataType, NEW; BEGIN RETURN CtlC.GetInt(this, 722) END DataType; PROCEDURE (this: Parameter) PUTDataType* (p1: XlParameterDataType), NEW; BEGIN CtlC.PutInt(this, 722, p1) END PUTDataType; PROCEDURE (this: Parameter) Type* (): XlParameterType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Parameter) PromptString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1599) END PromptString; PROCEDURE (this: Parameter) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: Parameter) SourceRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1600)) END SourceRange; PROCEDURE (this: Parameter) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Parameter) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Parameter) SetParam* (Type: XlParameterType; Value: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 1601, arg, NIL); END SetParam; PROCEDURE (this: Parameter) RefreshOnChange* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1879) END RefreshOnChange; PROCEDURE (this: Parameter) PUTRefreshOnChange* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1879, p1) END PUTRefreshOnChange; (* ---------- Parameters ---------- *) PROCEDURE (this: Parameters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Parameters) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Parameters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Parameters) Add* (Name: ARRAY OF CHAR; (* optional *) iDataType: CtlT.Any): Parameter, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(iDataType, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisParameter(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Parameters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Parameters) Item* (Index: CtlT.Any): Parameter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisParameter(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Parameters) _Default* (Index: CtlT.Any): Parameter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisParameter(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Parameters) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Parameters) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- ODBCError ---------- *) PROCEDURE (this: ODBCError) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ODBCError) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ODBCError) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ODBCError) SqlState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1603) END SqlState; PROCEDURE (this: ODBCError) ErrorString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1490) END ErrorString; (* ---------- ODBCErrors ---------- *) PROCEDURE (this: ODBCErrors) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ODBCErrors) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ODBCErrors) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ODBCErrors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ODBCErrors) Item* (Index: INTEGER): ODBCError, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisODBCError(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ODBCErrors) _Default* (Index: INTEGER): ODBCError, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisODBCError(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: ODBCErrors) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Validation ---------- *) PROCEDURE (this: Validation) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Validation) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Validation) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Validation) Add* (Type: XlDVType; (* optional *) AlertStyle: CtlT.Any; Operator: CtlT.Any; Formula1: CtlT.Any; Formula2: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.AnyVar(AlertStyle, arg[3]); CtlC.AnyVar(Operator, arg[2]); CtlC.AnyVar(Formula1, arg[1]); CtlC.AnyVar(Formula2, arg[0]); CtlC.CallParMethod(this, 181, arg, NIL); END Add; PROCEDURE (this: Validation) AlertStyle* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1605) END AlertStyle; PROCEDURE (this: Validation) IgnoreBlank* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1606) END IgnoreBlank; PROCEDURE (this: Validation) PUTIgnoreBlank* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1606, p1) END PUTIgnoreBlank; PROCEDURE (this: Validation) IMEMode* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1607) END IMEMode; PROCEDURE (this: Validation) PUTIMEMode* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1607, p1) END PUTIMEMode; PROCEDURE (this: Validation) InCellDropdown* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1608) END InCellDropdown; PROCEDURE (this: Validation) PUTInCellDropdown* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1608, p1) END PUTInCellDropdown; PROCEDURE (this: Validation) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Validation) ErrorMessage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1609) END ErrorMessage; PROCEDURE (this: Validation) PUTErrorMessage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1609, p1) END PUTErrorMessage; PROCEDURE (this: Validation) ErrorTitle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610) END ErrorTitle; PROCEDURE (this: Validation) PUTErrorTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610, p1) END PUTErrorTitle; PROCEDURE (this: Validation) InputMessage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1611) END InputMessage; PROCEDURE (this: Validation) PUTInputMessage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1611, p1) END PUTInputMessage; PROCEDURE (this: Validation) InputTitle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1612) END InputTitle; PROCEDURE (this: Validation) PUTInputTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1612, p1) END PUTInputTitle; PROCEDURE (this: Validation) Formula1* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1579) END Formula1; PROCEDURE (this: Validation) Formula2* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1580) END Formula2; PROCEDURE (this: Validation) Modify* ((* optional *) Type: CtlT.Any; AlertStyle: CtlT.Any; Operator: CtlT.Any; Formula1: CtlT.Any; Formula2: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[4]); CtlC.AnyVar(AlertStyle, arg[3]); CtlC.AnyVar(Operator, arg[2]); CtlC.AnyVar(Formula1, arg[1]); CtlC.AnyVar(Formula2, arg[0]); CtlC.CallParMethod(this, 1581, arg, NIL); END Modify; PROCEDURE (this: Validation) Operator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 797) END Operator; PROCEDURE (this: Validation) ShowError* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1613) END ShowError; PROCEDURE (this: Validation) PUTShowError* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1613, p1) END PUTShowError; PROCEDURE (this: Validation) ShowInput* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1614) END ShowInput; PROCEDURE (this: Validation) PUTShowInput* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1614, p1) END PUTShowInput; PROCEDURE (this: Validation) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Validation) Value* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Value; (* ---------- Hyperlinks ---------- *) PROCEDURE (this: Hyperlinks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Hyperlinks) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Hyperlinks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Hyperlinks) Add* (Anchor: CtlT.Object; Address: ARRAY OF CHAR; (* optional *) SubAddress: CtlT.Any; ScreenTip: CtlT.Any; TextToDisplay: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Anchor, arg[4]); CtlC.StrVar(Address, arg[3]); CtlC.AnyVar(SubAddress, arg[2]); CtlC.AnyVar(ScreenTip, arg[1]); CtlC.AnyVar(TextToDisplay, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN CtlC.VarObj(ret) END Add; PROCEDURE (this: Hyperlinks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Hyperlinks) Item* (Index: CtlT.Any): Hyperlink, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Hyperlinks) _Default* (Index: CtlT.Any): Hyperlink, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Hyperlinks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Hyperlinks) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- Hyperlink ---------- *) PROCEDURE (this: Hyperlink) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Hyperlink) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Hyperlink) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Hyperlink) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Hyperlink) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 197)) END Range; PROCEDURE (this: Hyperlink) Shape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1582)) END Shape; PROCEDURE (this: Hyperlink) SubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1471) END SubAddress; PROCEDURE (this: Hyperlink) PUTSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1471, p1) END PUTSubAddress; PROCEDURE (this: Hyperlink) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 236) END Address; PROCEDURE (this: Hyperlink) PUTAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 236, p1) END PUTAddress; PROCEDURE (this: Hyperlink) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Hyperlink) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 1476, NIL); END AddToFavorites; PROCEDURE (this: Hyperlink) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Hyperlink) Follow* ((* optional *) NewWindow: CtlT.Any; AddHistory: CtlT.Any; ExtraInfo: CtlT.Any; Method: CtlT.Any; HeaderInfo: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(NewWindow, arg[4]); CtlC.AnyVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.AnyVar(Method, arg[1]); CtlC.AnyVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 1616, arg, NIL); END Follow; PROCEDURE (this: Hyperlink) EmailSubject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1883) END EmailSubject; PROCEDURE (this: Hyperlink) PUTEmailSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1883, p1) END PUTEmailSubject; PROCEDURE (this: Hyperlink) ScreenTip* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1881) END ScreenTip; PROCEDURE (this: Hyperlink) PUTScreenTip* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1881, p1) END PUTScreenTip; PROCEDURE (this: Hyperlink) TextToDisplay* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1882) END TextToDisplay; PROCEDURE (this: Hyperlink) PUTTextToDisplay* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1882, p1) END PUTTextToDisplay; PROCEDURE (this: Hyperlink) CreateNewDocument* (Filename: ARRAY OF CHAR; EditNow: BOOLEAN; Overwrite: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[2]); CtlC.BoolVar(EditNow, arg[1]); CtlC.BoolVar(Overwrite, arg[0]); CtlC.CallParMethod(this, 1884, arg, NIL); END CreateNewDocument; (* ---------- AutoFilter ---------- *) PROCEDURE (this: AutoFilter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AutoFilter) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AutoFilter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AutoFilter) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 197)) END Range; PROCEDURE (this: AutoFilter) Filters* (): Filters, NEW; BEGIN RETURN ThisFilters(CtlC.GetAny(this, 1617)) END Filters; (* ---------- Filters ---------- *) PROCEDURE (this: Filters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Filters) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Filters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Filters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Filters) _Default* (Index: INTEGER): Filter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisFilter(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Filters) Item* (Index: INTEGER): Filter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisFilter(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Filters) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Filter ---------- *) PROCEDURE (this: Filter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Filter) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Filter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Filter) On* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1618) END On; PROCEDURE (this: Filter) Criteria1* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 796) END Criteria1; PROCEDURE (this: Filter) Operator* (): XlAutoFilterOperator, NEW; BEGIN RETURN CtlC.GetInt(this, 797) END Operator; PROCEDURE (this: Filter) Criteria2* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 798) END Criteria2; (* ---------- AutoCorrect ---------- *) PROCEDURE (this: AutoCorrect) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AutoCorrect) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AutoCorrect) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AutoCorrect) AddReplacement* (What: ARRAY OF CHAR; Replacement: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(What, arg[1]); CtlC.StrVar(Replacement, arg[0]); CtlC.CallParMethod(this, 1146, arg, ret); RETURN CtlC.VarAny(ret) END AddReplacement; PROCEDURE (this: AutoCorrect) CapitalizeNamesOfDays* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1150) END CapitalizeNamesOfDays; PROCEDURE (this: AutoCorrect) PUTCapitalizeNamesOfDays* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1150, p1) END PUTCapitalizeNamesOfDays; PROCEDURE (this: AutoCorrect) DeleteReplacement* (What: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(What, arg[0]); CtlC.CallParMethod(this, 1147, arg, ret); RETURN CtlC.VarAny(ret) END DeleteReplacement; PROCEDURE (this: AutoCorrect) ReplacementList* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1151, arg, ret); RETURN CtlC.VarAny(ret) END ReplacementList; PROCEDURE (this: AutoCorrect) PUTReplacementList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1151, arg, NIL); END PUTReplacementList; PROCEDURE (this: AutoCorrect) ReplaceText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1148) END ReplaceText; PROCEDURE (this: AutoCorrect) PUTReplaceText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1148, p1) END PUTReplaceText; PROCEDURE (this: AutoCorrect) TwoInitialCapitals* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1149) END TwoInitialCapitals; PROCEDURE (this: AutoCorrect) PUTTwoInitialCapitals* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1149, p1) END PUTTwoInitialCapitals; PROCEDURE (this: AutoCorrect) CorrectSentenceCap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1619) END CorrectSentenceCap; PROCEDURE (this: AutoCorrect) PUTCorrectSentenceCap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1619, p1) END PUTCorrectSentenceCap; PROCEDURE (this: AutoCorrect) CorrectCapsLock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1620) END CorrectCapsLock; PROCEDURE (this: AutoCorrect) PUTCorrectCapsLock* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1620, p1) END PUTCorrectCapsLock; (* ---------- Border ---------- *) PROCEDURE (this: Border) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Border) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Border) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Border) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Border) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Border) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Border) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Border) LineStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 119) END LineStyle; PROCEDURE (this: Border) PUTLineStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 119, p1) END PUTLineStyle; PROCEDURE (this: Border) Weight* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 120) END Weight; PROCEDURE (this: Border) PUTWeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 120, p1) END PUTWeight; (* ---------- Interior ---------- *) PROCEDURE (this: Interior) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Interior) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Interior) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Interior) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Interior) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Interior) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Interior) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Interior) InvertIfNegative* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 132) END InvertIfNegative; PROCEDURE (this: Interior) PUTInvertIfNegative* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Interior) Pattern* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 95) END Pattern; PROCEDURE (this: Interior) PUTPattern* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 95, p1) END PUTPattern; PROCEDURE (this: Interior) PatternColor* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END PatternColor; PROCEDURE (this: Interior) PUTPatternColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTPatternColor; PROCEDURE (this: Interior) PatternColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 98) END PatternColorIndex; PROCEDURE (this: Interior) PUTPatternColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 98, p1) END PUTPatternColorIndex; (* ---------- ChartFillFormat ---------- *) PROCEDURE (this: ChartFillFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartFillFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartFillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartFillFormat) OneColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 1621, arg, NIL); END OneColorGradient; PROCEDURE (this: ChartFillFormat) TwoColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 1624, arg, NIL); END TwoColorGradient; PROCEDURE (this: ChartFillFormat) PresetTextured* (PresetTexture: CtlOffice.MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 1625, arg, NIL); END PresetTextured; PROCEDURE (this: ChartFillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 1627, NIL); END Solid; PROCEDURE (this: ChartFillFormat) Patterned* (Pattern: CtlOffice.MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 1628, arg, NIL); END Patterned; PROCEDURE (this: ChartFillFormat) UserPicture* ((* optional *) PictureFile: CtlT.Any; PictureFormat: CtlT.Any; PictureStackUnit: CtlT.Any; PicturePlacement: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(PictureFile, arg[3]); CtlC.AnyVar(PictureFormat, arg[2]); CtlC.AnyVar(PictureStackUnit, arg[1]); CtlC.AnyVar(PicturePlacement, arg[0]); CtlC.CallParMethod(this, 1629, arg, NIL); END UserPicture; PROCEDURE (this: ChartFillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 1634, arg, NIL); END UserTextured; PROCEDURE (this: ChartFillFormat) PresetGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; PresetGradientType: CtlOffice.MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 1636, arg, NIL); END PresetGradient; PROCEDURE (this: ChartFillFormat) BackColor* (): ChartColorFormat, NEW; BEGIN RETURN ThisChartColorFormat(CtlC.GetAny(this, 1638)) END BackColor; PROCEDURE (this: ChartFillFormat) ForeColor* (): ChartColorFormat, NEW; BEGIN RETURN ThisChartColorFormat(CtlC.GetAny(this, 1639)) END ForeColor; PROCEDURE (this: ChartFillFormat) GradientColorType* (): CtlOffice.MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 1640) END GradientColorType; PROCEDURE (this: ChartFillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1641) END GradientDegree; PROCEDURE (this: ChartFillFormat) GradientStyle* (): CtlOffice.MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 1642) END GradientStyle; PROCEDURE (this: ChartFillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1643) END GradientVariant; PROCEDURE (this: ChartFillFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 95) END Pattern; PROCEDURE (this: ChartFillFormat) PresetGradientType* (): CtlOffice.MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 1637) END PresetGradientType; PROCEDURE (this: ChartFillFormat) PresetTexture* (): CtlOffice.MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 1626) END PresetTexture; PROCEDURE (this: ChartFillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1644) END TextureName; PROCEDURE (this: ChartFillFormat) TextureType* (): CtlOffice.MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 1645) END TextureType; PROCEDURE (this: ChartFillFormat) Type* (): CtlOffice.MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ChartFillFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: ChartFillFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; (* ---------- ChartColorFormat ---------- *) PROCEDURE (this: ChartColorFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartColorFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartColorFormat) SchemeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1646) END SchemeColor; PROCEDURE (this: ChartColorFormat) PUTSchemeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1646, p1) END PUTSchemeColor; PROCEDURE (this: ChartColorFormat) RGB* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1055) END RGB; PROCEDURE (this: ChartColorFormat) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ChartColorFormat) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; (* ---------- Axis ---------- *) PROCEDURE (this: Axis) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Axis) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Axis) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Axis) AxisBetweenCategories* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 45) END AxisBetweenCategories; PROCEDURE (this: Axis) PUTAxisBetweenCategories* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 45, p1) END PUTAxisBetweenCategories; PROCEDURE (this: Axis) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: Axis) AxisTitle* (): AxisTitle, NEW; BEGIN RETURN ThisAxisTitle(CtlC.GetAny(this, 82)) END AxisTitle; PROCEDURE (this: Axis) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Axis) CategoryNames* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 156) END CategoryNames; PROCEDURE (this: Axis) PUTCategoryNames* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 156, p1) END PUTCategoryNames; PROCEDURE (this: Axis) Crosses* (): XlAxisCrosses, NEW; BEGIN RETURN CtlC.GetInt(this, 42) END Crosses; PROCEDURE (this: Axis) PUTCrosses* (p1: XlAxisCrosses), NEW; BEGIN CtlC.PutInt(this, 42, p1) END PUTCrosses; PROCEDURE (this: Axis) CrossesAt* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 43) END CrossesAt; PROCEDURE (this: Axis) PUTCrossesAt* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 43, p1) END PUTCrossesAt; PROCEDURE (this: Axis) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Axis) HasMajorGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END HasMajorGridlines; PROCEDURE (this: Axis) PUTHasMajorGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTHasMajorGridlines; PROCEDURE (this: Axis) HasMinorGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END HasMinorGridlines; PROCEDURE (this: Axis) PUTHasMinorGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTHasMinorGridlines; PROCEDURE (this: Axis) HasTitle* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 54) END HasTitle; PROCEDURE (this: Axis) PUTHasTitle* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 54, p1) END PUTHasTitle; PROCEDURE (this: Axis) MajorGridlines* (): Gridlines, NEW; BEGIN RETURN ThisGridlines(CtlC.GetAny(this, 89)) END MajorGridlines; PROCEDURE (this: Axis) MajorTickMark* (): XlTickMark, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END MajorTickMark; PROCEDURE (this: Axis) PUTMajorTickMark* (p1: XlTickMark), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTMajorTickMark; PROCEDURE (this: Axis) MajorUnit* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 37) END MajorUnit; PROCEDURE (this: Axis) PUTMajorUnit* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 37, p1) END PUTMajorUnit; PROCEDURE (this: Axis) MajorUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 38) END MajorUnitIsAuto; PROCEDURE (this: Axis) PUTMajorUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 38, p1) END PUTMajorUnitIsAuto; PROCEDURE (this: Axis) MaximumScale* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 35) END MaximumScale; PROCEDURE (this: Axis) PUTMaximumScale* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 35, p1) END PUTMaximumScale; PROCEDURE (this: Axis) MaximumScaleIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END MaximumScaleIsAuto; PROCEDURE (this: Axis) PUTMaximumScaleIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTMaximumScaleIsAuto; PROCEDURE (this: Axis) MinimumScale* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 33) END MinimumScale; PROCEDURE (this: Axis) PUTMinimumScale* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 33, p1) END PUTMinimumScale; PROCEDURE (this: Axis) MinimumScaleIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34) END MinimumScaleIsAuto; PROCEDURE (this: Axis) PUTMinimumScaleIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34, p1) END PUTMinimumScaleIsAuto; PROCEDURE (this: Axis) MinorGridlines* (): Gridlines, NEW; BEGIN RETURN ThisGridlines(CtlC.GetAny(this, 90)) END MinorGridlines; PROCEDURE (this: Axis) MinorTickMark* (): XlTickMark, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END MinorTickMark; PROCEDURE (this: Axis) PUTMinorTickMark* (p1: XlTickMark), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTMinorTickMark; PROCEDURE (this: Axis) MinorUnit* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 39) END MinorUnit; PROCEDURE (this: Axis) PUTMinorUnit* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 39, p1) END PUTMinorUnit; PROCEDURE (this: Axis) MinorUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 40) END MinorUnitIsAuto; PROCEDURE (this: Axis) PUTMinorUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 40, p1) END PUTMinorUnitIsAuto; PROCEDURE (this: Axis) ReversePlotOrder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 44) END ReversePlotOrder; PROCEDURE (this: Axis) PUTReversePlotOrder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 44, p1) END PUTReversePlotOrder; PROCEDURE (this: Axis) ScaleType* (): XlScaleType, NEW; BEGIN RETURN CtlC.GetInt(this, 41) END ScaleType; PROCEDURE (this: Axis) PUTScaleType* (p1: XlScaleType), NEW; BEGIN CtlC.PutInt(this, 41, p1) END PUTScaleType; PROCEDURE (this: Axis) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Axis) TickLabelPosition* (): XlTickLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END TickLabelPosition; PROCEDURE (this: Axis) PUTTickLabelPosition* (p1: XlTickLabelPosition), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTTickLabelPosition; PROCEDURE (this: Axis) TickLabels* (): TickLabels, NEW; BEGIN RETURN ThisTickLabels(CtlC.GetAny(this, 91)) END TickLabels; PROCEDURE (this: Axis) TickLabelSpacing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 29) END TickLabelSpacing; PROCEDURE (this: Axis) PUTTickLabelSpacing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 29, p1) END PUTTickLabelSpacing; PROCEDURE (this: Axis) TickMarkSpacing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 31) END TickMarkSpacing; PROCEDURE (this: Axis) PUTTickMarkSpacing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 31, p1) END PUTTickMarkSpacing; PROCEDURE (this: Axis) Type* (): XlAxisType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Axis) PUTType* (p1: XlAxisType), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: Axis) BaseUnit* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1647) END BaseUnit; PROCEDURE (this: Axis) PUTBaseUnit* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1647, p1) END PUTBaseUnit; PROCEDURE (this: Axis) BaseUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1648) END BaseUnitIsAuto; PROCEDURE (this: Axis) PUTBaseUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1648, p1) END PUTBaseUnitIsAuto; PROCEDURE (this: Axis) MajorUnitScale* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1649) END MajorUnitScale; PROCEDURE (this: Axis) PUTMajorUnitScale* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1649, p1) END PUTMajorUnitScale; PROCEDURE (this: Axis) MinorUnitScale* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1650) END MinorUnitScale; PROCEDURE (this: Axis) PUTMinorUnitScale* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1650, p1) END PUTMinorUnitScale; PROCEDURE (this: Axis) CategoryType* (): XlCategoryType, NEW; BEGIN RETURN CtlC.GetInt(this, 1651) END CategoryType; PROCEDURE (this: Axis) PUTCategoryType* (p1: XlCategoryType), NEW; BEGIN CtlC.PutInt(this, 1651, p1) END PUTCategoryType; PROCEDURE (this: Axis) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Axis) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Axis) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Axis) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Axis) DisplayUnit* (): XlDisplayUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1886) END DisplayUnit; PROCEDURE (this: Axis) PUTDisplayUnit* (p1: XlDisplayUnit), NEW; BEGIN CtlC.PutInt(this, 1886, p1) END PUTDisplayUnit; PROCEDURE (this: Axis) DisplayUnitCustom* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1887) END DisplayUnitCustom; PROCEDURE (this: Axis) PUTDisplayUnitCustom* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1887, p1) END PUTDisplayUnitCustom; PROCEDURE (this: Axis) HasDisplayUnitLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1888) END HasDisplayUnitLabel; PROCEDURE (this: Axis) PUTHasDisplayUnitLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1888, p1) END PUTHasDisplayUnitLabel; PROCEDURE (this: Axis) DisplayUnitLabel* (): DisplayUnitLabel, NEW; BEGIN RETURN ThisDisplayUnitLabel(CtlC.GetAny(this, 1889)) END DisplayUnitLabel; (* ---------- ChartTitle ---------- *) PROCEDURE (this: ChartTitle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartTitle) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartTitle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartTitle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ChartTitle) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ChartTitle) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartTitle) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ChartTitle) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartTitle) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: ChartTitle) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: ChartTitle) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: ChartTitle) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: ChartTitle) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: ChartTitle) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: ChartTitle) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: ChartTitle) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartTitle) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartTitle) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: ChartTitle) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: ChartTitle) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartTitle) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: ChartTitle) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: ChartTitle) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: ChartTitle) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartTitle) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartTitle) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: ChartTitle) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: ChartTitle) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: ChartTitle) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: ChartTitle) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: ChartTitle) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- AxisTitle ---------- *) PROCEDURE (this: AxisTitle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AxisTitle) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AxisTitle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AxisTitle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: AxisTitle) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: AxisTitle) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: AxisTitle) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: AxisTitle) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: AxisTitle) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: AxisTitle) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: AxisTitle) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: AxisTitle) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: AxisTitle) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: AxisTitle) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: AxisTitle) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: AxisTitle) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: AxisTitle) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: AxisTitle) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: AxisTitle) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: AxisTitle) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: AxisTitle) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: AxisTitle) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: AxisTitle) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: AxisTitle) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: AxisTitle) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: AxisTitle) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: AxisTitle) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: AxisTitle) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: AxisTitle) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: AxisTitle) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: AxisTitle) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- ChartGroup ---------- *) PROCEDURE (this: ChartGroup) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartGroup) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartGroup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartGroup) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: ChartGroup) PUTAxisGroup* (p1: XlAxisGroup), NEW; BEGIN CtlC.PutInt(this, 47, p1) END PUTAxisGroup; PROCEDURE (this: ChartGroup) DoughnutHoleSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1126) END DoughnutHoleSize; PROCEDURE (this: ChartGroup) PUTDoughnutHoleSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1126, p1) END PUTDoughnutHoleSize; PROCEDURE (this: ChartGroup) DownBars* (): DownBars, NEW; BEGIN RETURN ThisDownBars(CtlC.GetAny(this, 141)) END DownBars; PROCEDURE (this: ChartGroup) DropLines* (): DropLines, NEW; BEGIN RETURN ThisDropLines(CtlC.GetAny(this, 142)) END DropLines; PROCEDURE (this: ChartGroup) FirstSliceAngle* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 63) END FirstSliceAngle; PROCEDURE (this: ChartGroup) PUTFirstSliceAngle* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 63, p1) END PUTFirstSliceAngle; PROCEDURE (this: ChartGroup) GapWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 51) END GapWidth; PROCEDURE (this: ChartGroup) PUTGapWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 51, p1) END PUTGapWidth; PROCEDURE (this: ChartGroup) HasDropLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61) END HasDropLines; PROCEDURE (this: ChartGroup) PUTHasDropLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61, p1) END PUTHasDropLines; PROCEDURE (this: ChartGroup) HasHiLoLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62) END HasHiLoLines; PROCEDURE (this: ChartGroup) PUTHasHiLoLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 62, p1) END PUTHasHiLoLines; PROCEDURE (this: ChartGroup) HasRadarAxisLabels* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 64) END HasRadarAxisLabels; PROCEDURE (this: ChartGroup) PUTHasRadarAxisLabels* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 64, p1) END PUTHasRadarAxisLabels; PROCEDURE (this: ChartGroup) HasSeriesLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 65) END HasSeriesLines; PROCEDURE (this: ChartGroup) PUTHasSeriesLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 65, p1) END PUTHasSeriesLines; PROCEDURE (this: ChartGroup) HasUpDownBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 66) END HasUpDownBars; PROCEDURE (this: ChartGroup) PUTHasUpDownBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 66, p1) END PUTHasUpDownBars; PROCEDURE (this: ChartGroup) HiLoLines* (): HiLoLines, NEW; BEGIN RETURN ThisHiLoLines(CtlC.GetAny(this, 143)) END HiLoLines; PROCEDURE (this: ChartGroup) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: ChartGroup) Overlap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 56) END Overlap; PROCEDURE (this: ChartGroup) PUTOverlap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 56, p1) END PUTOverlap; PROCEDURE (this: ChartGroup) RadarAxisLabels* (): TickLabels, NEW; BEGIN RETURN ThisTickLabels(CtlC.GetAny(this, 144)) END RadarAxisLabels; PROCEDURE (this: ChartGroup) SeriesCollection* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 68, arg, ret); RETURN CtlC.VarObj(ret) END SeriesCollection; PROCEDURE (this: ChartGroup) SeriesLines* (): SeriesLines, NEW; BEGIN RETURN ThisSeriesLines(CtlC.GetAny(this, 145)) END SeriesLines; PROCEDURE (this: ChartGroup) SubType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END SubType; PROCEDURE (this: ChartGroup) PUTSubType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTSubType; PROCEDURE (this: ChartGroup) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ChartGroup) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: ChartGroup) UpBars* (): UpBars, NEW; BEGIN RETURN ThisUpBars(CtlC.GetAny(this, 140)) END UpBars; PROCEDURE (this: ChartGroup) VaryByCategories* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 60) END VaryByCategories; PROCEDURE (this: ChartGroup) PUTVaryByCategories* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 60, p1) END PUTVaryByCategories; PROCEDURE (this: ChartGroup) SizeRepresents* (): XlSizeRepresents, NEW; BEGIN RETURN CtlC.GetInt(this, 1652) END SizeRepresents; PROCEDURE (this: ChartGroup) PUTSizeRepresents* (p1: XlSizeRepresents), NEW; BEGIN CtlC.PutInt(this, 1652, p1) END PUTSizeRepresents; PROCEDURE (this: ChartGroup) BubbleScale* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1653) END BubbleScale; PROCEDURE (this: ChartGroup) PUTBubbleScale* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1653, p1) END PUTBubbleScale; PROCEDURE (this: ChartGroup) ShowNegativeBubbles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1654) END ShowNegativeBubbles; PROCEDURE (this: ChartGroup) PUTShowNegativeBubbles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1654, p1) END PUTShowNegativeBubbles; PROCEDURE (this: ChartGroup) SplitType* (): XlChartSplitType, NEW; BEGIN RETURN CtlC.GetInt(this, 1655) END SplitType; PROCEDURE (this: ChartGroup) PUTSplitType* (p1: XlChartSplitType), NEW; BEGIN CtlC.PutInt(this, 1655, p1) END PUTSplitType; PROCEDURE (this: ChartGroup) SplitValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1656) END SplitValue; PROCEDURE (this: ChartGroup) PUTSplitValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1656, p1) END PUTSplitValue; PROCEDURE (this: ChartGroup) SecondPlotSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1657) END SecondPlotSize; PROCEDURE (this: ChartGroup) PUTSecondPlotSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1657, p1) END PUTSecondPlotSize; PROCEDURE (this: ChartGroup) Has3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1658) END Has3DShading; PROCEDURE (this: ChartGroup) PUTHas3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1658, p1) END PUTHas3DShading; (* ---------- ChartGroups ---------- *) PROCEDURE (this: ChartGroups) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartGroups) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartGroups) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartGroups) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ChartGroups) Item* (Index: CtlT.Any): ChartGroup, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisChartGroup(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ChartGroups) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Axes ---------- *) PROCEDURE (this: Axes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Axes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Axes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Axes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Axes) Item* (Type: XlAxisType; AxisGroup: XlAxisGroup): Axis, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.IntVar(AxisGroup, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisAxis(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Axes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Points ---------- *) PROCEDURE (this: Points) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Points) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Points) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Points) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Points) Item* (Index: INTEGER): Point, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPoint(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Points) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Point ---------- *) PROCEDURE (this: Point) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Point) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Point) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Point) ApplyDataLabels* (Type: XlDataLabelsType; (* optional *) LegendKey: CtlT.Any; AutoText: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(LegendKey, arg[1]); CtlC.AnyVar(AutoText, arg[0]); CtlC.CallParMethod(this, 151, arg, ret); RETURN CtlC.VarAny(ret) END ApplyDataLabels; PROCEDURE (this: Point) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Point) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Point) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Point) DataLabel* (): DataLabel, NEW; BEGIN RETURN ThisDataLabel(CtlC.GetAny(this, 158)) END DataLabel; PROCEDURE (this: Point) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Point) Explosion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 182) END Explosion; PROCEDURE (this: Point) PUTExplosion* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 182, p1) END PUTExplosion; PROCEDURE (this: Point) HasDataLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 77) END HasDataLabel; PROCEDURE (this: Point) PUTHasDataLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 77, p1) END PUTHasDataLabel; PROCEDURE (this: Point) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Point) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: Point) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Point) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: Point) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: Point) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: Point) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: Point) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: Point) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: Point) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: Point) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: Point) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: Point) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: Point) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: Point) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: Point) Paste* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 211, ret); RETURN CtlC.VarAny(ret) END Paste; PROCEDURE (this: Point) PictureType* (): XlChartPictureType, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: Point) PUTPictureType* (p1: XlChartPictureType), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: Point) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: Point) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: Point) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Point) ApplyPictToSides* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1659) END ApplyPictToSides; PROCEDURE (this: Point) PUTApplyPictToSides* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1659, p1) END PUTApplyPictToSides; PROCEDURE (this: Point) ApplyPictToFront* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1660) END ApplyPictToFront; PROCEDURE (this: Point) PUTApplyPictToFront* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1660, p1) END PUTApplyPictToFront; PROCEDURE (this: Point) ApplyPictToEnd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1661) END ApplyPictToEnd; PROCEDURE (this: Point) PUTApplyPictToEnd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1661, p1) END PUTApplyPictToEnd; PROCEDURE (this: Point) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Point) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Point) SecondaryPlot* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1662) END SecondaryPlot; PROCEDURE (this: Point) PUTSecondaryPlot* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1662, p1) END PUTSecondaryPlot; PROCEDURE (this: Point) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- Series ---------- *) PROCEDURE (this: Series) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Series) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Series) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Series) ApplyDataLabels* (Type: XlDataLabelsType; (* optional *) LegendKey: CtlT.Any; AutoText: CtlT.Any; HasLeaderLines: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(LegendKey, arg[2]); CtlC.AnyVar(AutoText, arg[1]); CtlC.AnyVar(HasLeaderLines, arg[0]); CtlC.CallParMethod(this, 151, arg, ret); RETURN CtlC.VarAny(ret) END ApplyDataLabels; PROCEDURE (this: Series) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: Series) PUTAxisGroup* (p1: XlAxisGroup), NEW; BEGIN CtlC.PutInt(this, 47, p1) END PUTAxisGroup; PROCEDURE (this: Series) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Series) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Series) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: Series) DataLabels* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 157, arg, ret); RETURN CtlC.VarObj(ret) END DataLabels; PROCEDURE (this: Series) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Series) ErrorBar* (Direction: XlErrorBarDirection; Include: XlErrorBarInclude; Type: XlErrorBarType; (* optional *) Amount: CtlT.Any; MinusValues: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[4]); CtlC.IntVar(Include, arg[3]); CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(Amount, arg[1]); CtlC.AnyVar(MinusValues, arg[0]); CtlC.CallParMethod(this, 152, arg, ret); RETURN CtlC.VarAny(ret) END ErrorBar; PROCEDURE (this: Series) ErrorBars* (): ErrorBars, NEW; BEGIN RETURN ThisErrorBars(CtlC.GetAny(this, 159)) END ErrorBars; PROCEDURE (this: Series) Explosion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 182) END Explosion; PROCEDURE (this: Series) PUTExplosion* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 182, p1) END PUTExplosion; PROCEDURE (this: Series) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 261) END Formula; PROCEDURE (this: Series) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 261, p1) END PUTFormula; PROCEDURE (this: Series) FormulaLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 263) END FormulaLocal; PROCEDURE (this: Series) PUTFormulaLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 263, p1) END PUTFormulaLocal; PROCEDURE (this: Series) FormulaR1C1* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 264) END FormulaR1C1; PROCEDURE (this: Series) PUTFormulaR1C1* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 264, p1) END PUTFormulaR1C1; PROCEDURE (this: Series) FormulaR1C1Local* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 265) END FormulaR1C1Local; PROCEDURE (this: Series) PUTFormulaR1C1Local* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 265, p1) END PUTFormulaR1C1Local; PROCEDURE (this: Series) HasDataLabels* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 78) END HasDataLabels; PROCEDURE (this: Series) PUTHasDataLabels* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 78, p1) END PUTHasDataLabels; PROCEDURE (this: Series) HasErrorBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 160) END HasErrorBars; PROCEDURE (this: Series) PUTHasErrorBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 160, p1) END PUTHasErrorBars; PROCEDURE (this: Series) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Series) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Series) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: Series) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Series) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: Series) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: Series) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: Series) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: Series) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: Series) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: Series) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: Series) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: Series) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: Series) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: Series) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: Series) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: Series) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Series) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Series) Paste* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 211, ret); RETURN CtlC.VarAny(ret) END Paste; PROCEDURE (this: Series) PictureType* (): XlChartPictureType, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: Series) PUTPictureType* (p1: XlChartPictureType), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: Series) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: Series) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: Series) PlotOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 228) END PlotOrder; PROCEDURE (this: Series) PUTPlotOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 228, p1) END PUTPlotOrder; PROCEDURE (this: Series) Points* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 70, arg, ret); RETURN CtlC.VarObj(ret) END Points; PROCEDURE (this: Series) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Series) Smooth* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 163) END Smooth; PROCEDURE (this: Series) PUTSmooth* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 163, p1) END PUTSmooth; PROCEDURE (this: Series) Trendlines* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 154, arg, ret); RETURN CtlC.VarObj(ret) END Trendlines; PROCEDURE (this: Series) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Series) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: Series) ChartType* (): XlChartType, NEW; BEGIN RETURN CtlC.GetInt(this, 1400) END ChartType; PROCEDURE (this: Series) PUTChartType* (p1: XlChartType), NEW; BEGIN CtlC.PutInt(this, 1400, p1) END PUTChartType; PROCEDURE (this: Series) ApplyCustomType* (ChartType: XlChartType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ChartType, arg[0]); CtlC.CallParMethod(this, 1401, arg, NIL); END ApplyCustomType; PROCEDURE (this: Series) Values* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 164) END Values; PROCEDURE (this: Series) PUTValues* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 164, p1) END PUTValues; PROCEDURE (this: Series) XValues* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1111) END XValues; PROCEDURE (this: Series) PUTXValues* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1111, p1) END PUTXValues; PROCEDURE (this: Series) BubbleSizes* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1664) END BubbleSizes; PROCEDURE (this: Series) PUTBubbleSizes* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1664, p1) END PUTBubbleSizes; PROCEDURE (this: Series) BarShape* (): XlBarShape, NEW; BEGIN RETURN CtlC.GetInt(this, 1403) END BarShape; PROCEDURE (this: Series) PUTBarShape* (p1: XlBarShape), NEW; BEGIN CtlC.PutInt(this, 1403, p1) END PUTBarShape; PROCEDURE (this: Series) ApplyPictToSides* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1659) END ApplyPictToSides; PROCEDURE (this: Series) PUTApplyPictToSides* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1659, p1) END PUTApplyPictToSides; PROCEDURE (this: Series) ApplyPictToFront* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1660) END ApplyPictToFront; PROCEDURE (this: Series) PUTApplyPictToFront* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1660, p1) END PUTApplyPictToFront; PROCEDURE (this: Series) ApplyPictToEnd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1661) END ApplyPictToEnd; PROCEDURE (this: Series) PUTApplyPictToEnd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1661, p1) END PUTApplyPictToEnd; PROCEDURE (this: Series) Has3DEffect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1665) END Has3DEffect; PROCEDURE (this: Series) PUTHas3DEffect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1665, p1) END PUTHas3DEffect; PROCEDURE (this: Series) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Series) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Series) HasLeaderLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1394) END HasLeaderLines; PROCEDURE (this: Series) PUTHasLeaderLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1394, p1) END PUTHasLeaderLines; PROCEDURE (this: Series) LeaderLines* (): LeaderLines, NEW; BEGIN RETURN ThisLeaderLines(CtlC.GetAny(this, 1666)) END LeaderLines; (* ---------- SeriesCollection ---------- *) PROCEDURE (this: SeriesCollection) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: SeriesCollection) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: SeriesCollection) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: SeriesCollection) Add* (Source: CtlT.Any; Rowcol: XlRowCol; (* optional *) SeriesLabels: CtlT.Any; CategoryLabels: CtlT.Any; Replace: CtlT.Any): Series, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[4]); CtlC.IntVar(Rowcol, arg[3]); CtlC.AnyVar(SeriesLabels, arg[2]); CtlC.AnyVar(CategoryLabels, arg[1]); CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisSeries(CtlC.VarAny(ret)) END Add; PROCEDURE (this: SeriesCollection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: SeriesCollection) Extend* (Source: CtlT.Any; (* optional *) Rowcol: CtlT.Any; CategoryLabels: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[2]); CtlC.AnyVar(Rowcol, arg[1]); CtlC.AnyVar(CategoryLabels, arg[0]); CtlC.CallParMethod(this, 227, arg, ret); RETURN CtlC.VarAny(ret) END Extend; PROCEDURE (this: SeriesCollection) Item* (Index: CtlT.Any): Series, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisSeries(CtlC.VarAny(ret)) END Item; PROCEDURE (this: SeriesCollection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: SeriesCollection) Paste* (Rowcol: XlRowCol; (* optional *) SeriesLabels: CtlT.Any; CategoryLabels: CtlT.Any; Replace: CtlT.Any; NewSeries: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Rowcol, arg[4]); CtlC.AnyVar(SeriesLabels, arg[3]); CtlC.AnyVar(CategoryLabels, arg[2]); CtlC.AnyVar(Replace, arg[1]); CtlC.AnyVar(NewSeries, arg[0]); CtlC.CallParMethod(this, 211, arg, ret); RETURN CtlC.VarAny(ret) END Paste; PROCEDURE (this: SeriesCollection) NewSeries* (): Series, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1117, ret); RETURN ThisSeries(CtlC.VarAny(ret)) END NewSeries; (* ---------- DataLabel ---------- *) PROCEDURE (this: DataLabel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataLabel) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DataLabel) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DataLabel) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataLabel) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DataLabel) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DataLabel) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DataLabel) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DataLabel) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DataLabel) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DataLabel) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataLabel) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DataLabel) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DataLabel) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DataLabel) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DataLabel) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DataLabel) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DataLabel) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DataLabel) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DataLabel) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DataLabel) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DataLabel) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DataLabel) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DataLabel) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DataLabel) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DataLabel) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DataLabel) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DataLabel) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataLabel) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: DataLabel) AutoText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 135) END AutoText; PROCEDURE (this: DataLabel) PUTAutoText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 135, p1) END PUTAutoText; PROCEDURE (this: DataLabel) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: DataLabel) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: DataLabel) NumberFormatLinked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 194) END NumberFormatLinked; PROCEDURE (this: DataLabel) PUTNumberFormatLinked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 194, p1) END PUTNumberFormatLinked; PROCEDURE (this: DataLabel) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: DataLabel) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: DataLabel) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataLabel) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataLabel) Type* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 108) END Type; PROCEDURE (this: DataLabel) PUTType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 108, p1) END PUTType; PROCEDURE (this: DataLabel) Position* (): XlDataLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: DataLabel) PUTPosition* (p1: XlDataLabelPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; (* ---------- DataLabels ---------- *) PROCEDURE (this: DataLabels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataLabels) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataLabels) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DataLabels) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DataLabels) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataLabels) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DataLabels) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DataLabels) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DataLabels) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataLabels) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DataLabels) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DataLabels) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DataLabels) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DataLabels) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DataLabels) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DataLabels) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DataLabels) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DataLabels) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DataLabels) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DataLabels) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataLabels) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: DataLabels) AutoText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 135) END AutoText; PROCEDURE (this: DataLabels) PUTAutoText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 135, p1) END PUTAutoText; PROCEDURE (this: DataLabels) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: DataLabels) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: DataLabels) NumberFormatLinked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 194) END NumberFormatLinked; PROCEDURE (this: DataLabels) PUTNumberFormatLinked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 194, p1) END PUTNumberFormatLinked; PROCEDURE (this: DataLabels) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: DataLabels) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: DataLabels) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataLabels) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataLabels) Type* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 108) END Type; PROCEDURE (this: DataLabels) PUTType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 108, p1) END PUTType; PROCEDURE (this: DataLabels) Position* (): XlDataLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: DataLabels) PUTPosition* (p1: XlDataLabelPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: DataLabels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: DataLabels) Item* (Index: CtlT.Any): DataLabel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisDataLabel(CtlC.VarAny(ret)) END Item; PROCEDURE (this: DataLabels) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- LegendEntry ---------- *) PROCEDURE (this: LegendEntry) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendEntry) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendEntry) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: LegendEntry) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: LegendEntry) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: LegendEntry) LegendKey* (): LegendKey, NEW; BEGIN RETURN ThisLegendKey(CtlC.GetAny(this, 174)) END LegendKey; PROCEDURE (this: LegendEntry) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: LegendEntry) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: LegendEntry) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: LegendEntry) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: LegendEntry) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: LegendEntry) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: LegendEntry) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; (* ---------- LegendEntries ---------- *) PROCEDURE (this: LegendEntries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendEntries) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: LegendEntries) Item* (Index: CtlT.Any): LegendEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisLegendEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: LegendEntries) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- LegendKey ---------- *) PROCEDURE (this: LegendKey) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendKey) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendKey) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendKey) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: LegendKey) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: LegendKey) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: LegendKey) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: LegendKey) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: LegendKey) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: LegendKey) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: LegendKey) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: LegendKey) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: LegendKey) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: LegendKey) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: LegendKey) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: LegendKey) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: LegendKey) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: LegendKey) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: LegendKey) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: LegendKey) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: LegendKey) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: LegendKey) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: LegendKey) PictureType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: LegendKey) PUTPictureType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: LegendKey) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: LegendKey) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: LegendKey) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: LegendKey) Smooth* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 163) END Smooth; PROCEDURE (this: LegendKey) PUTSmooth* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 163, p1) END PUTSmooth; PROCEDURE (this: LegendKey) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: LegendKey) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: LegendKey) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: LegendKey) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: LegendKey) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: LegendKey) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; (* ---------- Trendlines ---------- *) PROCEDURE (this: Trendlines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Trendlines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Trendlines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Trendlines) Add* (Type: XlTrendlineType; (* optional *) Order: CtlT.Any; Period: CtlT.Any; Forward: CtlT.Any; Backward: CtlT.Any; Intercept: CtlT.Any; DisplayEquation: CtlT.Any; DisplayRSquared: CtlT.Any; Name: CtlT.Any): Trendline, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[8]); CtlC.AnyVar(Order, arg[7]); CtlC.AnyVar(Period, arg[6]); CtlC.AnyVar(Forward, arg[5]); CtlC.AnyVar(Backward, arg[4]); CtlC.AnyVar(Intercept, arg[3]); CtlC.AnyVar(DisplayEquation, arg[2]); CtlC.AnyVar(DisplayRSquared, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisTrendline(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Trendlines) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Trendlines) Item* ((* optional *) Index: CtlT.Any): Trendline, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisTrendline(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Trendlines) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Trendline ---------- *) PROCEDURE (this: Trendline) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Trendline) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Trendline) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Trendline) Backward* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 185) END Backward; PROCEDURE (this: Trendline) PUTBackward* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 185, p1) END PUTBackward; PROCEDURE (this: Trendline) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Trendline) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Trendline) DataLabel* (): DataLabel, NEW; BEGIN RETURN ThisDataLabel(CtlC.GetAny(this, 158)) END DataLabel; PROCEDURE (this: Trendline) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Trendline) DisplayEquation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 190) END DisplayEquation; PROCEDURE (this: Trendline) PUTDisplayEquation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 190, p1) END PUTDisplayEquation; PROCEDURE (this: Trendline) DisplayRSquared* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 189) END DisplayRSquared; PROCEDURE (this: Trendline) PUTDisplayRSquared* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 189, p1) END PUTDisplayRSquared; PROCEDURE (this: Trendline) Forward* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 191) END Forward; PROCEDURE (this: Trendline) PUTForward* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 191, p1) END PUTForward; PROCEDURE (this: Trendline) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Trendline) Intercept* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 186) END Intercept; PROCEDURE (this: Trendline) PUTIntercept* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 186, p1) END PUTIntercept; PROCEDURE (this: Trendline) InterceptIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 187) END InterceptIsAuto; PROCEDURE (this: Trendline) PUTInterceptIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 187, p1) END PUTInterceptIsAuto; PROCEDURE (this: Trendline) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Trendline) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Trendline) NameIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 188) END NameIsAuto; PROCEDURE (this: Trendline) PUTNameIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 188, p1) END PUTNameIsAuto; PROCEDURE (this: Trendline) Order* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 192) END Order; PROCEDURE (this: Trendline) PUTOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 192, p1) END PUTOrder; PROCEDURE (this: Trendline) Period* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 184) END Period; PROCEDURE (this: Trendline) PUTPeriod* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 184, p1) END PUTPeriod; PROCEDURE (this: Trendline) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Trendline) Type* (): XlTrendlineType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Trendline) PUTType* (p1: XlTrendlineType), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; (* ---------- Corners ---------- *) PROCEDURE (this: Corners) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Corners) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Corners) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Corners) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Corners) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; (* ---------- SeriesLines ---------- *) PROCEDURE (this: SeriesLines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: SeriesLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: SeriesLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: SeriesLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: SeriesLines) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: SeriesLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: SeriesLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- HiLoLines ---------- *) PROCEDURE (this: HiLoLines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: HiLoLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: HiLoLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: HiLoLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: HiLoLines) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: HiLoLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: HiLoLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- Gridlines ---------- *) PROCEDURE (this: Gridlines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Gridlines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Gridlines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Gridlines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Gridlines) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Gridlines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Gridlines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- DropLines ---------- *) PROCEDURE (this: DropLines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DropLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DropLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DropLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DropLines) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DropLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DropLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- LeaderLines ---------- *) PROCEDURE (this: LeaderLines) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LeaderLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LeaderLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LeaderLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: LeaderLines) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: LeaderLines) Select* (), NEW; BEGIN CtlC.CallMethod(this, 235, NIL); END Select; (* ---------- UpBars ---------- *) PROCEDURE (this: UpBars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: UpBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: UpBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: UpBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: UpBars) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: UpBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: UpBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: UpBars) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: UpBars) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- DownBars ---------- *) PROCEDURE (this: DownBars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DownBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DownBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DownBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DownBars) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DownBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DownBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DownBars) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DownBars) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- Floor ---------- *) PROCEDURE (this: Floor) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Floor) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Floor) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Floor) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Floor) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Floor) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Floor) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Floor) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Floor) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Floor) PictureType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 161) END PictureType; PROCEDURE (this: Floor) PUTPictureType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 161, p1) END PUTPictureType; PROCEDURE (this: Floor) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 211, NIL); END Paste; (* ---------- Walls ---------- *) PROCEDURE (this: Walls) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Walls) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Walls) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Walls) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Walls) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Walls) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Walls) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Walls) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Walls) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Walls) PictureType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 161) END PictureType; PROCEDURE (this: Walls) PUTPictureType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 161, p1) END PUTPictureType; PROCEDURE (this: Walls) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 211, NIL); END Paste; PROCEDURE (this: Walls) PictureUnit* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 162) END PictureUnit; PROCEDURE (this: Walls) PUTPictureUnit* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 162, p1) END PUTPictureUnit; (* ---------- TickLabels ---------- *) PROCEDURE (this: TickLabels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TickLabels) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TickLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TickLabels) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: TickLabels) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: TickLabels) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: TickLabels) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: TickLabels) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: TickLabels) NumberFormatLinked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 194) END NumberFormatLinked; PROCEDURE (this: TickLabels) PUTNumberFormatLinked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 194, p1) END PUTNumberFormatLinked; PROCEDURE (this: TickLabels) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: TickLabels) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: TickLabels) Orientation* (): XlTickLabelOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: TickLabels) PUTOrientation* (p1: XlTickLabelOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: TickLabels) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: TickLabels) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: TickLabels) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: TickLabels) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: TickLabels) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: TickLabels) Depth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1890) END Depth; PROCEDURE (this: TickLabels) Offset* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 254) END Offset; PROCEDURE (this: TickLabels) PUTOffset* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 254, p1) END PUTOffset; PROCEDURE (this: TickLabels) Alignment* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 453) END Alignment; PROCEDURE (this: TickLabels) PUTAlignment* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 453, p1) END PUTAlignment; (* ---------- PlotArea ---------- *) PROCEDURE (this: PlotArea) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PlotArea) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PlotArea) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PlotArea) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: PlotArea) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: PlotArea) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: PlotArea) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: PlotArea) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: PlotArea) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: PlotArea) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: PlotArea) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: PlotArea) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: PlotArea) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: PlotArea) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: PlotArea) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: PlotArea) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: PlotArea) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: PlotArea) InsideLeft* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1667) END InsideLeft; PROCEDURE (this: PlotArea) InsideTop* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1668) END InsideTop; PROCEDURE (this: PlotArea) InsideWidth* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1669) END InsideWidth; PROCEDURE (this: PlotArea) InsideHeight* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1670) END InsideHeight; (* ---------- ChartArea ---------- *) PROCEDURE (this: ChartArea) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartArea) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartArea) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartArea) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ChartArea) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ChartArea) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartArea) Clear* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 111, ret); RETURN CtlC.VarAny(ret) END Clear; PROCEDURE (this: ChartArea) ClearContents* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 113, ret); RETURN CtlC.VarAny(ret) END ClearContents; PROCEDURE (this: ChartArea) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ChartArea) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: ChartArea) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartArea) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: ChartArea) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: ChartArea) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ChartArea) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ChartArea) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartArea) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: ChartArea) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartArea) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartArea) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartArea) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartArea) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ChartArea) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ChartArea) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: ChartArea) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- Legend ---------- *) PROCEDURE (this: Legend) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Legend) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Legend) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Legend) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Legend) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: Legend) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Legend) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Legend) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Legend) LegendEntries* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 173, arg, ret); RETURN CtlC.VarObj(ret) END LegendEntries; PROCEDURE (this: Legend) Position* (): XlLegendPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: Legend) PUTPosition* (p1: XlLegendPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: Legend) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Legend) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Legend) Clear* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 111, ret); RETURN CtlC.VarAny(ret) END Clear; PROCEDURE (this: Legend) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Legend) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Legend) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Legend) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Legend) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Legend) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Legend) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Legend) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Legend) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Legend) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Legend) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Legend) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- ErrorBars ---------- *) PROCEDURE (this: ErrorBars) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ErrorBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ErrorBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ErrorBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ErrorBars) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: ErrorBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ErrorBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ErrorBars) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: ErrorBars) EndStyle* (): XlEndStyleCap, NEW; BEGIN RETURN CtlC.GetInt(this, 1124) END EndStyle; PROCEDURE (this: ErrorBars) PUTEndStyle* (p1: XlEndStyleCap), NEW; BEGIN CtlC.PutInt(this, 1124, p1) END PUTEndStyle; (* ---------- DataTable ---------- *) PROCEDURE (this: DataTable) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataTable) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataTable) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataTable) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataTable) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataTable) HasBorderHorizontal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1671) END HasBorderHorizontal; PROCEDURE (this: DataTable) PUTHasBorderHorizontal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1671, p1) END PUTHasBorderHorizontal; PROCEDURE (this: DataTable) HasBorderVertical* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1672) END HasBorderVertical; PROCEDURE (this: DataTable) PUTHasBorderVertical* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1672, p1) END PUTHasBorderVertical; PROCEDURE (this: DataTable) HasBorderOutline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1673) END HasBorderOutline; PROCEDURE (this: DataTable) PUTHasBorderOutline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1673, p1) END PUTHasBorderOutline; PROCEDURE (this: DataTable) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataTable) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataTable) Select* (), NEW; BEGIN CtlC.CallMethod(this, 235, NIL); END Select; PROCEDURE (this: DataTable) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: DataTable) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataTable) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- Phonetic ---------- *) PROCEDURE (this: Phonetic) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Phonetic) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Phonetic) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Phonetic) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Phonetic) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Phonetic) CharacterType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1674) END CharacterType; PROCEDURE (this: Phonetic) PUTCharacterType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1674, p1) END PUTCharacterType; PROCEDURE (this: Phonetic) Alignment* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 453) END Alignment; PROCEDURE (this: Phonetic) PUTAlignment* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 453, p1) END PUTAlignment; PROCEDURE (this: Phonetic) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Phonetic) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Phonetic) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; (* ---------- Shape ---------- *) PROCEDURE (this: Shape) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Shape) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Shape) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Shape) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 1675, NIL); END Apply; PROCEDURE (this: Shape) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Shape) Duplicate* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: Shape) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 1676, arg, NIL); END Flip; PROCEDURE (this: Shape) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1678, arg, NIL); END IncrementLeft; PROCEDURE (this: Shape) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1680, arg, NIL); END IncrementRotation; PROCEDURE (this: Shape) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1681, arg, NIL); END IncrementTop; PROCEDURE (this: Shape) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 1682, NIL); END PickUp; PROCEDURE (this: Shape) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 1683, NIL); END RerouteConnections; PROCEDURE (this: Shape) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; (* optional *) Scale: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.AnyVar(Scale, arg[0]); CtlC.CallParMethod(this, 1684, arg, NIL); END ScaleHeight; PROCEDURE (this: Shape) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; (* optional *) Scale: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.AnyVar(Scale, arg[0]); CtlC.CallParMethod(this, 1688, arg, NIL); END ScaleWidth; PROCEDURE (this: Shape) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: Shape) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 1689, NIL); END SetShapesDefaultProperties; PROCEDURE (this: Shape) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: Shape) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 622, arg, NIL); END ZOrder; PROCEDURE (this: Shape) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 1691)) END Adjustments; PROCEDURE (this: Shape) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 1692)) END TextFrame; PROCEDURE (this: Shape) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 1693) END AutoShapeType; PROCEDURE (this: Shape) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 1693, p1) END PUTAutoShapeType; PROCEDURE (this: Shape) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 1694)) END Callout; PROCEDURE (this: Shape) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1695) END ConnectionSiteCount; PROCEDURE (this: Shape) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1696) END Connector; PROCEDURE (this: Shape) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 1697)) END ConnectorFormat; PROCEDURE (this: Shape) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Shape) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 1698)) END GroupItems; PROCEDURE (this: Shape) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Height; PROCEDURE (this: Shape) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Shape) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1699) END HorizontalFlip; PROCEDURE (this: Shape) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 127) END Left; PROCEDURE (this: Shape) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Shape) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 817)) END Line; PROCEDURE (this: Shape) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1700) END LockAspectRatio; PROCEDURE (this: Shape) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1700, p1) END PUTLockAspectRatio; PROCEDURE (this: Shape) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Shape) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Shape) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 1701)) END Nodes; PROCEDURE (this: Shape) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 59) END Rotation; PROCEDURE (this: Shape) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 59, p1) END PUTRotation; PROCEDURE (this: Shape) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 1631)) END PictureFormat; PROCEDURE (this: Shape) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 103)) END Shadow; PROCEDURE (this: Shape) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 1702)) END TextEffect; PROCEDURE (this: Shape) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 1703)) END ThreeD; PROCEDURE (this: Shape) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 126) END Top; PROCEDURE (this: Shape) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 126, p1) END PUTTop; PROCEDURE (this: Shape) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Shape) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1704) END VerticalFlip; PROCEDURE (this: Shape) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 621) END Vertices; PROCEDURE (this: Shape) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: Shape) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: Shape) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 122) END Width; PROCEDURE (this: Shape) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Shape) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1705) END ZOrderPosition; PROCEDURE (this: Shape) Hyperlink* (): Hyperlink, NEW; BEGIN RETURN ThisHyperlink(CtlC.GetAny(this, 1706)) END Hyperlink; PROCEDURE (this: Shape) BlackWhiteMode* (): CtlOffice.MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 1707) END BlackWhiteMode; PROCEDURE (this: Shape) PUTBlackWhiteMode* (p1: CtlOffice.MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 1707, p1) END PUTBlackWhiteMode; PROCEDURE (this: Shape) DrawingObject* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1708) END DrawingObject; PROCEDURE (this: Shape) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 596) END OnAction; PROCEDURE (this: Shape) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 596, p1) END PUTOnAction; PROCEDURE (this: Shape) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: Shape) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: Shape) TopLeftCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 620)) END TopLeftCell; PROCEDURE (this: Shape) BottomRightCell* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 615)) END BottomRightCell; PROCEDURE (this: Shape) Placement* (): XlPlacement, NEW; BEGIN RETURN CtlC.GetInt(this, 617) END Placement; PROCEDURE (this: Shape) PUTPlacement* (p1: XlPlacement), NEW; BEGIN CtlC.PutInt(this, 617, p1) END PUTPlacement; PROCEDURE (this: Shape) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 551, NIL); END Copy; PROCEDURE (this: Shape) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 565, NIL); END Cut; PROCEDURE (this: Shape) CopyPicture* ((* optional *) Appearance: CtlT.Any; Format: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Appearance, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 213, arg, NIL); END CopyPicture; PROCEDURE (this: Shape) ControlFormat* (): ControlFormat, NEW; BEGIN RETURN ThisControlFormat(CtlC.GetAny(this, 1709)) END ControlFormat; PROCEDURE (this: Shape) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 1710)) END LinkFormat; PROCEDURE (this: Shape) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 1711)) END OLEFormat; PROCEDURE (this: Shape) FormControlType* (): XlFormControl, NEW; BEGIN RETURN CtlC.GetInt(this, 1712) END FormControlType; PROCEDURE (this: Shape) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1891) END AlternativeText; PROCEDURE (this: Shape) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1891, p1) END PUTAlternativeText; PROCEDURE (this: Shape) Script* (): CtlOffice.Script, NEW; BEGIN RETURN CtlOffice.ThisScript(CtlC.GetAny(this, 1892)) END Script; (* ---------- Shapes ---------- *) PROCEDURE (this: Shapes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Shapes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Shapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Shapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Shapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Shapes) _Default* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: Shapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Shapes) AddCallout* (Type: CtlOffice.MsoCalloutType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 1713, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCallout; PROCEDURE (this: Shapes) AddConnector* (Type: CtlOffice.MsoConnectorType; BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 1714, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddConnector; PROCEDURE (this: Shapes) AddCurve* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 1719, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCurve; PROCEDURE (this: Shapes) AddLabel* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 1721, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLabel; PROCEDURE (this: Shapes) AddLine* (BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 1722, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLine; PROCEDURE (this: Shapes) AddPicture* (Filename: ARRAY OF CHAR; LinkToFile: CtlOffice.MsoTriState; SaveWithDocument: CtlOffice.MsoTriState; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filename, arg[6]); CtlC.IntVar(LinkToFile, arg[5]); CtlC.IntVar(SaveWithDocument, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 1723, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPicture; PROCEDURE (this: Shapes) AddPolyline* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 1726, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPolyline; PROCEDURE (this: Shapes) AddShape* (Type: CtlOffice.MsoAutoShapeType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 1727, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddShape; PROCEDURE (this: Shapes) AddTextEffect* (PresetTextEffect: CtlOffice.MsoPresetTextEffect; Text: ARRAY OF CHAR; FontName: ARRAY OF CHAR; FontSize: SHORTREAL; FontBold: CtlOffice.MsoTriState; FontItalic: CtlOffice.MsoTriState; Left: SHORTREAL; Top: SHORTREAL): Shape, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(PresetTextEffect, arg[7]); CtlC.StrVar(Text, arg[6]); CtlC.StrVar(FontName, arg[5]); CtlC.SRealVar(FontSize, arg[4]); CtlC.IntVar(FontBold, arg[3]); CtlC.IntVar(FontItalic, arg[2]); CtlC.SRealVar(Left, arg[1]); CtlC.SRealVar(Top, arg[0]); CtlC.CallParMethod(this, 1728, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextEffect; PROCEDURE (this: Shapes) AddTextbox* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 1734, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextbox; PROCEDURE (this: Shapes) BuildFreeform* (EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL): FreeformBuilder, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(EditingType, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 1735, arg, ret); RETURN ThisFreeformBuilder(CtlC.VarAny(ret)) END BuildFreeform; PROCEDURE (this: Shapes) Range* (Index: CtlT.Any): ShapeRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Shapes) SelectAll* (), NEW; BEGIN CtlC.CallMethod(this, 1737, NIL); END SelectAll; PROCEDURE (this: Shapes) AddFormControl* (Type: XlFormControl; Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.IntVar(Left, arg[3]); CtlC.IntVar(Top, arg[2]); CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 1738, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddFormControl; PROCEDURE (this: Shapes) AddOLEObject* ((* optional *) ClassType: CtlT.Any; Filename: CtlT.Any; Link: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any): Shape, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[10]); CtlC.AnyVar(Filename, arg[9]); CtlC.AnyVar(Link, arg[8]); CtlC.AnyVar(DisplayAsIcon, arg[7]); CtlC.AnyVar(IconFileName, arg[6]); CtlC.AnyVar(IconIndex, arg[5]); CtlC.AnyVar(IconLabel, arg[4]); CtlC.AnyVar(Left, arg[3]); CtlC.AnyVar(Top, arg[2]); CtlC.AnyVar(Width, arg[1]); CtlC.AnyVar(Height, arg[0]); CtlC.CallParMethod(this, 1739, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddOLEObject; (* ---------- ShapeRange ---------- *) PROCEDURE (this: ShapeRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ShapeRange) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ShapeRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ShapeRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ShapeRange) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeRange) _Default* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: ShapeRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeRange) Align* (AlignCmd: CtlOffice.MsoAlignCmd; RelativeTo: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(AlignCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 1740, arg, NIL); END Align; PROCEDURE (this: ShapeRange) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 1675, NIL); END Apply; PROCEDURE (this: ShapeRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: ShapeRange) Distribute* (DistributeCmd: CtlOffice.MsoDistributeCmd; RelativeTo: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(DistributeCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 1742, arg, NIL); END Distribute; PROCEDURE (this: ShapeRange) Duplicate* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1039, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: ShapeRange) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 1676, arg, NIL); END Flip; PROCEDURE (this: ShapeRange) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1678, arg, NIL); END IncrementLeft; PROCEDURE (this: ShapeRange) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1680, arg, NIL); END IncrementRotation; PROCEDURE (this: ShapeRange) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 1681, arg, NIL); END IncrementTop; PROCEDURE (this: ShapeRange) Group* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 46, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ShapeRange) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 1682, NIL); END PickUp; PROCEDURE (this: ShapeRange) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 1683, NIL); END RerouteConnections; PROCEDURE (this: ShapeRange) Regroup* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1744, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Regroup; PROCEDURE (this: ShapeRange) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; (* optional *) Scale: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.AnyVar(Scale, arg[0]); CtlC.CallParMethod(this, 1684, arg, NIL); END ScaleHeight; PROCEDURE (this: ShapeRange) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; (* optional *) Scale: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.AnyVar(Scale, arg[0]); CtlC.CallParMethod(this, 1688, arg, NIL); END ScaleWidth; PROCEDURE (this: ShapeRange) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 235, arg, NIL); END Select; PROCEDURE (this: ShapeRange) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 1689, NIL); END SetShapesDefaultProperties; PROCEDURE (this: ShapeRange) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 244, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: ShapeRange) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 622, arg, NIL); END ZOrder; PROCEDURE (this: ShapeRange) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 1691)) END Adjustments; PROCEDURE (this: ShapeRange) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 1692)) END TextFrame; PROCEDURE (this: ShapeRange) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 1693) END AutoShapeType; PROCEDURE (this: ShapeRange) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 1693, p1) END PUTAutoShapeType; PROCEDURE (this: ShapeRange) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 1694)) END Callout; PROCEDURE (this: ShapeRange) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1695) END ConnectionSiteCount; PROCEDURE (this: ShapeRange) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1696) END Connector; PROCEDURE (this: ShapeRange) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 1697)) END ConnectorFormat; PROCEDURE (this: ShapeRange) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: ShapeRange) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 1698)) END GroupItems; PROCEDURE (this: ShapeRange) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Height; PROCEDURE (this: ShapeRange) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ShapeRange) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1699) END HorizontalFlip; PROCEDURE (this: ShapeRange) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 127) END Left; PROCEDURE (this: ShapeRange) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ShapeRange) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 817)) END Line; PROCEDURE (this: ShapeRange) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1700) END LockAspectRatio; PROCEDURE (this: ShapeRange) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1700, p1) END PUTLockAspectRatio; PROCEDURE (this: ShapeRange) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ShapeRange) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: ShapeRange) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 1701)) END Nodes; PROCEDURE (this: ShapeRange) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 59) END Rotation; PROCEDURE (this: ShapeRange) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 59, p1) END PUTRotation; PROCEDURE (this: ShapeRange) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 1631)) END PictureFormat; PROCEDURE (this: ShapeRange) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 103)) END Shadow; PROCEDURE (this: ShapeRange) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 1702)) END TextEffect; PROCEDURE (this: ShapeRange) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 1703)) END ThreeD; PROCEDURE (this: ShapeRange) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 126) END Top; PROCEDURE (this: ShapeRange) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 126, p1) END PUTTop; PROCEDURE (this: ShapeRange) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ShapeRange) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1704) END VerticalFlip; PROCEDURE (this: ShapeRange) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 621) END Vertices; PROCEDURE (this: ShapeRange) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: ShapeRange) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; PROCEDURE (this: ShapeRange) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 122) END Width; PROCEDURE (this: ShapeRange) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ShapeRange) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1705) END ZOrderPosition; PROCEDURE (this: ShapeRange) BlackWhiteMode* (): CtlOffice.MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 1707) END BlackWhiteMode; PROCEDURE (this: ShapeRange) PUTBlackWhiteMode* (p1: CtlOffice.MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 1707, p1) END PUTBlackWhiteMode; PROCEDURE (this: ShapeRange) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1891) END AlternativeText; PROCEDURE (this: ShapeRange) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1891, p1) END PUTAlternativeText; (* ---------- GroupShapes ---------- *) PROCEDURE (this: GroupShapes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: GroupShapes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: GroupShapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: GroupShapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: GroupShapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: GroupShapes) _Default* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: GroupShapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- TextFrame ---------- *) PROCEDURE (this: TextFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TextFrame) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TextFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TextFrame) MarginBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1745) END MarginBottom; PROCEDURE (this: TextFrame) PUTMarginBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1745, p1) END PUTMarginBottom; PROCEDURE (this: TextFrame) MarginLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1746) END MarginLeft; PROCEDURE (this: TextFrame) PUTMarginLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1746, p1) END PUTMarginLeft; PROCEDURE (this: TextFrame) MarginRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1747) END MarginRight; PROCEDURE (this: TextFrame) PUTMarginRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1747, p1) END PUTMarginRight; PROCEDURE (this: TextFrame) MarginTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1748) END MarginTop; PROCEDURE (this: TextFrame) PUTMarginTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1748, p1) END PUTMarginTop; PROCEDURE (this: TextFrame) Orientation* (): CtlOffice.MsoTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: TextFrame) PUTOrientation* (p1: CtlOffice.MsoTextOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: TextFrame) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallParMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: TextFrame) HorizontalAlignment* (): XlHAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 136) END HorizontalAlignment; PROCEDURE (this: TextFrame) PUTHorizontalAlignment* (p1: XlHAlign), NEW; BEGIN CtlC.PutInt(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: TextFrame) VerticalAlignment* (): XlVAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 137) END VerticalAlignment; PROCEDURE (this: TextFrame) PUTVerticalAlignment* (p1: XlVAlign), NEW; BEGIN CtlC.PutInt(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: TextFrame) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END AutoSize; PROCEDURE (this: TextFrame) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTAutoSize; PROCEDURE (this: TextFrame) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: TextFrame) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: TextFrame) AutoMargins* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1749) END AutoMargins; PROCEDURE (this: TextFrame) PUTAutoMargins* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1749, p1) END PUTAutoMargins; (* ---------- ConnectorFormat ---------- *) PROCEDURE (this: ConnectorFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ConnectorFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ConnectorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ConnectorFormat) BeginConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 1750, arg, NIL); END BeginConnect; PROCEDURE (this: ConnectorFormat) BeginDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 1753, NIL); END BeginDisconnect; PROCEDURE (this: ConnectorFormat) EndConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 1754, arg, NIL); END EndConnect; PROCEDURE (this: ConnectorFormat) EndDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 1755, NIL); END EndDisconnect; PROCEDURE (this: ConnectorFormat) BeginConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1756) END BeginConnected; PROCEDURE (this: ConnectorFormat) BeginConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1757)) END BeginConnectedShape; PROCEDURE (this: ConnectorFormat) BeginConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1758) END BeginConnectionSite; PROCEDURE (this: ConnectorFormat) EndConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1759) END EndConnected; PROCEDURE (this: ConnectorFormat) EndConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1760)) END EndConnectedShape; PROCEDURE (this: ConnectorFormat) EndConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1761) END EndConnectionSite; PROCEDURE (this: ConnectorFormat) Type* (): CtlOffice.MsoConnectorType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ConnectorFormat) PUTType* (p1: CtlOffice.MsoConnectorType), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; (* ---------- FreeformBuilder ---------- *) PROCEDURE (this: FreeformBuilder) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: FreeformBuilder) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: FreeformBuilder) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: FreeformBuilder) AddNodes* (SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; (* optional *) X2: CtlT.Any; Y2: CtlT.Any; X3: CtlT.Any; Y3: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.AnyVar(X2, arg[3]); CtlC.AnyVar(Y2, arg[2]); CtlC.AnyVar(X3, arg[1]); CtlC.AnyVar(Y3, arg[0]); CtlC.CallParMethod(this, 1762, arg, NIL); END AddNodes; PROCEDURE (this: FreeformBuilder) ConvertToShape* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1766, ret); RETURN ThisShape(CtlC.VarAny(ret)) END ConvertToShape; (* ---------- ControlFormat ---------- *) PROCEDURE (this: ControlFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ControlFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ControlFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ControlFormat) AddItem* (Text: ARRAY OF CHAR; (* optional *) Index: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 851, arg, NIL); END AddItem; PROCEDURE (this: ControlFormat) RemoveAllItems* (), NEW; BEGIN CtlC.CallMethod(this, 853, NIL); END RemoveAllItems; PROCEDURE (this: ControlFormat) RemoveItem* (Index: INTEGER; (* optional *) Count: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 852, arg, NIL); END RemoveItem; PROCEDURE (this: ControlFormat) DropDownLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 848) END DropDownLines; PROCEDURE (this: ControlFormat) PUTDropDownLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 848, p1) END PUTDropDownLines; PROCEDURE (this: ControlFormat) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 600) END Enabled; PROCEDURE (this: ControlFormat) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 600, p1) END PUTEnabled; PROCEDURE (this: ControlFormat) LargeChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 845) END LargeChange; PROCEDURE (this: ControlFormat) PUTLargeChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 845, p1) END PUTLargeChange; PROCEDURE (this: ControlFormat) LinkedCell* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1058) END LinkedCell; PROCEDURE (this: ControlFormat) PUTLinkedCell* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1058, p1) END PUTLinkedCell; PROCEDURE (this: ControlFormat) List* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 861, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: ControlFormat) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 849) END ListCount; PROCEDURE (this: ControlFormat) PUTListCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 849, p1) END PUTListCount; PROCEDURE (this: ControlFormat) ListFillRange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 847) END ListFillRange; PROCEDURE (this: ControlFormat) PUTListFillRange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 847, p1) END PUTListFillRange; PROCEDURE (this: ControlFormat) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 850) END ListIndex; PROCEDURE (this: ControlFormat) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 850, p1) END PUTListIndex; PROCEDURE (this: ControlFormat) LockedText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 616) END LockedText; PROCEDURE (this: ControlFormat) PUTLockedText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 616, p1) END PUTLockedText; PROCEDURE (this: ControlFormat) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 842) END Max; PROCEDURE (this: ControlFormat) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 842, p1) END PUTMax; PROCEDURE (this: ControlFormat) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 843) END Min; PROCEDURE (this: ControlFormat) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 843, p1) END PUTMin; PROCEDURE (this: ControlFormat) MultiSelect* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32) END MultiSelect; PROCEDURE (this: ControlFormat) PUTMultiSelect* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 32, p1) END PUTMultiSelect; PROCEDURE (this: ControlFormat) PrintObject* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 618) END PrintObject; PROCEDURE (this: ControlFormat) PUTPrintObject* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 618, p1) END PUTPrintObject; PROCEDURE (this: ControlFormat) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 844) END SmallChange; PROCEDURE (this: ControlFormat) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 844, p1) END PUTSmallChange; PROCEDURE (this: ControlFormat) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ControlFormat) PUT_Default* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUT_Default; PROCEDURE (this: ControlFormat) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Value; PROCEDURE (this: ControlFormat) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTValue; (* ---------- OLEFormat ---------- *) PROCEDURE (this: OLEFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OLEFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OLEFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OLEFormat) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: OLEFormat) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1049) END Object; PROCEDURE (this: OLEFormat) ProgId* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1523) END ProgId; PROCEDURE (this: OLEFormat) Verb* ((* optional *) Verb: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Verb, arg[0]); CtlC.CallParMethod(this, 606, arg, NIL); END Verb; (* ---------- LinkFormat ---------- *) PROCEDURE (this: LinkFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LinkFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LinkFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LinkFormat) AutoUpdate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1048) END AutoUpdate; PROCEDURE (this: LinkFormat) PUTAutoUpdate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1048, p1) END PUTAutoUpdate; PROCEDURE (this: LinkFormat) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END Locked; PROCEDURE (this: LinkFormat) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTLocked; PROCEDURE (this: LinkFormat) Update* (), NEW; BEGIN CtlC.CallMethod(this, 680, NIL); END Update; (* ---------- PublishObjects ---------- *) PROCEDURE (this: PublishObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PublishObjects) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PublishObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PublishObjects) Add* (SourceType: XlSourceType; Filename: ARRAY OF CHAR; (* optional *) Sheet: CtlT.Any; Source: CtlT.Any; HtmlType: CtlT.Any; DivID: CtlT.Any; Title: CtlT.Any): PublishObject, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SourceType, arg[6]); CtlC.StrVar(Filename, arg[5]); CtlC.AnyVar(Sheet, arg[4]); CtlC.AnyVar(Source, arg[3]); CtlC.AnyVar(HtmlType, arg[2]); CtlC.AnyVar(DivID, arg[1]); CtlC.AnyVar(Title, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisPublishObject(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PublishObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: PublishObjects) Item* (Index: CtlT.Any): PublishObject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN ThisPublishObject(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PublishObjects) _Default* (Index: CtlT.Any): PublishObject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPublishObject(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: PublishObjects) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PublishObjects) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: PublishObjects) Publish* (), NEW; BEGIN CtlC.CallMethod(this, 1895, NIL); END Publish; (* ---------- OLEDBError ---------- *) PROCEDURE (this: OLEDBError) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OLEDBError) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OLEDBError) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OLEDBError) SqlState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1603) END SqlState; PROCEDURE (this: OLEDBError) ErrorString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1490) END ErrorString; PROCEDURE (this: OLEDBError) Native* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1897) END Native; PROCEDURE (this: OLEDBError) Number* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 451) END Number; PROCEDURE (this: OLEDBError) Stage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1898) END Stage; (* ---------- OLEDBErrors ---------- *) PROCEDURE (this: OLEDBErrors) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: OLEDBErrors) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: OLEDBErrors) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: OLEDBErrors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: OLEDBErrors) Item* (Index: INTEGER): OLEDBError, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisOLEDBError(CtlC.VarAny(ret)) END Item; PROCEDURE (this: OLEDBErrors) _Default* (Index: INTEGER): OLEDBError, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisOLEDBError(CtlC.VarAny(ret)) END _Default; PROCEDURE (this: OLEDBErrors) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Phonetics ---------- *) PROCEDURE (this: Phonetics) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Phonetics) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Phonetics) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Phonetics) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Phonetics) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 608) END Start; PROCEDURE (this: Phonetics) Length* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 609) END Length; PROCEDURE (this: Phonetics) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Phonetics) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Phonetics) CharacterType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1674) END CharacterType; PROCEDURE (this: Phonetics) PUTCharacterType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1674, p1) END PUTCharacterType; PROCEDURE (this: Phonetics) Alignment* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 453) END Alignment; PROCEDURE (this: Phonetics) PUTAlignment* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 453, p1) END PUTAlignment; PROCEDURE (this: Phonetics) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Phonetics) Item* (Index: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Phonetics) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: Phonetics) Add* (Start: INTEGER; Length: INTEGER; Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[2]); CtlC.IntVar(Length, arg[1]); CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 181, arg, NIL); END Add; PROCEDURE (this: Phonetics) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: Phonetics) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: Phonetics) _Default* (Index: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END _Default; PROCEDURE (this: Phonetics) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- PivotLayout ---------- *) PROCEDURE (this: PivotLayout) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PivotLayout) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PivotLayout) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PivotLayout) ColumnFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 713, arg, ret); RETURN CtlC.VarObj(ret) END ColumnFields; PROCEDURE (this: PivotLayout) DataFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 715, arg, ret); RETURN CtlC.VarObj(ret) END DataFields; PROCEDURE (this: PivotLayout) PageFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 714, arg, ret); RETURN CtlC.VarObj(ret) END PageFields; PROCEDURE (this: PivotLayout) RowFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 712, arg, ret); RETURN CtlC.VarObj(ret) END RowFields; PROCEDURE (this: PivotLayout) HiddenFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 711, arg, ret); RETURN CtlC.VarObj(ret) END HiddenFields; PROCEDURE (this: PivotLayout) VisibleFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 710, arg, ret); RETURN CtlC.VarObj(ret) END VisibleFields; PROCEDURE (this: PivotLayout) PivotFields* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 718, arg, ret); RETURN CtlC.VarObj(ret) END PivotFields; PROCEDURE (this: PivotLayout) CubeFields* (): CubeFields, NEW; BEGIN RETURN ThisCubeFields(CtlC.GetAny(this, 1839)) END CubeFields; PROCEDURE (this: PivotLayout) PivotCache* (): PivotCache, NEW; BEGIN RETURN ThisPivotCache(CtlC.GetAny(this, 1496)) END PivotCache; PROCEDURE (this: PivotLayout) PivotTable* (): PivotTable, NEW; BEGIN RETURN ThisPivotTable(CtlC.GetAny(this, 716)) END PivotTable; PROCEDURE (this: PivotLayout) InnerDetail* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 698) END InnerDetail; PROCEDURE (this: PivotLayout) PUTInnerDetail* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 698, p1) END PUTInnerDetail; PROCEDURE (this: PivotLayout) AddFields* ((* optional *) RowFields: CtlT.Any; ColumnFields: CtlT.Any; PageFields: CtlT.Any; AppendField: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowFields, arg[3]); CtlC.AnyVar(ColumnFields, arg[2]); CtlC.AnyVar(PageFields, arg[1]); CtlC.AnyVar(AppendField, arg[0]); CtlC.CallParMethod(this, 708, arg, NIL); END AddFields; (* ---------- DisplayUnitLabel ---------- *) PROCEDURE (this: DisplayUnitLabel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DisplayUnitLabel) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DisplayUnitLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DisplayUnitLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DisplayUnitLabel) Select* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 235, ret); RETURN CtlC.VarAny(ret) END Select; PROCEDURE (this: DisplayUnitLabel) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DisplayUnitLabel) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DisplayUnitLabel) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DisplayUnitLabel) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DisplayUnitLabel) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DisplayUnitLabel) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DisplayUnitLabel) Characters* ((* optional *) Start: CtlT.Any; Length: CtlT.Any): Characters, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(Length, arg[0]); CtlC.CallGetMethod(this, 603, arg, ret); RETURN ThisCharacters(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: DisplayUnitLabel) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DisplayUnitLabel) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DisplayUnitLabel) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DisplayUnitLabel) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DisplayUnitLabel) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DisplayUnitLabel) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DisplayUnitLabel) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DisplayUnitLabel) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DisplayUnitLabel) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DisplayUnitLabel) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DisplayUnitLabel) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DisplayUnitLabel) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DisplayUnitLabel) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DisplayUnitLabel) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DisplayUnitLabel) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DisplayUnitLabel) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DisplayUnitLabel) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DisplayUnitLabel) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DisplayUnitLabel) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE NewQueryTable* (): _QueryTable; BEGIN RETURN This_QueryTable(CtlC.NewObj("{59191DA1-EA47-11CE-A51F-00AA0061507F}")) END NewQueryTable; PROCEDURE NewApplication* (): _Application; BEGIN RETURN This_Application(CtlC.NewObj("{00024500-0000-0000-C000-000000000046}")) END NewApplication; PROCEDURE NewChart* (): _Chart; BEGIN RETURN This_Chart(CtlC.NewObj("{00020821-0000-0000-C000-000000000046}")) END NewChart; PROCEDURE NewWorksheet* (): _Worksheet; BEGIN RETURN This_Worksheet(CtlC.NewObj("{00020820-0000-0000-C000-000000000046}")) END NewWorksheet; PROCEDURE NewGlobal* (): _Global; BEGIN RETURN This_Global(CtlC.NewObj("{00020812-0000-0000-C000-000000000046}")) END NewGlobal; PROCEDURE NewWorkbook* (): _Workbook; BEGIN RETURN This_Workbook(CtlC.NewObj("{00020819-0000-0000-C000-000000000046}")) END NewWorkbook; PROCEDURE NewOLEObject* (): _OLEObject; BEGIN RETURN This_OLEObject(CtlC.NewObj("{00020818-0000-0000-C000-000000000046}")) END NewOLEObject; END CtlExcel9.

Ctl/Mod/Excel9.odc

MODULE CtlGraph9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Graph 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\VBAGRP9.CHM, id: 65535 *) (* guid: {00020802-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 1.3 *) IMPORT CtlT, CtlC, CtlOffice; CONST (* Constants *) xlAll* = -4104; xlAutomatic* = -4105; xlBoth* = 1; xlCenter* = -4108; xlChecker* = 9; xlCircle* = 8; xlCorner* = 2; xlCrissCross* = 16; xlCross* = 4; xlDiamond* = 2; xlDistributed* = -4117; xlDoubleAccounting* = 5; xlFixedValue* = 1; xlFormats* = -4122; xlGray16* = 17; xlGray8* = 18; xlGrid* = 15; xlHigh* = -4127; xlInside* = 2; xlJustify* = -4130; xlLightDown* = 13; xlLightHorizontal* = 11; xlLightUp* = 14; xlLightVertical* = 12; xlLow* = -4134; xlManual* = -4135; xlMinusValues* = 3; xlModule* = -4141; xlNextToAxis* = 4; xlNone* = -4142; xlNotes* = -4144; xlOff* = -4146; xlOn* = 1; xlPercent* = 2; xlPlus* = 9; xlPlusValues* = 2; xlSemiGray75* = 10; xlShowLabel* = 4; xlShowLabelAndPercent* = 5; xlShowPercent* = 3; xlShowValue* = 2; xlSimple* = -4154; xlSingle* = 2; xlSingleAccounting* = 4; xlSolid* = 1; xlSquare* = 1; xlStar* = 5; xlStError* = 4; xlToolbarButton* = 2; xlTriangle* = 3; xlGray25* = -4124; xlGray50* = -4125; xlGray75* = -4126; xlBottom* = -4107; xlLeft* = -4131; xlRight* = -4152; xlTop* = -4160; xl3DBar* = -4099; xl3DSurface* = -4103; xlBar* = 2; xlColumn* = 3; xlCombination* = -4111; xlCustom* = -4114; xlDefaultAutoFormat* = -1; xlMaximum* = 2; xlMinimum* = 4; xlOpaque* = 3; xlTransparent* = 2; xlBidi* = -5000; xlLatin* = -5001; xlContext* = -5002; xlLTR* = -5003; xlRTL* = -5004; xlFullScript* = 1; xlPartialScript* = 2; xlMixedScript* = 3; xlMixedAuthorizedScript* = 4; xlDefault* = -4143; xlVisualCursor* = 2; xlLogicalCursor* = 1; xlSystem* = 1; xlPartial* = 3; xlHindiNumerals* = 3; xlBidiCalendar* = 3; xlGregorian* = 2; xlComplete* = 4; xlScale* = 3; xlWizardDisplayAlways* = 1; xlWizardDisplayDefault* = 0; xlWizardDisplayNever* = 2; (* XlCreator *) xlCreatorCode* = 1480803660; (* XlChartGallery *) xlBuiltIn* = 21; xlUserDefined* = 22; xlAnyGallery* = 23; (* XlColorIndex *) xlColorIndexAutomatic* = -4105; xlColorIndexNone* = -4142; (* XlEndStyleCap *) xlCap* = 1; xlNoCap* = 2; (* XlRowCol *) xlColumns* = 2; xlRows* = 1; (* XlScaleType *) xlScaleLinear* = -4132; xlScaleLogarithmic* = -4133; (* XlDataSeriesType *) xlAutoFill* = 4; xlChronological* = 3; xlGrowth* = 2; xlDataSeriesLinear* = -4132; (* XlAxisCrosses *) xlAxisCrossesAutomatic* = -4105; xlAxisCrossesCustom* = -4114; xlAxisCrossesMaximum* = 2; xlAxisCrossesMinimum* = 4; (* XlAxisGroup *) xlPrimary* = 1; xlSecondary* = 2; (* XlBackground *) xlBackgroundAutomatic* = -4105; xlBackgroundOpaque* = 3; xlBackgroundTransparent* = 2; (* XlWindowState *) xlMaximized* = -4137; xlMinimized* = -4140; xlNormal* = -4143; (* XlAxisType *) xlCategory* = 1; xlSeriesAxis* = 3; xlValue* = 2; (* XlArrowHeadLength *) xlArrowHeadLengthLong* = 3; xlArrowHeadLengthMedium* = -4138; xlArrowHeadLengthShort* = 1; (* XlVAlign *) xlVAlignBottom* = -4107; xlVAlignCenter* = -4108; xlVAlignDistributed* = -4117; xlVAlignJustify* = -4130; xlVAlignTop* = -4160; (* XlTickMark *) xlTickMarkCross* = 4; xlTickMarkInside* = 2; xlTickMarkNone* = -4142; xlTickMarkOutside* = 3; (* XlErrorBarDirection *) xlX* = -4168; xlY* = 1; (* XlErrorBarInclude *) xlErrorBarIncludeBoth* = 1; xlErrorBarIncludeMinusValues* = 3; xlErrorBarIncludeNone* = -4142; xlErrorBarIncludePlusValues* = 2; (* XlDisplayBlanksAs *) xlInterpolated* = 3; xlNotPlotted* = 1; xlZero* = 2; (* XlArrowHeadStyle *) xlArrowHeadStyleClosed* = 3; xlArrowHeadStyleDoubleClosed* = 5; xlArrowHeadStyleDoubleOpen* = 4; xlArrowHeadStyleNone* = -4142; xlArrowHeadStyleOpen* = 2; (* XlArrowHeadWidth *) xlArrowHeadWidthMedium* = -4138; xlArrowHeadWidthNarrow* = 1; xlArrowHeadWidthWide* = 3; (* XlHAlign *) xlHAlignCenter* = -4108; xlHAlignCenterAcrossSelection* = 7; xlHAlignDistributed* = -4117; xlHAlignFill* = 5; xlHAlignGeneral* = 1; xlHAlignJustify* = -4130; xlHAlignLeft* = -4131; xlHAlignRight* = -4152; (* XlTickLabelPosition *) xlTickLabelPositionHigh* = -4127; xlTickLabelPositionLow* = -4134; xlTickLabelPositionNextToAxis* = 4; xlTickLabelPositionNone* = -4142; (* XlLegendPosition *) xlLegendPositionBottom* = -4107; xlLegendPositionCorner* = 2; xlLegendPositionLeft* = -4131; xlLegendPositionRight* = -4152; xlLegendPositionTop* = -4160; (* XlChartPictureType *) xlStackScale* = 3; xlStack* = 2; xlStretch* = 1; (* XlChartPicturePlacement *) xlSides* = 1; xlEnd* = 2; xlEndSides* = 3; xlFront* = 4; xlFrontSides* = 5; xlFrontEnd* = 6; xlAllFaces* = 7; (* XlOrientation *) xlDownward* = -4170; xlHorizontal* = -4128; xlUpward* = -4171; xlVertical* = -4166; (* XlTickLabelOrientation *) xlTickLabelOrientationAutomatic* = -4105; xlTickLabelOrientationDownward* = -4170; xlTickLabelOrientationHorizontal* = -4128; xlTickLabelOrientationUpward* = -4171; xlTickLabelOrientationVertical* = -4166; (* XlBorderWeight *) xlHairline* = 1; xlMedium* = -4138; xlThick* = 4; xlThin* = 2; (* XlDataSeriesDate *) xlDay* = 1; xlMonth* = 3; xlWeekday* = 2; xlYear* = 4; (* XlUnderlineStyle *) xlUnderlineStyleDouble* = -4119; xlUnderlineStyleDoubleAccounting* = 5; xlUnderlineStyleNone* = -4142; xlUnderlineStyleSingle* = 2; xlUnderlineStyleSingleAccounting* = 4; (* XlErrorBarType *) xlErrorBarTypeCustom* = -4114; xlErrorBarTypeFixedValue* = 1; xlErrorBarTypePercent* = 2; xlErrorBarTypeStDev* = -4155; xlErrorBarTypeStError* = 4; (* XlTrendlineType *) xlExponential* = 5; xlLinear* = -4132; xlLogarithmic* = -4133; xlMovingAvg* = 6; xlPolynomial* = 3; xlPower* = 4; (* XlLineStyle *) xlContinuous* = 1; xlDash* = -4115; xlDashDot* = 4; xlDashDotDot* = 5; xlDot* = -4118; xlDouble* = -4119; xlSlantDashDot* = 13; xlLineStyleNone* = -4142; (* XlDataLabelsType *) xlDataLabelsShowNone* = -4142; xlDataLabelsShowValue* = 2; xlDataLabelsShowPercent* = 3; xlDataLabelsShowLabel* = 4; xlDataLabelsShowLabelAndPercent* = 5; xlDataLabelsShowBubbleSizes* = 6; (* XlMarkerStyle *) xlMarkerStyleAutomatic* = -4105; xlMarkerStyleCircle* = 8; xlMarkerStyleDash* = -4115; xlMarkerStyleDiamond* = 2; xlMarkerStyleDot* = -4118; xlMarkerStyleNone* = -4142; xlMarkerStylePicture* = -4147; xlMarkerStylePlus* = 9; xlMarkerStyleSquare* = 1; xlMarkerStyleStar* = 5; xlMarkerStyleTriangle* = 3; xlMarkerStyleX* = -4168; (* XlPictureConvertorType *) xlBMP* = 1; xlCGM* = 7; xlDRW* = 4; xlDXF* = 5; xlEPS* = 8; xlHGL* = 6; xlPCT* = 13; xlPCX* = 10; xlPIC* = 11; xlPLT* = 12; xlTIF* = 9; xlWMF* = 2; xlWPG* = 3; (* XlPattern *) xlPatternAutomatic* = -4105; xlPatternChecker* = 9; xlPatternCrissCross* = 16; xlPatternDown* = -4121; xlPatternGray16* = 17; xlPatternGray25* = -4124; xlPatternGray50* = -4125; xlPatternGray75* = -4126; xlPatternGray8* = 18; xlPatternGrid* = 15; xlPatternHorizontal* = -4128; xlPatternLightDown* = 13; xlPatternLightHorizontal* = 11; xlPatternLightUp* = 14; xlPatternLightVertical* = 12; xlPatternNone* = -4142; xlPatternSemiGray75* = 10; xlPatternSolid* = 1; xlPatternUp* = -4162; xlPatternVertical* = -4166; (* XlChartSplitType *) xlSplitByPosition* = 1; xlSplitByPercentValue* = 3; xlSplitByCustomSplit* = 4; xlSplitByValue* = 2; (* XlDisplayUnit *) xlHundreds* = -2; xlThousands* = -3; xlTenThousands* = -4; xlHundredThousands* = -5; xlMillions* = -6; xlTenMillions* = -7; xlHundredMillions* = -8; xlThousandMillions* = -9; xlMillionMillions* = -10; (* XlDataLabelPosition *) xlLabelPositionCenter* = -4108; xlLabelPositionAbove* = 0; xlLabelPositionBelow* = 1; xlLabelPositionLeft* = -4131; xlLabelPositionRight* = -4152; xlLabelPositionOutsideEnd* = 2; xlLabelPositionInsideEnd* = 3; xlLabelPositionInsideBase* = 4; xlLabelPositionBestFit* = 5; xlLabelPositionMixed* = 6; xlLabelPositionCustom* = 7; (* XlTimeUnit *) xlDays* = 0; xlMonths* = 1; xlYears* = 2; (* XlCategoryType *) xlCategoryScale* = 2; xlTimeScale* = 3; xlAutomaticScale* = -4105; (* XlBarShape *) xlBox* = 0; xlPyramidToPoint* = 1; xlPyramidToMax* = 2; xlCylinder* = 3; xlConeToPoint* = 4; xlConeToMax* = 5; (* XlChartType *) xlColumnClustered* = 51; xlColumnStacked* = 52; xlColumnStacked100* = 53; xl3DColumnClustered* = 54; xl3DColumnStacked* = 55; xl3DColumnStacked100* = 56; xlBarClustered* = 57; xlBarStacked* = 58; xlBarStacked100* = 59; xl3DBarClustered* = 60; xl3DBarStacked* = 61; xl3DBarStacked100* = 62; xlLineStacked* = 63; xlLineStacked100* = 64; xlLineMarkers* = 65; xlLineMarkersStacked* = 66; xlLineMarkersStacked100* = 67; xlPieOfPie* = 68; xlPieExploded* = 69; xl3DPieExploded* = 70; xlBarOfPie* = 71; xlXYScatterSmooth* = 72; xlXYScatterSmoothNoMarkers* = 73; xlXYScatterLines* = 74; xlXYScatterLinesNoMarkers* = 75; xlAreaStacked* = 76; xlAreaStacked100* = 77; xl3DAreaStacked* = 78; xl3DAreaStacked100* = 79; xlDoughnutExploded* = 80; xlRadarMarkers* = 81; xlRadarFilled* = 82; xlSurface* = 83; xlSurfaceWireframe* = 84; xlSurfaceTopView* = 85; xlSurfaceTopViewWireframe* = 86; xlBubble* = 15; xlBubble3DEffect* = 87; xlStockHLC* = 88; xlStockOHLC* = 89; xlStockVHLC* = 90; xlStockVOHLC* = 91; xlCylinderColClustered* = 92; xlCylinderColStacked* = 93; xlCylinderColStacked100* = 94; xlCylinderBarClustered* = 95; xlCylinderBarStacked* = 96; xlCylinderBarStacked100* = 97; xlCylinderCol* = 98; xlConeColClustered* = 99; xlConeColStacked* = 100; xlConeColStacked100* = 101; xlConeBarClustered* = 102; xlConeBarStacked* = 103; xlConeBarStacked100* = 104; xlConeCol* = 105; xlPyramidColClustered* = 106; xlPyramidColStacked* = 107; xlPyramidColStacked100* = 108; xlPyramidBarClustered* = 109; xlPyramidBarStacked* = 110; xlPyramidBarStacked100* = 111; xlPyramidCol* = 112; xl3DColumn* = -4100; xlLine* = 4; xl3DLine* = -4101; xl3DPie* = -4102; xlPie* = 5; xlXYScatter* = -4169; xl3DArea* = -4098; xlArea* = 1; xlDoughnut* = -4120; xlRadar* = -4151; (* XlChartItem *) xlDataLabel* = 0; xlChartArea* = 2; xlSeries* = 3; xlChartTitle* = 4; xlWalls* = 5; xlCorners* = 6; xlDataTable* = 7; xlTrendline* = 8; xlErrorBars* = 9; xlXErrorBars* = 10; xlYErrorBars* = 11; xlLegendEntry* = 12; xlLegendKey* = 13; xlShape* = 14; xlMajorGridlines* = 15; xlMinorGridlines* = 16; xlAxisTitle* = 17; xlUpBars* = 18; xlPlotArea* = 19; xlDownBars* = 20; xlAxis* = 21; xlSeriesLines* = 22; xlFloor* = 23; xlLegend* = 24; xlHiLoLines* = 25; xlDropLines* = 26; xlRadarAxisLabels* = 27; xlNothing* = 28; xlLeaderLines* = 29; xlDisplayUnitLabel* = 30; xlPivotChartFieldButton* = 31; xlPivotChartDropZone* = 32; (* XlSizeRepresents *) xlSizeIsWidth* = 2; xlSizeIsArea* = 1; (* XlInsertShiftDirection *) xlShiftDown* = -4121; xlShiftToRight* = -4161; (* XlDeleteShiftDirection *) xlShiftToLeft* = -4159; xlShiftUp* = -4162; (* XlDirection *) xlDown* = -4121; xlToLeft* = -4159; xlToRight* = -4161; xlUp* = -4162; (* XlConsolidationFunction *) xlAverage* = -4106; xlCount* = -4112; xlCountNums* = -4113; xlMax* = -4136; xlMin* = -4139; xlProduct* = -4149; xlStDev* = -4155; xlStDevP* = -4156; xlSum* = -4157; xlVar* = -4164; xlVarP* = -4165; xlUnknown* = 1000; (* XlSheetType *) xlChart* = -4109; xlDialogSheet* = -4116; xlExcel4IntlMacroSheet* = 4; xlExcel4MacroSheet* = 3; xlWorksheet* = -4167; (* XlLocationInTable *) xlColumnHeader* = -4110; xlColumnItem* = 5; xlDataHeader* = 3; xlDataItem* = 7; xlPageHeader* = 2; xlPageItem* = 6; xlRowHeader* = -4153; xlRowItem* = 4; xlTableBody* = 8; (* XlFindLookIn *) xlFormulas* = -4123; xlComments* = -4144; xlValues* = -4163; (* XlWindowType *) xlChartAsWindow* = 5; xlChartInPlace* = 4; xlClipboard* = 3; xlInfo* = -4129; xlWorkbook* = 1; (* XlPivotFieldDataType *) xlDate* = 2; xlNumber* = -4145; xlText* = -4158; (* XlCopyPictureFormat *) xlBitmap* = 2; xlPicture* = -4147; (* XlPivotTableSourceType *) xlConsolidation* = 3; xlDatabase* = 1; xlExternal* = 2; xlPivotTable* = -4148; (* XlReferenceStyle *) xlA1* = 1; xlR1C1* = -4150; (* xlPivotFormatType *) xlReport1* = 0; xlReport2* = 1; xlReport3* = 2; xlReport4* = 3; xlReport5* = 4; xlReport6* = 5; xlReport7* = 6; xlReport8* = 7; xlReport9* = 8; xlReport10* = 9; xlTable1* = 10; xlTable2* = 11; xlTable3* = 12; xlTable4* = 13; xlTable5* = 14; xlTable6* = 15; xlTable7* = 16; xlTable8* = 17; xlTable9* = 18; xlTable10* = 19; xlPTClassic* = 20; xlPTNone* = 21; (* XlCmdType *) xlCmdCube* = 1; xlCmdSql* = 2; xlCmdTable* = 3; xlCmdDefault* = 4; (* xlColumnDataType *) xlGeneralFormat* = 1; xlTextFormat* = 2; xlMDYFormat* = 3; xlDMYFormat* = 4; xlYMDFormat* = 5; xlMYDFormat* = 6; xlDYMFormat* = 7; xlYDMFormat* = 8; xlSkipColumn* = 9; xlEMDFormat* = 10; (* xlQueryType *) xlODBCQuery* = 1; xlDAORecordSet* = 2; xlWebQuery* = 4; xlOLEDBQuery* = 5; xlTextImport* = 6; xlADORecordset* = 7; (* xlWebSelectionType *) xlEntirePage* = 1; xlAllTables* = 2; xlSpecifiedTables* = 3; (* XlCubeFieldType *) xlHierarchy* = 1; xlMeasure* = 2; (* xlWebFormatting *) xlWebFormattingAll* = 1; xlWebFormattingRTF* = 2; xlWebFormattingNone* = 3; (* xlDisplayDrawingObjects *) xlDisplayShapes* = -4104; xlHide* = 3; xlPlaceholders* = 2; (* xLSubtototalLocationType *) xlAtTop* = 1; xlAtBottom* = 2; TYPE Constants* = INTEGER; XlCreator* = INTEGER; XlChartGallery* = INTEGER; XlColorIndex* = INTEGER; XlEndStyleCap* = INTEGER; XlRowCol* = INTEGER; XlScaleType* = INTEGER; XlDataSeriesType* = INTEGER; XlAxisCrosses* = INTEGER; XlAxisGroup* = INTEGER; XlBackground* = INTEGER; XlWindowState* = INTEGER; XlAxisType* = INTEGER; XlArrowHeadLength* = INTEGER; XlVAlign* = INTEGER; XlTickMark* = INTEGER; XlErrorBarDirection* = INTEGER; XlErrorBarInclude* = INTEGER; XlDisplayBlanksAs* = INTEGER; XlArrowHeadStyle* = INTEGER; XlArrowHeadWidth* = INTEGER; XlHAlign* = INTEGER; XlTickLabelPosition* = INTEGER; XlLegendPosition* = INTEGER; XlChartPictureType* = INTEGER; XlChartPicturePlacement* = INTEGER; XlOrientation* = INTEGER; XlTickLabelOrientation* = INTEGER; XlBorderWeight* = INTEGER; XlDataSeriesDate* = INTEGER; XlUnderlineStyle* = INTEGER; XlErrorBarType* = INTEGER; XlTrendlineType* = INTEGER; XlLineStyle* = INTEGER; XlDataLabelsType* = INTEGER; XlMarkerStyle* = INTEGER; XlPictureConvertorType* = INTEGER; XlPattern* = INTEGER; XlChartSplitType* = INTEGER; XlDisplayUnit* = INTEGER; XlDataLabelPosition* = INTEGER; XlTimeUnit* = INTEGER; XlCategoryType* = INTEGER; XlBarShape* = INTEGER; XlChartType* = INTEGER; XlChartItem* = INTEGER; XlSizeRepresents* = INTEGER; XlInsertShiftDirection* = INTEGER; XlDeleteShiftDirection* = INTEGER; XlDirection* = INTEGER; XlConsolidationFunction* = INTEGER; XlSheetType* = INTEGER; XlLocationInTable* = INTEGER; XlFindLookIn* = INTEGER; XlWindowType* = INTEGER; XlPivotFieldDataType* = INTEGER; XlCopyPictureFormat* = INTEGER; XlPivotTableSourceType* = INTEGER; XlReferenceStyle* = INTEGER; xlPivotFormatType* = INTEGER; XlCmdType* = INTEGER; xlColumnDataType* = INTEGER; xlQueryType* = INTEGER; xlWebSelectionType* = INTEGER; XlCubeFieldType* = INTEGER; xlWebFormatting* = INTEGER; xlDisplayDrawingObjects* = INTEGER; xLSubtototalLocationType* = INTEGER; Font* = POINTER TO RECORD (CtlT.Object) END; _Global* = POINTER TO RECORD (CtlT.Object) END; Chart* = POINTER TO RECORD (CtlT.Object) END; Application* = POINTER TO RECORD (CtlT.Object) END; DataSheet* = POINTER TO RECORD (CtlT.Object) END; Range* = POINTER TO RECORD (CtlT.Object) END; AutoCorrect* = POINTER TO RECORD (CtlT.Object) END; Border* = POINTER TO RECORD (CtlT.Object) END; Interior* = POINTER TO RECORD (CtlT.Object) END; ChartFillFormat* = POINTER TO RECORD (CtlT.Object) END; ChartColorFormat* = POINTER TO RECORD (CtlT.Object) END; Axis* = POINTER TO RECORD (CtlT.Object) END; ChartTitle* = POINTER TO RECORD (CtlT.Object) END; AxisTitle* = POINTER TO RECORD (CtlT.Object) END; ChartGroup* = POINTER TO RECORD (CtlT.Object) END; ChartGroups* = POINTER TO RECORD (CtlT.Object) END; Axes* = POINTER TO RECORD (CtlT.Object) END; Points* = POINTER TO RECORD (CtlT.Object) END; Point* = POINTER TO RECORD (CtlT.Object) END; Series* = POINTER TO RECORD (CtlT.Object) END; SeriesCollection* = POINTER TO RECORD (CtlT.Object) END; DataLabel* = POINTER TO RECORD (CtlT.Object) END; DataLabels* = POINTER TO RECORD (CtlT.Object) END; LegendEntry* = POINTER TO RECORD (CtlT.Object) END; LegendEntries* = POINTER TO RECORD (CtlT.Object) END; LegendKey* = POINTER TO RECORD (CtlT.Object) END; Trendlines* = POINTER TO RECORD (CtlT.Object) END; Trendline* = POINTER TO RECORD (CtlT.Object) END; Corners* = POINTER TO RECORD (CtlT.Object) END; SeriesLines* = POINTER TO RECORD (CtlT.Object) END; HiLoLines* = POINTER TO RECORD (CtlT.Object) END; Gridlines* = POINTER TO RECORD (CtlT.Object) END; DropLines* = POINTER TO RECORD (CtlT.Object) END; LeaderLines* = POINTER TO RECORD (CtlT.Object) END; UpBars* = POINTER TO RECORD (CtlT.Object) END; DownBars* = POINTER TO RECORD (CtlT.Object) END; Floor* = POINTER TO RECORD (CtlT.Object) END; Walls* = POINTER TO RECORD (CtlT.Object) END; TickLabels* = POINTER TO RECORD (CtlT.Object) END; PlotArea* = POINTER TO RECORD (CtlT.Object) END; ChartArea* = POINTER TO RECORD (CtlT.Object) END; Legend* = POINTER TO RECORD (CtlT.Object) END; ErrorBars* = POINTER TO RECORD (CtlT.Object) END; DataTable* = POINTER TO RECORD (CtlT.Object) END; DisplayUnitLabel* = POINTER TO RECORD (CtlT.Object) END; Global* = _Global; PROCEDURE ThisFont* (v: CtlT.Any): Font; VAR new: Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFont; PROCEDURE IsFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F3-0000-0000-C000-000000000046}") END IsFont; PROCEDURE This_Global* (v: CtlT.Any): _Global; VAR new: _Global; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208FC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Global; PROCEDURE Is_Global* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208FC-0000-0000-C000-000000000046}") END Is_Global; PROCEDURE ThisChart* (v: CtlT.Any): Chart; VAR new: Chart; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208FB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChart; PROCEDURE IsChart* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208FB-0000-0000-C000-000000000046}") END IsChart; PROCEDURE ThisApplication* (v: CtlT.Any): Application; VAR new: Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208EC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisApplication; PROCEDURE IsApplication* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208EC-0000-0000-C000-000000000046}") END IsApplication; PROCEDURE ThisDataSheet* (v: CtlT.Any): DataSheet; VAR new: DataSheet; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024726-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataSheet; PROCEDURE IsDataSheet* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024726-0000-0000-C000-000000000046}") END IsDataSheet; PROCEDURE ThisRange* (v: CtlT.Any): Range; VAR new: Range; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024727-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRange; PROCEDURE IsRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024727-0000-0000-C000-000000000046}") END IsRange; PROCEDURE ThisAutoCorrect* (v: CtlT.Any): AutoCorrect; VAR new: AutoCorrect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCorrect; PROCEDURE IsAutoCorrect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D4-0000-0000-C000-000000000046}") END IsAutoCorrect; PROCEDURE ThisBorder* (v: CtlT.Any): Border; VAR new: Border; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208EE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBorder; PROCEDURE IsBorder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208EE-0000-0000-C000-000000000046}") END IsBorder; PROCEDURE ThisInterior* (v: CtlT.Any): Interior; VAR new: Interior; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208ED-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisInterior; PROCEDURE IsInterior* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208ED-0000-0000-C000-000000000046}") END IsInterior; PROCEDURE ThisChartFillFormat* (v: CtlT.Any): ChartFillFormat; VAR new: ChartFillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartFillFormat; PROCEDURE IsChartFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441C-0000-0000-C000-000000000046}") END IsChartFillFormat; PROCEDURE ThisChartColorFormat* (v: CtlT.Any): ChartColorFormat; VAR new: ChartColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartColorFormat; PROCEDURE IsChartColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441D-0000-0000-C000-000000000046}") END IsChartColorFormat; PROCEDURE ThisAxis* (v: CtlT.Any): Axis; VAR new: Axis; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxis; PROCEDURE IsAxis* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F9-0000-0000-C000-000000000046}") END IsAxis; PROCEDURE ThisChartTitle* (v: CtlT.Any): ChartTitle; VAR new: ChartTitle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartTitle; PROCEDURE IsChartTitle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F8-0000-0000-C000-000000000046}") END IsChartTitle; PROCEDURE ThisAxisTitle* (v: CtlT.Any): AxisTitle; VAR new: AxisTitle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxisTitle; PROCEDURE IsAxisTitle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F7-0000-0000-C000-000000000046}") END IsAxisTitle; PROCEDURE ThisChartGroup* (v: CtlT.Any): ChartGroup; VAR new: ChartGroup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartGroup; PROCEDURE IsChartGroup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F6-0000-0000-C000-000000000046}") END IsChartGroup; PROCEDURE ThisChartGroups* (v: CtlT.Any): ChartGroups; VAR new: ChartGroups; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartGroups; PROCEDURE IsChartGroups* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F5-0000-0000-C000-000000000046}") END IsChartGroups; PROCEDURE ThisAxes* (v: CtlT.Any): Axes; VAR new: Axes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAxes; PROCEDURE IsAxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F4-0000-0000-C000-000000000046}") END IsAxes; PROCEDURE ThisPoints* (v: CtlT.Any): Points; VAR new: Points; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPoints; PROCEDURE IsPoints* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F2-0000-0000-C000-000000000046}") END IsPoints; PROCEDURE ThisPoint* (v: CtlT.Any): Point; VAR new: Point; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPoint; PROCEDURE IsPoint* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F1-0000-0000-C000-000000000046}") END IsPoint; PROCEDURE ThisSeries* (v: CtlT.Any): Series; VAR new: Series; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208F0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeries; PROCEDURE IsSeries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208F0-0000-0000-C000-000000000046}") END IsSeries; PROCEDURE ThisSeriesCollection* (v: CtlT.Any): SeriesCollection; VAR new: SeriesCollection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208EF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeriesCollection; PROCEDURE IsSeriesCollection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208EF-0000-0000-C000-000000000046}") END IsSeriesCollection; PROCEDURE ThisDataLabel* (v: CtlT.Any): DataLabel; VAR new: DataLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataLabel; PROCEDURE IsDataLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E9-0000-0000-C000-000000000046}") END IsDataLabel; PROCEDURE ThisDataLabels* (v: CtlT.Any): DataLabels; VAR new: DataLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataLabels; PROCEDURE IsDataLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E8-0000-0000-C000-000000000046}") END IsDataLabels; PROCEDURE ThisLegendEntry* (v: CtlT.Any): LegendEntry; VAR new: LegendEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendEntry; PROCEDURE IsLegendEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E7-0000-0000-C000-000000000046}") END IsLegendEntry; PROCEDURE ThisLegendEntries* (v: CtlT.Any): LegendEntries; VAR new: LegendEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendEntries; PROCEDURE IsLegendEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E6-0000-0000-C000-000000000046}") END IsLegendEntries; PROCEDURE ThisLegendKey* (v: CtlT.Any): LegendKey; VAR new: LegendKey; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegendKey; PROCEDURE IsLegendKey* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E5-0000-0000-C000-000000000046}") END IsLegendKey; PROCEDURE ThisTrendlines* (v: CtlT.Any): Trendlines; VAR new: Trendlines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTrendlines; PROCEDURE IsTrendlines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E4-0000-0000-C000-000000000046}") END IsTrendlines; PROCEDURE ThisTrendline* (v: CtlT.Any): Trendline; VAR new: Trendline; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTrendline; PROCEDURE IsTrendline* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E3-0000-0000-C000-000000000046}") END IsTrendline; PROCEDURE ThisCorners* (v: CtlT.Any): Corners; VAR new: Corners; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCorners; PROCEDURE IsCorners* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E2-0000-0000-C000-000000000046}") END IsCorners; PROCEDURE ThisSeriesLines* (v: CtlT.Any): SeriesLines; VAR new: SeriesLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSeriesLines; PROCEDURE IsSeriesLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E1-0000-0000-C000-000000000046}") END IsSeriesLines; PROCEDURE ThisHiLoLines* (v: CtlT.Any): HiLoLines; VAR new: HiLoLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208E0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHiLoLines; PROCEDURE IsHiLoLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208E0-0000-0000-C000-000000000046}") END IsHiLoLines; PROCEDURE ThisGridlines* (v: CtlT.Any): Gridlines; VAR new: Gridlines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024700-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGridlines; PROCEDURE IsGridlines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024700-0000-0000-C000-000000000046}") END IsGridlines; PROCEDURE ThisDropLines* (v: CtlT.Any): DropLines; VAR new: DropLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024701-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropLines; PROCEDURE IsDropLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024701-0000-0000-C000-000000000046}") END IsDropLines; PROCEDURE ThisLeaderLines* (v: CtlT.Any): LeaderLines; VAR new: LeaderLines; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002441E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLeaderLines; PROCEDURE IsLeaderLines* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002441E-0000-0000-C000-000000000046}") END IsLeaderLines; PROCEDURE ThisUpBars* (v: CtlT.Any): UpBars; VAR new: UpBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024702-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisUpBars; PROCEDURE IsUpBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024702-0000-0000-C000-000000000046}") END IsUpBars; PROCEDURE ThisDownBars* (v: CtlT.Any): DownBars; VAR new: DownBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024703-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDownBars; PROCEDURE IsDownBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024703-0000-0000-C000-000000000046}") END IsDownBars; PROCEDURE ThisFloor* (v: CtlT.Any): Floor; VAR new: Floor; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024704-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFloor; PROCEDURE IsFloor* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024704-0000-0000-C000-000000000046}") END IsFloor; PROCEDURE ThisWalls* (v: CtlT.Any): Walls; VAR new: Walls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024705-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWalls; PROCEDURE IsWalls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024705-0000-0000-C000-000000000046}") END IsWalls; PROCEDURE ThisTickLabels* (v: CtlT.Any): TickLabels; VAR new: TickLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024706-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTickLabels; PROCEDURE IsTickLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024706-0000-0000-C000-000000000046}") END IsTickLabels; PROCEDURE ThisPlotArea* (v: CtlT.Any): PlotArea; VAR new: PlotArea; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024707-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPlotArea; PROCEDURE IsPlotArea* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024707-0000-0000-C000-000000000046}") END IsPlotArea; PROCEDURE ThisChartArea* (v: CtlT.Any): ChartArea; VAR new: ChartArea; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024708-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisChartArea; PROCEDURE IsChartArea* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024708-0000-0000-C000-000000000046}") END IsChartArea; PROCEDURE ThisLegend* (v: CtlT.Any): Legend; VAR new: Legend; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00024709-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLegend; PROCEDURE IsLegend* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00024709-0000-0000-C000-000000000046}") END IsLegend; PROCEDURE ThisErrorBars* (v: CtlT.Any): ErrorBars; VAR new: ErrorBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002470A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisErrorBars; PROCEDURE IsErrorBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002470A-0000-0000-C000-000000000046}") END IsErrorBars; PROCEDURE ThisDataTable* (v: CtlT.Any): DataTable; VAR new: DataTable; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208FA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDataTable; PROCEDURE IsDataTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208FA-0000-0000-C000-000000000046}") END IsDataTable; PROCEDURE ThisDisplayUnitLabel* (v: CtlT.Any): DisplayUnitLabel; VAR new: DisplayUnitLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000208D3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDisplayUnitLabel; PROCEDURE IsDisplayUnitLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000208D3-0000-0000-C000-000000000046}") END IsDisplayUnitLabel; (* ---------- Font ---------- *) PROCEDURE (this: Font) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Font) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Font) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Font) Background* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 180) END Background; PROCEDURE (this: Font) PUTBackground* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 180, p1) END PUTBackground; PROCEDURE (this: Font) Bold* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 96) END Bold; PROCEDURE (this: Font) PUTBold* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 96, p1) END PUTBold; PROCEDURE (this: Font) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Font) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Font) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Font) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Font) FontStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 177) END FontStyle; PROCEDURE (this: Font) PUTFontStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 177, p1) END PUTFontStyle; PROCEDURE (this: Font) Italic* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Italic; PROCEDURE (this: Font) PUTItalic* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 101, p1) END PUTItalic; PROCEDURE (this: Font) Name* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 110) END Name; PROCEDURE (this: Font) PUTName* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 110, p1) END PUTName; PROCEDURE (this: Font) OutlineFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 221) END OutlineFont; PROCEDURE (this: Font) PUTOutlineFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 221, p1) END PUTOutlineFont; PROCEDURE (this: Font) Shadow* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 103) END Shadow; PROCEDURE (this: Font) PUTShadow* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 103, p1) END PUTShadow; PROCEDURE (this: Font) Size* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 104) END Size; PROCEDURE (this: Font) PUTSize* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 104, p1) END PUTSize; PROCEDURE (this: Font) Strikethrough* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 105) END Strikethrough; PROCEDURE (this: Font) PUTStrikethrough* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 105, p1) END PUTStrikethrough; PROCEDURE (this: Font) Subscript* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 179) END Subscript; PROCEDURE (this: Font) PUTSubscript* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 179, p1) END PUTSubscript; PROCEDURE (this: Font) Superscript* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 178) END Superscript; PROCEDURE (this: Font) PUTSuperscript* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 178, p1) END PUTSuperscript; PROCEDURE (this: Font) Underline* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 106) END Underline; PROCEDURE (this: Font) PUTUnderline* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 106, p1) END PUTUnderline; (* ---------- _Global, hidden ---------- *) PROCEDURE (this: _Global) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: _Global) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: _Global) Parent* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: _Global) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.ThisCommandBars(CtlC.GetAny(this, 1439)) END CommandBars; (* ---------- Chart ---------- *) PROCEDURE (this: Chart) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Chart) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Chart) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Chart) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: Chart) ApplyDataLabels* ((* optional *) Type: CtlT.Any; LegendKey: CtlT.Any; AutoText: CtlT.Any; HasLeaderLines: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[3]); CtlC.AnyVar(LegendKey, arg[2]); CtlC.AnyVar(AutoText, arg[1]); CtlC.AnyVar(HasLeaderLines, arg[0]); CtlC.CallParMethod(this, 151, arg, NIL); END ApplyDataLabels; PROCEDURE (this: Chart) Area3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 17)) END Area3DGroup; PROCEDURE (this: Chart) AreaGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 9, arg, ret); RETURN CtlC.VarObj(ret) END AreaGroups; PROCEDURE (this: Chart) AutoFormat* (Gallery: INTEGER; (* optional *) Format: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Gallery, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 114, arg, NIL); END AutoFormat; PROCEDURE (this: Chart) AutoScaling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 107) END AutoScaling; PROCEDURE (this: Chart) PUTAutoScaling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 107, p1) END PUTAutoScaling; PROCEDURE (this: Chart) Axes* ((* optional *) Type: CtlT.Any; AxisGroup: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[1]); CtlC.AnyVar(AxisGroup, arg[0]); CtlC.CallParMethod(this, 23, arg, ret); RETURN CtlC.VarObj(ret) END Axes; PROCEDURE (this: Chart) Bar3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 18)) END Bar3DGroup; PROCEDURE (this: Chart) BarGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN CtlC.VarObj(ret) END BarGroups; PROCEDURE (this: Chart) ChartArea* (): ChartArea, NEW; BEGIN RETURN ThisChartArea(CtlC.GetAny(this, 80)) END ChartArea; PROCEDURE (this: Chart) ChartGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 8, arg, ret); RETURN CtlC.VarObj(ret) END ChartGroups; PROCEDURE (this: Chart) ChartTitle* (): ChartTitle, NEW; BEGIN RETURN ThisChartTitle(CtlC.GetAny(this, 81)) END ChartTitle; PROCEDURE (this: Chart) Column3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 19)) END Column3DGroup; PROCEDURE (this: Chart) ColumnGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN CtlC.VarObj(ret) END ColumnGroups; PROCEDURE (this: Chart) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.ThisCommandBars(CtlC.GetAny(this, 1439)) END CommandBars; PROCEDURE (this: Chart) Corners* (): Corners, NEW; BEGIN RETURN ThisCorners(CtlC.GetAny(this, 79)) END Corners; PROCEDURE (this: Chart) DataTable* (): DataTable, NEW; BEGIN RETURN ThisDataTable(CtlC.GetAny(this, 1395)) END DataTable; PROCEDURE (this: Chart) DepthPercent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 48) END DepthPercent; PROCEDURE (this: Chart) PUTDepthPercent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 48, p1) END PUTDepthPercent; PROCEDURE (this: Chart) Deselect* (), NEW; BEGIN CtlC.CallMethod(this, 1120, NIL); END Deselect; PROCEDURE (this: Chart) DisplayBlanksAs* (): XlDisplayBlanksAs, NEW; BEGIN RETURN CtlC.GetInt(this, 93) END DisplayBlanksAs; PROCEDURE (this: Chart) PUTDisplayBlanksAs* (p1: XlDisplayBlanksAs), NEW; BEGIN CtlC.PutInt(this, 93, p1) END PUTDisplayBlanksAs; PROCEDURE (this: Chart) DoughnutGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN CtlC.VarObj(ret) END DoughnutGroups; PROCEDURE (this: Chart) Elevation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 49) END Elevation; PROCEDURE (this: Chart) PUTElevation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 49, p1) END PUTElevation; PROCEDURE (this: Chart) Floor* (): Floor, NEW; BEGIN RETURN ThisFloor(CtlC.GetAny(this, 83)) END Floor; PROCEDURE (this: Chart) GapDepth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 50) END GapDepth; PROCEDURE (this: Chart) PUTGapDepth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 50, p1) END PUTGapDepth; PROCEDURE (this: Chart) HasAxis* ((* optional *) Index1: CtlT.Any; Index2: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[1]); CtlC.AnyVar(Index2, arg[0]); CtlC.CallGetMethod(this, 52, arg, ret); RETURN CtlC.VarAny(ret) END HasAxis; PROCEDURE (this: Chart) PUTHasAxis* (Index1: CtlT.Any; (* optional *) Index2: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[2]); CtlC.AnyVar(Index2, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 52, arg, NIL); END PUTHasAxis; PROCEDURE (this: Chart) HasDataTable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1396) END HasDataTable; PROCEDURE (this: Chart) PUTHasDataTable* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1396, p1) END PUTHasDataTable; PROCEDURE (this: Chart) HasLegend* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 53) END HasLegend; PROCEDURE (this: Chart) PUTHasLegend* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 53, p1) END PUTHasLegend; PROCEDURE (this: Chart) HasTitle* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 54) END HasTitle; PROCEDURE (this: Chart) PUTHasTitle* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 54, p1) END PUTHasTitle; PROCEDURE (this: Chart) Height* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 123) END Height; PROCEDURE (this: Chart) PUTHeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 123, p1) END PUTHeight; PROCEDURE (this: Chart) HeightPercent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 55) END HeightPercent; PROCEDURE (this: Chart) PUTHeightPercent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 55, p1) END PUTHeightPercent; PROCEDURE (this: Chart) Left* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 127) END Left; PROCEDURE (this: Chart) PUTLeft* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 127, p1) END PUTLeft; PROCEDURE (this: Chart) Legend* (): Legend, NEW; BEGIN RETURN ThisLegend(CtlC.GetAny(this, 84)) END Legend; PROCEDURE (this: Chart) Line3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 20)) END Line3DGroup; PROCEDURE (this: Chart) LineGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN CtlC.VarObj(ret) END LineGroups; PROCEDURE (this: Chart) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Chart) OmitBackground* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1098, ret); RETURN CtlC.VarAny(ret) END OmitBackground; PROCEDURE (this: Chart) Perspective* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 57) END Perspective; PROCEDURE (this: Chart) PUTPerspective* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 57, p1) END PUTPerspective; PROCEDURE (this: Chart) Pie3DGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 21)) END Pie3DGroup; PROCEDURE (this: Chart) PieGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN CtlC.VarObj(ret) END PieGroups; PROCEDURE (this: Chart) PlotArea* (): PlotArea, NEW; BEGIN RETURN ThisPlotArea(CtlC.GetAny(this, 85)) END PlotArea; PROCEDURE (this: Chart) RadarGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN CtlC.VarObj(ret) END RadarGroups; PROCEDURE (this: Chart) RightAngleAxes* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 58) END RightAngleAxes; PROCEDURE (this: Chart) PUTRightAngleAxes* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 58, p1) END PUTRightAngleAxes; PROCEDURE (this: Chart) Rotation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 59) END Rotation; PROCEDURE (this: Chart) PUTRotation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 59, p1) END PUTRotation; PROCEDURE (this: Chart) SeriesCollection* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 68, arg, ret); RETURN CtlC.VarObj(ret) END SeriesCollection; PROCEDURE (this: Chart) SetEchoOn* ((* optional *) EchoOn: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(EchoOn, arg[0]); CtlC.CallParMethod(this, 1133, arg, ret); RETURN CtlC.VarAny(ret) END SetEchoOn; PROCEDURE (this: Chart) SubType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 109) END SubType; PROCEDURE (this: Chart) PUTSubType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 109, p1) END PUTSubType; PROCEDURE (this: Chart) SurfaceGroup* (): ChartGroup, NEW; BEGIN RETURN ThisChartGroup(CtlC.GetAny(this, 22)) END SurfaceGroup; PROCEDURE (this: Chart) Top* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Top; PROCEDURE (this: Chart) PUTTop* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 126, p1) END PUTTop; PROCEDURE (this: Chart) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Chart) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: Chart) ChartType* (): XlChartType, NEW; BEGIN RETURN CtlC.GetInt(this, 1400) END ChartType; PROCEDURE (this: Chart) PUTChartType* (p1: XlChartType), NEW; BEGIN CtlC.PutInt(this, 1400, p1) END PUTChartType; PROCEDURE (this: Chart) ApplyCustomType* (ChartType: XlChartType; (* optional *) TypeName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(ChartType, arg[1]); CtlC.AnyVar(TypeName, arg[0]); CtlC.CallParMethod(this, 1401, arg, NIL); END ApplyCustomType; PROCEDURE (this: Chart) Walls* (): Walls, NEW; BEGIN RETURN ThisWalls(CtlC.GetAny(this, 86)) END Walls; PROCEDURE (this: Chart) WallsAndGridlines2D* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 210) END WallsAndGridlines2D; PROCEDURE (this: Chart) PUTWallsAndGridlines2D* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 210, p1) END PUTWallsAndGridlines2D; PROCEDURE (this: Chart) Width* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 122) END Width; PROCEDURE (this: Chart) PUTWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 122, p1) END PUTWidth; PROCEDURE (this: Chart) XYGroups* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN CtlC.VarObj(ret) END XYGroups; PROCEDURE (this: Chart) BarShape* (): XlBarShape, NEW; BEGIN RETURN CtlC.GetInt(this, 1403) END BarShape; PROCEDURE (this: Chart) PUTBarShape* (p1: XlBarShape), NEW; BEGIN CtlC.PutInt(this, 1403, p1) END PUTBarShape; PROCEDURE (this: Chart) Export* (FileName: ARRAY OF CHAR; (* optional *) FilterName: CtlT.Any; Interactive: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.AnyVar(FilterName, arg[1]); CtlC.AnyVar(Interactive, arg[0]); CtlC.CallParMethod(this, 1414, arg, ret); RETURN CtlC.VarBool(ret) END Export; PROCEDURE (this: Chart) Refresh* (), NEW; BEGIN CtlC.CallMethod(this, 1417, NIL); END Refresh; PROCEDURE (this: Chart) PlotOnX* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1775) END PlotOnX; PROCEDURE (this: Chart) PUTPlotOnX* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1775, p1) END PUTPlotOnX; (* ---------- Application ---------- *) PROCEDURE (this: Application) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Application) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Application) Parent* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 150)) END Parent; PROCEDURE (this: Application) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.ThisCommandBars(CtlC.GetAny(this, 1439)) END CommandBars; PROCEDURE (this: Application) AddChartAutoFormat* (Name: ARRAY OF CHAR; (* optional *) Description: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Description, arg[0]); CtlC.CallParMethod(this, 216, arg, NIL); END AddChartAutoFormat; PROCEDURE (this: Application) CellDragAndDrop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 320) END CellDragAndDrop; PROCEDURE (this: Application) PUTCellDragAndDrop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 320, p1) END PUTCellDragAndDrop; PROCEDURE (this: Application) Chart* (): Chart, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 7, ret); RETURN ThisChart(CtlC.VarAny(ret)) END Chart; PROCEDURE (this: Application) ChartWizardDisplay* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1129) END ChartWizardDisplay; PROCEDURE (this: Application) PUTChartWizardDisplay* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1129, p1) END PUTChartWizardDisplay; PROCEDURE (this: Application) DataSheet* (): DataSheet, NEW; BEGIN RETURN ThisDataSheet(CtlC.GetAny(this, 1101)) END DataSheet; PROCEDURE (this: Application) PUTREFDataSheet* (p1: DataSheet), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 1101, arg, NIL); END PUTREFDataSheet; PROCEDURE (this: Application) DeleteChartAutoFormat* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 217, arg, NIL); END DeleteChartAutoFormat; PROCEDURE (this: Application) DisplayAlerts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 343) END DisplayAlerts; PROCEDURE (this: Application) PUTDisplayAlerts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 343, p1) END PUTDisplayAlerts; PROCEDURE (this: Application) Evaluate* (Name: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN CtlC.VarAny(ret) END Evaluate; PROCEDURE (this: Application) FileImport* (FileName: ARRAY OF CHAR; (* optional *) Password: CtlT.Any; ImportRange: CtlT.Any; WorksheetName: CtlT.Any; OverwriteCells: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[4]); CtlC.AnyVar(Password, arg[3]); CtlC.AnyVar(ImportRange, arg[2]); CtlC.AnyVar(WorksheetName, arg[1]); CtlC.AnyVar(OverwriteCells, arg[0]); CtlC.CallParMethod(this, 1191, arg, NIL); END FileImport; PROCEDURE (this: Application) HasLinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1094) END HasLinks; PROCEDURE (this: Application) PUTHasLinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1094, p1) END PUTHasLinks; PROCEDURE (this: Application) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Application) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Application) ImportChart* (FileName: ARRAY OF CHAR; (* optional *) Password: CtlT.Any; ImportRange: CtlT.Any; WorksheetName: CtlT.Any; OverwriteCells: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[4]); CtlC.AnyVar(Password, arg[3]); CtlC.AnyVar(ImportRange, arg[2]); CtlC.AnyVar(WorksheetName, arg[1]); CtlC.AnyVar(OverwriteCells, arg[0]); CtlC.CallParMethod(this, 1099, arg, NIL); END ImportChart; PROCEDURE (this: Application) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Application) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Application) MoveAfterReturn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 374) END MoveAfterReturn; PROCEDURE (this: Application) PUTMoveAfterReturn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 374, p1) END PUTMoveAfterReturn; PROCEDURE (this: Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Application) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Application) PlotBy* (): XlRowCol, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END PlotBy; PROCEDURE (this: Application) PUTPlotBy* (p1: XlRowCol), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTPlotBy; PROCEDURE (this: Application) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END Quit; PROCEDURE (this: Application) SaveAs* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 284, arg, NIL); END SaveAs; PROCEDURE (this: Application) SaveAsOldFileFormat* ((* optional *) MajorVersion: CtlT.Any; MinorVersion: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(MajorVersion, arg[1]); CtlC.AnyVar(MinorVersion, arg[0]); CtlC.CallParMethod(this, 1091, arg, NIL); END SaveAsOldFileFormat; PROCEDURE (this: Application) SetDefaultChart* ((* optional *) FormatName: CtlT.Any; Gallery: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FormatName, arg[1]); CtlC.AnyVar(Gallery, arg[0]); CtlC.CallParMethod(this, 219, arg, NIL); END SetDefaultChart; PROCEDURE (this: Application) ShowChartTipNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1207) END ShowChartTipNames; PROCEDURE (this: Application) PUTShowChartTipNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1207, p1) END PUTShowChartTipNames; PROCEDURE (this: Application) ShowChartTipValues* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1208) END ShowChartTipValues; PROCEDURE (this: Application) PUTShowChartTipValues* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1208, p1) END PUTShowChartTipValues; PROCEDURE (this: Application) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Application) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Application) Update* (), NEW; BEGIN CtlC.CallMethod(this, 680, NIL); END Update; PROCEDURE (this: Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 392) END Version; PROCEDURE (this: Application) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 558) END Visible; PROCEDURE (this: Application) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 558, p1) END PUTVisible; PROCEDURE (this: Application) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Application) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Application) WindowState* (): XlWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 396) END WindowState; PROCEDURE (this: Application) PUTWindowState* (p1: XlWindowState), NEW; BEGIN CtlC.PutInt(this, 396, p1) END PUTWindowState; PROCEDURE (this: Application) AutoCorrect* (): AutoCorrect, NEW; BEGIN RETURN ThisAutoCorrect(CtlC.GetAny(this, 1145)) END AutoCorrect; (* ---------- DataSheet ---------- *) PROCEDURE (this: DataSheet) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataSheet) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataSheet) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataSheet) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 304, NIL); END Activate; PROCEDURE (this: DataSheet) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: DataSheet) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: DataSheet) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataSheet) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 146, arg, NIL); END PUTREFFont; PROCEDURE (this: DataSheet) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: DataSheet) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: DataSheet) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DataSheet) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DataSheet) Range* (Range1: CtlT.Any; (* optional *) Range2: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Range1, arg[1]); CtlC.AnyVar(Range2, arg[0]); CtlC.CallGetMethod(this, 197, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: DataSheet) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: DataSheet) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DataSheet) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DataSheet) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: DataSheet) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; (* ---------- Range ---------- *) PROCEDURE (this: Range) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Range) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Range) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Range) AutoFit* (), NEW; BEGIN CtlC.CallMethod(this, 237, NIL); END AutoFit; PROCEDURE (this: Range) Cells* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 238)) END Cells; PROCEDURE (this: Range) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 111, NIL); END Clear; PROCEDURE (this: Range) ClearContents* (), NEW; BEGIN CtlC.CallMethod(this, 113, NIL); END ClearContents; PROCEDURE (this: Range) ClearFormats* (), NEW; BEGIN CtlC.CallMethod(this, 112, NIL); END ClearFormats; PROCEDURE (this: Range) Columns* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 241)) END Columns; PROCEDURE (this: Range) ColumnWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 242) END ColumnWidth; PROCEDURE (this: Range) PUTColumnWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 242, p1) END PUTColumnWidth; PROCEDURE (this: Range) Copy* ((* optional *) Destination: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[0]); CtlC.CallParMethod(this, 551, arg, NIL); END Copy; PROCEDURE (this: Range) Cut* ((* optional *) Destination: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Destination, arg[0]); CtlC.CallParMethod(this, 565, arg, NIL); END Cut; PROCEDURE (this: Range) Delete* ((* optional *) Shift: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Shift, arg[0]); CtlC.CallParMethod(this, 117, arg, NIL); END Delete; PROCEDURE (this: Range) ImportData* (FileName: CtlT.Any; (* optional *) Range: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 1100, arg, NIL); END ImportData; PROCEDURE (this: Range) Include* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 165) END Include; PROCEDURE (this: Range) PUTInclude* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 165, p1) END PUTInclude; PROCEDURE (this: Range) Insert* ((* optional *) Shift: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Shift, arg[0]); CtlC.CallParMethod(this, 252, arg, NIL); END Insert; PROCEDURE (this: Range) Item* ((* optional *) RowIndex: CtlT.Any; ColumnIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[1]); CtlC.AnyVar(ColumnIndex, arg[0]); CtlC.CallGetMethod(this, 170, arg, ret); RETURN CtlC.VarAny(ret) END Item; PROCEDURE (this: Range) PUTItem* (RowIndex: CtlT.Any; (* optional *) ColumnIndex: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[2]); CtlC.AnyVar(ColumnIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 170, arg, NIL); END PUTItem; PROCEDURE (this: Range) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Range) NumberFormat* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 193) END NumberFormat; PROCEDURE (this: Range) PUTNumberFormat* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: Range) Paste* ((* optional *) Link: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Link, arg[0]); CtlC.CallParMethod(this, 211, arg, NIL); END Paste; PROCEDURE (this: Range) Rows* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 258)) END Rows; PROCEDURE (this: Range) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 6) END Value; PROCEDURE (this: Range) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 6, p1) END PUTValue; PROCEDURE (this: Range) _Default* ((* optional *) RowIndex: CtlT.Any; ColumnIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[1]); CtlC.AnyVar(ColumnIndex, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarAny(ret) END _Default; PROCEDURE (this: Range) PUT_Default* (RowIndex: CtlT.Any; (* optional *) ColumnIndex: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowIndex, arg[2]); CtlC.AnyVar(ColumnIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUT_Default; (* ---------- AutoCorrect ---------- *) PROCEDURE (this: AutoCorrect) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AutoCorrect) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AutoCorrect) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AutoCorrect) AddReplacement* (What: ARRAY OF CHAR; Replacement: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(What, arg[1]); CtlC.StrVar(Replacement, arg[0]); CtlC.CallParMethod(this, 1146, arg, ret); RETURN CtlC.VarAny(ret) END AddReplacement; PROCEDURE (this: AutoCorrect) CapitalizeNamesOfDays* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1150) END CapitalizeNamesOfDays; PROCEDURE (this: AutoCorrect) PUTCapitalizeNamesOfDays* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1150, p1) END PUTCapitalizeNamesOfDays; PROCEDURE (this: AutoCorrect) DeleteReplacement* (What: ARRAY OF CHAR): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(What, arg[0]); CtlC.CallParMethod(this, 1147, arg, ret); RETURN CtlC.VarAny(ret) END DeleteReplacement; PROCEDURE (this: AutoCorrect) ReplacementList* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 1151, arg, ret); RETURN CtlC.VarAny(ret) END ReplacementList; PROCEDURE (this: AutoCorrect) PUTReplacementList* (Index: CtlT.Any; (* optional *) p2: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[1]); CtlC.AnyVar(p2, arg[0]); CtlC.CallPutMethod(this, 1151, arg, NIL); END PUTReplacementList; PROCEDURE (this: AutoCorrect) ReplaceText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1148) END ReplaceText; PROCEDURE (this: AutoCorrect) PUTReplaceText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1148, p1) END PUTReplaceText; PROCEDURE (this: AutoCorrect) TwoInitialCapitals* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1149) END TwoInitialCapitals; PROCEDURE (this: AutoCorrect) PUTTwoInitialCapitals* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1149, p1) END PUTTwoInitialCapitals; PROCEDURE (this: AutoCorrect) CorrectSentenceCap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1619) END CorrectSentenceCap; PROCEDURE (this: AutoCorrect) PUTCorrectSentenceCap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1619, p1) END PUTCorrectSentenceCap; PROCEDURE (this: AutoCorrect) CorrectCapsLock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1620) END CorrectCapsLock; PROCEDURE (this: AutoCorrect) PUTCorrectCapsLock* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1620, p1) END PUTCorrectCapsLock; (* ---------- Border ---------- *) PROCEDURE (this: Border) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Border) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Border) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Border) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Border) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Border) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Border) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Border) LineStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 119) END LineStyle; PROCEDURE (this: Border) PUTLineStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 119, p1) END PUTLineStyle; PROCEDURE (this: Border) Weight* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 120) END Weight; PROCEDURE (this: Border) PUTWeight* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 120, p1) END PUTWeight; (* ---------- Interior ---------- *) PROCEDURE (this: Interior) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Interior) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Interior) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Interior) Color* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 99) END Color; PROCEDURE (this: Interior) PUTColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 99, p1) END PUTColor; PROCEDURE (this: Interior) ColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 97) END ColorIndex; PROCEDURE (this: Interior) PUTColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 97, p1) END PUTColorIndex; PROCEDURE (this: Interior) InvertIfNegative* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 132) END InvertIfNegative; PROCEDURE (this: Interior) PUTInvertIfNegative* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Interior) Pattern* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 95) END Pattern; PROCEDURE (this: Interior) PUTPattern* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 95, p1) END PUTPattern; PROCEDURE (this: Interior) PatternColor* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END PatternColor; PROCEDURE (this: Interior) PUTPatternColor* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTPatternColor; PROCEDURE (this: Interior) PatternColorIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 98) END PatternColorIndex; PROCEDURE (this: Interior) PUTPatternColorIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 98, p1) END PUTPatternColorIndex; (* ---------- ChartFillFormat ---------- *) PROCEDURE (this: ChartFillFormat) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartFillFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartFillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartFillFormat) OneColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 1621, arg, NIL); END OneColorGradient; PROCEDURE (this: ChartFillFormat) TwoColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 1624, arg, NIL); END TwoColorGradient; PROCEDURE (this: ChartFillFormat) PresetTextured* (PresetTexture: CtlOffice.MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 1625, arg, NIL); END PresetTextured; PROCEDURE (this: ChartFillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 1627, NIL); END Solid; PROCEDURE (this: ChartFillFormat) Patterned* (Pattern: CtlOffice.MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 1628, arg, NIL); END Patterned; PROCEDURE (this: ChartFillFormat) UserPicture* ((* optional *) PictureFile: CtlT.Any; PictureFormat: CtlT.Any; PictureStackUnit: CtlT.Any; PicturePlacement: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(PictureFile, arg[3]); CtlC.AnyVar(PictureFormat, arg[2]); CtlC.AnyVar(PictureStackUnit, arg[1]); CtlC.AnyVar(PicturePlacement, arg[0]); CtlC.CallParMethod(this, 1629, arg, NIL); END UserPicture; PROCEDURE (this: ChartFillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 1634, arg, NIL); END UserTextured; PROCEDURE (this: ChartFillFormat) PresetGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; PresetGradientType: CtlOffice.MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 1636, arg, NIL); END PresetGradient; PROCEDURE (this: ChartFillFormat) BackColor* (): ChartColorFormat, NEW; BEGIN RETURN ThisChartColorFormat(CtlC.GetAny(this, 1638)) END BackColor; PROCEDURE (this: ChartFillFormat) ForeColor* (): ChartColorFormat, NEW; BEGIN RETURN ThisChartColorFormat(CtlC.GetAny(this, 1639)) END ForeColor; PROCEDURE (this: ChartFillFormat) GradientColorType* (): CtlOffice.MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 1640) END GradientColorType; PROCEDURE (this: ChartFillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1641) END GradientDegree; PROCEDURE (this: ChartFillFormat) GradientStyle* (): CtlOffice.MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 1642) END GradientStyle; PROCEDURE (this: ChartFillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1643) END GradientVariant; PROCEDURE (this: ChartFillFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 95) END Pattern; PROCEDURE (this: ChartFillFormat) PresetGradientType* (): CtlOffice.MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 1637) END PresetGradientType; PROCEDURE (this: ChartFillFormat) PresetTexture* (): CtlOffice.MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 1626) END PresetTexture; PROCEDURE (this: ChartFillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1644) END TextureName; PROCEDURE (this: ChartFillFormat) TextureType* (): CtlOffice.MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 1645) END TextureType; PROCEDURE (this: ChartFillFormat) Type* (): CtlOffice.MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ChartFillFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 558) END Visible; PROCEDURE (this: ChartFillFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 558, p1) END PUTVisible; (* ---------- ChartColorFormat ---------- *) PROCEDURE (this: ChartColorFormat) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartColorFormat) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartColorFormat) SchemeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1646) END SchemeColor; PROCEDURE (this: ChartColorFormat) PUTSchemeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1646, p1) END PUTSchemeColor; PROCEDURE (this: ChartColorFormat) RGB* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1055) END RGB; PROCEDURE (this: ChartColorFormat) _Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END _Default; PROCEDURE (this: ChartColorFormat) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; (* ---------- Axis ---------- *) PROCEDURE (this: Axis) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Axis) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Axis) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Axis) AxisBetweenCategories* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 45) END AxisBetweenCategories; PROCEDURE (this: Axis) PUTAxisBetweenCategories* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 45, p1) END PUTAxisBetweenCategories; PROCEDURE (this: Axis) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: Axis) AxisTitle* (): AxisTitle, NEW; BEGIN RETURN ThisAxisTitle(CtlC.GetAny(this, 82)) END AxisTitle; PROCEDURE (this: Axis) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Axis) Crosses* (): XlAxisCrosses, NEW; BEGIN RETURN CtlC.GetInt(this, 42) END Crosses; PROCEDURE (this: Axis) PUTCrosses* (p1: XlAxisCrosses), NEW; BEGIN CtlC.PutInt(this, 42, p1) END PUTCrosses; PROCEDURE (this: Axis) CrossesAt* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 43) END CrossesAt; PROCEDURE (this: Axis) PUTCrossesAt* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 43, p1) END PUTCrossesAt; PROCEDURE (this: Axis) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Axis) HasMajorGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END HasMajorGridlines; PROCEDURE (this: Axis) PUTHasMajorGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTHasMajorGridlines; PROCEDURE (this: Axis) HasMinorGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END HasMinorGridlines; PROCEDURE (this: Axis) PUTHasMinorGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTHasMinorGridlines; PROCEDURE (this: Axis) HasTitle* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 54) END HasTitle; PROCEDURE (this: Axis) PUTHasTitle* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 54, p1) END PUTHasTitle; PROCEDURE (this: Axis) MajorGridlines* (): Gridlines, NEW; BEGIN RETURN ThisGridlines(CtlC.GetAny(this, 89)) END MajorGridlines; PROCEDURE (this: Axis) MajorTickMark* (): XlTickMark, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END MajorTickMark; PROCEDURE (this: Axis) PUTMajorTickMark* (p1: XlTickMark), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTMajorTickMark; PROCEDURE (this: Axis) MajorUnit* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 37) END MajorUnit; PROCEDURE (this: Axis) PUTMajorUnit* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 37, p1) END PUTMajorUnit; PROCEDURE (this: Axis) MajorUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 38) END MajorUnitIsAuto; PROCEDURE (this: Axis) PUTMajorUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 38, p1) END PUTMajorUnitIsAuto; PROCEDURE (this: Axis) MaximumScale* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 35) END MaximumScale; PROCEDURE (this: Axis) PUTMaximumScale* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 35, p1) END PUTMaximumScale; PROCEDURE (this: Axis) MaximumScaleIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END MaximumScaleIsAuto; PROCEDURE (this: Axis) PUTMaximumScaleIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTMaximumScaleIsAuto; PROCEDURE (this: Axis) MinimumScale* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 33) END MinimumScale; PROCEDURE (this: Axis) PUTMinimumScale* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 33, p1) END PUTMinimumScale; PROCEDURE (this: Axis) MinimumScaleIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34) END MinimumScaleIsAuto; PROCEDURE (this: Axis) PUTMinimumScaleIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34, p1) END PUTMinimumScaleIsAuto; PROCEDURE (this: Axis) MinorGridlines* (): Gridlines, NEW; BEGIN RETURN ThisGridlines(CtlC.GetAny(this, 90)) END MinorGridlines; PROCEDURE (this: Axis) MinorTickMark* (): XlTickMark, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END MinorTickMark; PROCEDURE (this: Axis) PUTMinorTickMark* (p1: XlTickMark), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTMinorTickMark; PROCEDURE (this: Axis) MinorUnit* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 39) END MinorUnit; PROCEDURE (this: Axis) PUTMinorUnit* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 39, p1) END PUTMinorUnit; PROCEDURE (this: Axis) MinorUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 40) END MinorUnitIsAuto; PROCEDURE (this: Axis) PUTMinorUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 40, p1) END PUTMinorUnitIsAuto; PROCEDURE (this: Axis) ReversePlotOrder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 44) END ReversePlotOrder; PROCEDURE (this: Axis) PUTReversePlotOrder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 44, p1) END PUTReversePlotOrder; PROCEDURE (this: Axis) ScaleType* (): XlScaleType, NEW; BEGIN RETURN CtlC.GetInt(this, 41) END ScaleType; PROCEDURE (this: Axis) PUTScaleType* (p1: XlScaleType), NEW; BEGIN CtlC.PutInt(this, 41, p1) END PUTScaleType; PROCEDURE (this: Axis) TickLabelPosition* (): XlTickLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END TickLabelPosition; PROCEDURE (this: Axis) PUTTickLabelPosition* (p1: XlTickLabelPosition), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTTickLabelPosition; PROCEDURE (this: Axis) TickLabels* (): TickLabels, NEW; BEGIN RETURN ThisTickLabels(CtlC.GetAny(this, 91)) END TickLabels; PROCEDURE (this: Axis) TickLabelSpacing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 29) END TickLabelSpacing; PROCEDURE (this: Axis) PUTTickLabelSpacing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 29, p1) END PUTTickLabelSpacing; PROCEDURE (this: Axis) TickMarkSpacing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 31) END TickMarkSpacing; PROCEDURE (this: Axis) PUTTickMarkSpacing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 31, p1) END PUTTickMarkSpacing; PROCEDURE (this: Axis) Type* (): XlAxisType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Axis) PUTType* (p1: XlAxisType), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: Axis) BaseUnit* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1647) END BaseUnit; PROCEDURE (this: Axis) PUTBaseUnit* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1647, p1) END PUTBaseUnit; PROCEDURE (this: Axis) BaseUnitIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1648) END BaseUnitIsAuto; PROCEDURE (this: Axis) PUTBaseUnitIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1648, p1) END PUTBaseUnitIsAuto; PROCEDURE (this: Axis) MajorUnitScale* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1649) END MajorUnitScale; PROCEDURE (this: Axis) PUTMajorUnitScale* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1649, p1) END PUTMajorUnitScale; PROCEDURE (this: Axis) MinorUnitScale* (): XlTimeUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1650) END MinorUnitScale; PROCEDURE (this: Axis) PUTMinorUnitScale* (p1: XlTimeUnit), NEW; BEGIN CtlC.PutInt(this, 1650, p1) END PUTMinorUnitScale; PROCEDURE (this: Axis) CategoryType* (): XlCategoryType, NEW; BEGIN RETURN CtlC.GetInt(this, 1651) END CategoryType; PROCEDURE (this: Axis) PUTCategoryType* (p1: XlCategoryType), NEW; BEGIN CtlC.PutInt(this, 1651, p1) END PUTCategoryType; PROCEDURE (this: Axis) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Axis) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Axis) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Axis) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Axis) DisplayUnit* (): XlDisplayUnit, NEW; BEGIN RETURN CtlC.GetInt(this, 1779) END DisplayUnit; PROCEDURE (this: Axis) PUTDisplayUnit* (p1: XlDisplayUnit), NEW; BEGIN CtlC.PutInt(this, 1779, p1) END PUTDisplayUnit; PROCEDURE (this: Axis) DisplayUnitCustom* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1780) END DisplayUnitCustom; PROCEDURE (this: Axis) PUTDisplayUnitCustom* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 1780, p1) END PUTDisplayUnitCustom; PROCEDURE (this: Axis) HasDisplayUnitLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1781) END HasDisplayUnitLabel; PROCEDURE (this: Axis) PUTHasDisplayUnitLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1781, p1) END PUTHasDisplayUnitLabel; PROCEDURE (this: Axis) DisplayUnitLabel* (): DisplayUnitLabel, NEW; BEGIN RETURN ThisDisplayUnitLabel(CtlC.GetAny(this, 1782)) END DisplayUnitLabel; (* ---------- ChartTitle ---------- *) PROCEDURE (this: ChartTitle) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartTitle) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartTitle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartTitle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ChartTitle) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartTitle) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ChartTitle) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartTitle) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: ChartTitle) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: ChartTitle) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: ChartTitle) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: ChartTitle) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: ChartTitle) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: ChartTitle) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartTitle) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartTitle) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: ChartTitle) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: ChartTitle) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartTitle) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: ChartTitle) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: ChartTitle) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: ChartTitle) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartTitle) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartTitle) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: ChartTitle) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: ChartTitle) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: ChartTitle) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: ChartTitle) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: ChartTitle) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- AxisTitle ---------- *) PROCEDURE (this: AxisTitle) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: AxisTitle) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: AxisTitle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: AxisTitle) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: AxisTitle) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: AxisTitle) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: AxisTitle) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: AxisTitle) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: AxisTitle) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: AxisTitle) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: AxisTitle) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: AxisTitle) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: AxisTitle) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: AxisTitle) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: AxisTitle) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: AxisTitle) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: AxisTitle) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: AxisTitle) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: AxisTitle) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: AxisTitle) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: AxisTitle) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: AxisTitle) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: AxisTitle) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: AxisTitle) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: AxisTitle) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: AxisTitle) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: AxisTitle) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: AxisTitle) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: AxisTitle) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- ChartGroup ---------- *) PROCEDURE (this: ChartGroup) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartGroup) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartGroup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartGroup) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: ChartGroup) PUTAxisGroup* (p1: XlAxisGroup), NEW; BEGIN CtlC.PutInt(this, 47, p1) END PUTAxisGroup; PROCEDURE (this: ChartGroup) DoughnutHoleSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1126) END DoughnutHoleSize; PROCEDURE (this: ChartGroup) PUTDoughnutHoleSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1126, p1) END PUTDoughnutHoleSize; PROCEDURE (this: ChartGroup) DownBars* (): DownBars, NEW; BEGIN RETURN ThisDownBars(CtlC.GetAny(this, 141)) END DownBars; PROCEDURE (this: ChartGroup) DropLines* (): DropLines, NEW; BEGIN RETURN ThisDropLines(CtlC.GetAny(this, 142)) END DropLines; PROCEDURE (this: ChartGroup) FirstSliceAngle* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 63) END FirstSliceAngle; PROCEDURE (this: ChartGroup) PUTFirstSliceAngle* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 63, p1) END PUTFirstSliceAngle; PROCEDURE (this: ChartGroup) GapWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 51) END GapWidth; PROCEDURE (this: ChartGroup) PUTGapWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 51, p1) END PUTGapWidth; PROCEDURE (this: ChartGroup) HasDropLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61) END HasDropLines; PROCEDURE (this: ChartGroup) PUTHasDropLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61, p1) END PUTHasDropLines; PROCEDURE (this: ChartGroup) HasHiLoLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62) END HasHiLoLines; PROCEDURE (this: ChartGroup) PUTHasHiLoLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 62, p1) END PUTHasHiLoLines; PROCEDURE (this: ChartGroup) HasRadarAxisLabels* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 64) END HasRadarAxisLabels; PROCEDURE (this: ChartGroup) PUTHasRadarAxisLabels* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 64, p1) END PUTHasRadarAxisLabels; PROCEDURE (this: ChartGroup) HasSeriesLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 65) END HasSeriesLines; PROCEDURE (this: ChartGroup) PUTHasSeriesLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 65, p1) END PUTHasSeriesLines; PROCEDURE (this: ChartGroup) HasUpDownBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 66) END HasUpDownBars; PROCEDURE (this: ChartGroup) PUTHasUpDownBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 66, p1) END PUTHasUpDownBars; PROCEDURE (this: ChartGroup) HiLoLines* (): HiLoLines, NEW; BEGIN RETURN ThisHiLoLines(CtlC.GetAny(this, 143)) END HiLoLines; PROCEDURE (this: ChartGroup) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: ChartGroup) Overlap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 56) END Overlap; PROCEDURE (this: ChartGroup) PUTOverlap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 56, p1) END PUTOverlap; PROCEDURE (this: ChartGroup) RadarAxisLabels* (): TickLabels, NEW; BEGIN RETURN ThisTickLabels(CtlC.GetAny(this, 144)) END RadarAxisLabels; PROCEDURE (this: ChartGroup) SeriesCollection* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 68, arg, ret); RETURN CtlC.VarObj(ret) END SeriesCollection; PROCEDURE (this: ChartGroup) SeriesLines* (): SeriesLines, NEW; BEGIN RETURN ThisSeriesLines(CtlC.GetAny(this, 145)) END SeriesLines; PROCEDURE (this: ChartGroup) SubType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END SubType; PROCEDURE (this: ChartGroup) PUTSubType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTSubType; PROCEDURE (this: ChartGroup) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: ChartGroup) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: ChartGroup) UpBars* (): UpBars, NEW; BEGIN RETURN ThisUpBars(CtlC.GetAny(this, 140)) END UpBars; PROCEDURE (this: ChartGroup) VaryByCategories* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 60) END VaryByCategories; PROCEDURE (this: ChartGroup) PUTVaryByCategories* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 60, p1) END PUTVaryByCategories; PROCEDURE (this: ChartGroup) SizeRepresents* (): XlSizeRepresents, NEW; BEGIN RETURN CtlC.GetInt(this, 1652) END SizeRepresents; PROCEDURE (this: ChartGroup) PUTSizeRepresents* (p1: XlSizeRepresents), NEW; BEGIN CtlC.PutInt(this, 1652, p1) END PUTSizeRepresents; PROCEDURE (this: ChartGroup) BubbleScale* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1653) END BubbleScale; PROCEDURE (this: ChartGroup) PUTBubbleScale* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1653, p1) END PUTBubbleScale; PROCEDURE (this: ChartGroup) ShowNegativeBubbles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1654) END ShowNegativeBubbles; PROCEDURE (this: ChartGroup) PUTShowNegativeBubbles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1654, p1) END PUTShowNegativeBubbles; PROCEDURE (this: ChartGroup) SplitType* (): XlChartSplitType, NEW; BEGIN RETURN CtlC.GetInt(this, 1655) END SplitType; PROCEDURE (this: ChartGroup) PUTSplitType* (p1: XlChartSplitType), NEW; BEGIN CtlC.PutInt(this, 1655, p1) END PUTSplitType; PROCEDURE (this: ChartGroup) SplitValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1656) END SplitValue; PROCEDURE (this: ChartGroup) PUTSplitValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1656, p1) END PUTSplitValue; PROCEDURE (this: ChartGroup) SecondPlotSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1657) END SecondPlotSize; PROCEDURE (this: ChartGroup) PUTSecondPlotSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1657, p1) END PUTSecondPlotSize; PROCEDURE (this: ChartGroup) Has3DShading* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1658) END Has3DShading; PROCEDURE (this: ChartGroup) PUTHas3DShading* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1658, p1) END PUTHas3DShading; (* ---------- ChartGroups ---------- *) PROCEDURE (this: ChartGroups) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartGroups) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartGroups) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartGroups) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: ChartGroups) Item* (Index: CtlT.Any): ChartGroup, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisChartGroup(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ChartGroups) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Axes ---------- *) PROCEDURE (this: Axes) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Axes) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Axes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Axes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Axes) Item* (Type: XlAxisType; AxisGroup: XlAxisGroup): Axis, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.IntVar(AxisGroup, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisAxis(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Axes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Points ---------- *) PROCEDURE (this: Points) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Points) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Points) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Points) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Points) Item* (Index: INTEGER): Point, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisPoint(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Points) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Point ---------- *) PROCEDURE (this: Point) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Point) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Point) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Point) ApplyDataLabels* (Type: XlDataLabelsType; (* optional *) LegendKey: CtlT.Any; AutoText: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(LegendKey, arg[1]); CtlC.AnyVar(AutoText, arg[0]); CtlC.CallParMethod(this, 151, arg, ret); RETURN CtlC.VarAny(ret) END ApplyDataLabels; PROCEDURE (this: Point) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Point) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Point) DataLabel* (): DataLabel, NEW; BEGIN RETURN ThisDataLabel(CtlC.GetAny(this, 158)) END DataLabel; PROCEDURE (this: Point) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Point) Explosion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 182) END Explosion; PROCEDURE (this: Point) PUTExplosion* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 182, p1) END PUTExplosion; PROCEDURE (this: Point) HasDataLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 77) END HasDataLabel; PROCEDURE (this: Point) PUTHasDataLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 77, p1) END PUTHasDataLabel; PROCEDURE (this: Point) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Point) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: Point) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Point) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: Point) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: Point) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: Point) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: Point) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: Point) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: Point) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: Point) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: Point) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: Point) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: Point) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: Point) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: Point) PictureType* (): XlChartPictureType, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: Point) PUTPictureType* (p1: XlChartPictureType), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: Point) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: Point) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: Point) ApplyPictToSides* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1659) END ApplyPictToSides; PROCEDURE (this: Point) PUTApplyPictToSides* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1659, p1) END PUTApplyPictToSides; PROCEDURE (this: Point) ApplyPictToFront* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1660) END ApplyPictToFront; PROCEDURE (this: Point) PUTApplyPictToFront* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1660, p1) END PUTApplyPictToFront; PROCEDURE (this: Point) ApplyPictToEnd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1661) END ApplyPictToEnd; PROCEDURE (this: Point) PUTApplyPictToEnd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1661, p1) END PUTApplyPictToEnd; PROCEDURE (this: Point) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Point) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Point) SecondaryPlot* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1662) END SecondaryPlot; PROCEDURE (this: Point) PUTSecondaryPlot* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1662, p1) END PUTSecondaryPlot; PROCEDURE (this: Point) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- Series ---------- *) PROCEDURE (this: Series) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Series) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Series) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Series) ApplyDataLabels* (Type: XlDataLabelsType; (* optional *) LegendKey: CtlT.Any; AutoText: CtlT.Any; HasLeaderLines: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(LegendKey, arg[2]); CtlC.AnyVar(AutoText, arg[1]); CtlC.AnyVar(HasLeaderLines, arg[0]); CtlC.CallParMethod(this, 151, arg, ret); RETURN CtlC.VarAny(ret) END ApplyDataLabels; PROCEDURE (this: Series) AxisGroup* (): XlAxisGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 47) END AxisGroup; PROCEDURE (this: Series) PUTAxisGroup* (p1: XlAxisGroup), NEW; BEGIN CtlC.PutInt(this, 47, p1) END PUTAxisGroup; PROCEDURE (this: Series) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Series) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Series) DataLabels* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 157, arg, ret); RETURN CtlC.VarObj(ret) END DataLabels; PROCEDURE (this: Series) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Series) ErrorBar* (Direction: XlErrorBarDirection; Include: XlErrorBarInclude; Type: XlErrorBarType; (* optional *) Amount: CtlT.Any; MinusValues: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[4]); CtlC.IntVar(Include, arg[3]); CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(Amount, arg[1]); CtlC.AnyVar(MinusValues, arg[0]); CtlC.CallParMethod(this, 152, arg, ret); RETURN CtlC.VarAny(ret) END ErrorBar; PROCEDURE (this: Series) ErrorBars* (): ErrorBars, NEW; BEGIN RETURN ThisErrorBars(CtlC.GetAny(this, 159)) END ErrorBars; PROCEDURE (this: Series) Explosion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 182) END Explosion; PROCEDURE (this: Series) PUTExplosion* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 182, p1) END PUTExplosion; PROCEDURE (this: Series) HasDataLabels* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 78) END HasDataLabels; PROCEDURE (this: Series) PUTHasDataLabels* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 78, p1) END PUTHasDataLabels; PROCEDURE (this: Series) HasErrorBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 160) END HasErrorBars; PROCEDURE (this: Series) PUTHasErrorBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 160, p1) END PUTHasErrorBars; PROCEDURE (this: Series) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Series) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Series) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: Series) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: Series) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: Series) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: Series) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: Series) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: Series) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: Series) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: Series) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: Series) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: Series) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: Series) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: Series) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: Series) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: Series) PictureType* (): XlChartPictureType, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: Series) PUTPictureType* (p1: XlChartPictureType), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: Series) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: Series) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: Series) Points* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 70, arg, ret); RETURN CtlC.VarObj(ret) END Points; PROCEDURE (this: Series) Smooth* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 163) END Smooth; PROCEDURE (this: Series) PUTSmooth* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 163, p1) END PUTSmooth; PROCEDURE (this: Series) Trendlines* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 154, arg, ret); RETURN CtlC.VarObj(ret) END Trendlines; PROCEDURE (this: Series) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Series) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; PROCEDURE (this: Series) ChartType* (): XlChartType, NEW; BEGIN RETURN CtlC.GetInt(this, 1400) END ChartType; PROCEDURE (this: Series) PUTChartType* (p1: XlChartType), NEW; BEGIN CtlC.PutInt(this, 1400, p1) END PUTChartType; PROCEDURE (this: Series) ApplyCustomType* (ChartType: XlChartType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ChartType, arg[0]); CtlC.CallParMethod(this, 1401, arg, NIL); END ApplyCustomType; PROCEDURE (this: Series) BarShape* (): XlBarShape, NEW; BEGIN RETURN CtlC.GetInt(this, 1403) END BarShape; PROCEDURE (this: Series) PUTBarShape* (p1: XlBarShape), NEW; BEGIN CtlC.PutInt(this, 1403, p1) END PUTBarShape; PROCEDURE (this: Series) ApplyPictToSides* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1659) END ApplyPictToSides; PROCEDURE (this: Series) PUTApplyPictToSides* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1659, p1) END PUTApplyPictToSides; PROCEDURE (this: Series) ApplyPictToFront* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1660) END ApplyPictToFront; PROCEDURE (this: Series) PUTApplyPictToFront* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1660, p1) END PUTApplyPictToFront; PROCEDURE (this: Series) ApplyPictToEnd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1661) END ApplyPictToEnd; PROCEDURE (this: Series) PUTApplyPictToEnd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1661, p1) END PUTApplyPictToEnd; PROCEDURE (this: Series) Has3DEffect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1665) END Has3DEffect; PROCEDURE (this: Series) PUTHas3DEffect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1665, p1) END PUTHas3DEffect; PROCEDURE (this: Series) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Series) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Series) HasLeaderLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1394) END HasLeaderLines; PROCEDURE (this: Series) PUTHasLeaderLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1394, p1) END PUTHasLeaderLines; PROCEDURE (this: Series) LeaderLines* (): LeaderLines, NEW; BEGIN RETURN ThisLeaderLines(CtlC.GetAny(this, 1666)) END LeaderLines; (* ---------- SeriesCollection ---------- *) PROCEDURE (this: SeriesCollection) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: SeriesCollection) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: SeriesCollection) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: SeriesCollection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: SeriesCollection) Item* (Index: CtlT.Any): Series, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisSeries(CtlC.VarAny(ret)) END Item; PROCEDURE (this: SeriesCollection) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- DataLabel ---------- *) PROCEDURE (this: DataLabel) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataLabel) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DataLabel) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataLabel) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DataLabel) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DataLabel) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DataLabel) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DataLabel) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DataLabel) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataLabel) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DataLabel) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DataLabel) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DataLabel) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DataLabel) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DataLabel) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DataLabel) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DataLabel) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DataLabel) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DataLabel) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DataLabel) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DataLabel) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DataLabel) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DataLabel) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DataLabel) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DataLabel) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DataLabel) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataLabel) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: DataLabel) AutoText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 135) END AutoText; PROCEDURE (this: DataLabel) PUTAutoText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 135, p1) END PUTAutoText; PROCEDURE (this: DataLabel) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: DataLabel) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: DataLabel) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: DataLabel) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: DataLabel) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataLabel) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataLabel) Type* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 108) END Type; PROCEDURE (this: DataLabel) PUTType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 108, p1) END PUTType; PROCEDURE (this: DataLabel) Position* (): XlDataLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: DataLabel) PUTPosition* (p1: XlDataLabelPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; (* ---------- DataLabels ---------- *) PROCEDURE (this: DataLabels) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataLabels) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataLabels) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DataLabels) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataLabels) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DataLabels) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DataLabels) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DataLabels) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataLabels) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DataLabels) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DataLabels) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DataLabels) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DataLabels) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DataLabels) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DataLabels) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DataLabels) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DataLabels) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DataLabels) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DataLabels) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataLabels) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: DataLabels) AutoText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 135) END AutoText; PROCEDURE (this: DataLabels) PUTAutoText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 135, p1) END PUTAutoText; PROCEDURE (this: DataLabels) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: DataLabels) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: DataLabels) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: DataLabels) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: DataLabels) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataLabels) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataLabels) Type* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 108) END Type; PROCEDURE (this: DataLabels) PUTType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 108, p1) END PUTType; PROCEDURE (this: DataLabels) Position* (): XlDataLabelPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: DataLabels) PUTPosition* (p1: XlDataLabelPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: DataLabels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: DataLabels) Item* (Index: CtlT.Any): DataLabel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisDataLabel(CtlC.VarAny(ret)) END Item; PROCEDURE (this: DataLabels) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- LegendEntry ---------- *) PROCEDURE (this: LegendEntry) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendEntry) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendEntry) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: LegendEntry) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: LegendEntry) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: LegendEntry) LegendKey* (): LegendKey, NEW; BEGIN RETURN ThisLegendKey(CtlC.GetAny(this, 174)) END LegendKey; PROCEDURE (this: LegendEntry) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: LegendEntry) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: LegendEntry) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: LegendEntry) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: LegendEntry) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: LegendEntry) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; (* ---------- LegendEntries ---------- *) PROCEDURE (this: LegendEntries) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendEntries) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: LegendEntries) Item* (Index: CtlT.Any): LegendEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisLegendEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: LegendEntries) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- LegendKey ---------- *) PROCEDURE (this: LegendKey) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LegendKey) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LegendKey) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LegendKey) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: LegendKey) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: LegendKey) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: LegendKey) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: LegendKey) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: LegendKey) InvertIfNegative* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 132) END InvertIfNegative; PROCEDURE (this: LegendKey) PUTInvertIfNegative* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 132, p1) END PUTInvertIfNegative; PROCEDURE (this: LegendKey) MarkerBackgroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 73) END MarkerBackgroundColor; PROCEDURE (this: LegendKey) PUTMarkerBackgroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 73, p1) END PUTMarkerBackgroundColor; PROCEDURE (this: LegendKey) MarkerBackgroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END MarkerBackgroundColorIndex; PROCEDURE (this: LegendKey) PUTMarkerBackgroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 74, p1) END PUTMarkerBackgroundColorIndex; PROCEDURE (this: LegendKey) MarkerForegroundColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 75) END MarkerForegroundColor; PROCEDURE (this: LegendKey) PUTMarkerForegroundColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 75, p1) END PUTMarkerForegroundColor; PROCEDURE (this: LegendKey) MarkerForegroundColorIndex* (): XlColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END MarkerForegroundColorIndex; PROCEDURE (this: LegendKey) PUTMarkerForegroundColorIndex* (p1: XlColorIndex), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTMarkerForegroundColorIndex; PROCEDURE (this: LegendKey) MarkerSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 231) END MarkerSize; PROCEDURE (this: LegendKey) PUTMarkerSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 231, p1) END PUTMarkerSize; PROCEDURE (this: LegendKey) MarkerStyle* (): XlMarkerStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 72) END MarkerStyle; PROCEDURE (this: LegendKey) PUTMarkerStyle* (p1: XlMarkerStyle), NEW; BEGIN CtlC.PutInt(this, 72, p1) END PUTMarkerStyle; PROCEDURE (this: LegendKey) PictureType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END PictureType; PROCEDURE (this: LegendKey) PUTPictureType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTPictureType; PROCEDURE (this: LegendKey) PictureUnit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 162) END PictureUnit; PROCEDURE (this: LegendKey) PUTPictureUnit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 162, p1) END PUTPictureUnit; PROCEDURE (this: LegendKey) Smooth* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 163) END Smooth; PROCEDURE (this: LegendKey) PUTSmooth* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 163, p1) END PUTSmooth; PROCEDURE (this: LegendKey) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: LegendKey) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: LegendKey) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: LegendKey) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: LegendKey) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: LegendKey) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; (* ---------- Trendlines ---------- *) PROCEDURE (this: Trendlines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Trendlines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Trendlines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Trendlines) Add* (Type: XlTrendlineType; (* optional *) Order: CtlT.Any; Period: CtlT.Any; Forward: CtlT.Any; Backward: CtlT.Any; Intercept: CtlT.Any; DisplayEquation: CtlT.Any; DisplayRSquared: CtlT.Any; Name: CtlT.Any): Trendline, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[8]); CtlC.AnyVar(Order, arg[7]); CtlC.AnyVar(Period, arg[6]); CtlC.AnyVar(Forward, arg[5]); CtlC.AnyVar(Backward, arg[4]); CtlC.AnyVar(Intercept, arg[3]); CtlC.AnyVar(DisplayEquation, arg[2]); CtlC.AnyVar(DisplayRSquared, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 181, arg, ret); RETURN ThisTrendline(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Trendlines) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END Count; PROCEDURE (this: Trendlines) Item* ((* optional *) Index: CtlT.Any): Trendline, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 170, arg, ret); RETURN ThisTrendline(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Trendlines) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- Trendline ---------- *) PROCEDURE (this: Trendline) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Trendline) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Trendline) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Trendline) Backward* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 185) END Backward; PROCEDURE (this: Trendline) PUTBackward* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 185, p1) END PUTBackward; PROCEDURE (this: Trendline) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Trendline) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Trendline) DataLabel* (): DataLabel, NEW; BEGIN RETURN ThisDataLabel(CtlC.GetAny(this, 158)) END DataLabel; PROCEDURE (this: Trendline) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Trendline) DisplayEquation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 190) END DisplayEquation; PROCEDURE (this: Trendline) PUTDisplayEquation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 190, p1) END PUTDisplayEquation; PROCEDURE (this: Trendline) DisplayRSquared* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 189) END DisplayRSquared; PROCEDURE (this: Trendline) PUTDisplayRSquared* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 189, p1) END PUTDisplayRSquared; PROCEDURE (this: Trendline) Forward* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 191) END Forward; PROCEDURE (this: Trendline) PUTForward* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 191, p1) END PUTForward; PROCEDURE (this: Trendline) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 486) END Index; PROCEDURE (this: Trendline) Intercept* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 186) END Intercept; PROCEDURE (this: Trendline) PUTIntercept* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 186, p1) END PUTIntercept; PROCEDURE (this: Trendline) InterceptIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 187) END InterceptIsAuto; PROCEDURE (this: Trendline) PUTInterceptIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 187, p1) END PUTInterceptIsAuto; PROCEDURE (this: Trendline) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Trendline) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTName; PROCEDURE (this: Trendline) NameIsAuto* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 188) END NameIsAuto; PROCEDURE (this: Trendline) PUTNameIsAuto* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 188, p1) END PUTNameIsAuto; PROCEDURE (this: Trendline) Order* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 192) END Order; PROCEDURE (this: Trendline) PUTOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 192, p1) END PUTOrder; PROCEDURE (this: Trendline) Period* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 184) END Period; PROCEDURE (this: Trendline) PUTPeriod* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 184, p1) END PUTPeriod; PROCEDURE (this: Trendline) Type* (): XlTrendlineType, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END Type; PROCEDURE (this: Trendline) PUTType* (p1: XlTrendlineType), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTType; (* ---------- Corners ---------- *) PROCEDURE (this: Corners) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Corners) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Corners) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Corners) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; (* ---------- SeriesLines ---------- *) PROCEDURE (this: SeriesLines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: SeriesLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: SeriesLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: SeriesLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: SeriesLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: SeriesLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- HiLoLines ---------- *) PROCEDURE (this: HiLoLines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: HiLoLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: HiLoLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: HiLoLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: HiLoLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: HiLoLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- Gridlines ---------- *) PROCEDURE (this: Gridlines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Gridlines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Gridlines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Gridlines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Gridlines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Gridlines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- DropLines ---------- *) PROCEDURE (this: DropLines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DropLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DropLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DropLines) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DropLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DropLines) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; (* ---------- LeaderLines ---------- *) PROCEDURE (this: LeaderLines) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: LeaderLines) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: LeaderLines) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: LeaderLines) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: LeaderLines) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; (* ---------- UpBars ---------- *) PROCEDURE (this: UpBars) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: UpBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: UpBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: UpBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: UpBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: UpBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: UpBars) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: UpBars) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- DownBars ---------- *) PROCEDURE (this: DownBars) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DownBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DownBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DownBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DownBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DownBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DownBars) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DownBars) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; (* ---------- Floor ---------- *) PROCEDURE (this: Floor) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Floor) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Floor) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Floor) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Floor) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Floor) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Floor) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Floor) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Floor) PictureType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 161) END PictureType; PROCEDURE (this: Floor) PUTPictureType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 161, p1) END PUTPictureType; (* ---------- Walls ---------- *) PROCEDURE (this: Walls) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Walls) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Walls) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Walls) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Walls) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Walls) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: Walls) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Walls) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Walls) PictureType* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 161) END PictureType; PROCEDURE (this: Walls) PUTPictureType* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 161, p1) END PUTPictureType; PROCEDURE (this: Walls) PictureUnit* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 162) END PictureUnit; PROCEDURE (this: Walls) PUTPictureUnit* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 162, p1) END PUTPictureUnit; (* ---------- TickLabels ---------- *) PROCEDURE (this: TickLabels) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: TickLabels) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: TickLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: TickLabels) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: TickLabels) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: TickLabels) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: TickLabels) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 193) END NumberFormat; PROCEDURE (this: TickLabels) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 193, p1) END PUTNumberFormat; PROCEDURE (this: TickLabels) NumberFormatLocal* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1097) END NumberFormatLocal; PROCEDURE (this: TickLabels) PUTNumberFormatLocal* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1097, p1) END PUTNumberFormatLocal; PROCEDURE (this: TickLabels) Orientation* (): XlTickLabelOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END Orientation; PROCEDURE (this: TickLabels) PUTOrientation* (p1: XlTickLabelOrientation), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTOrientation; PROCEDURE (this: TickLabels) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: TickLabels) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: TickLabels) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: TickLabels) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE (this: TickLabels) Offset* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 254) END Offset; PROCEDURE (this: TickLabels) PUTOffset* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 254, p1) END PUTOffset; (* ---------- PlotArea ---------- *) PROCEDURE (this: PlotArea) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: PlotArea) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: PlotArea) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: PlotArea) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: PlotArea) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: PlotArea) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: PlotArea) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: PlotArea) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: PlotArea) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: PlotArea) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: PlotArea) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: PlotArea) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: PlotArea) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: PlotArea) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: PlotArea) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: PlotArea) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: PlotArea) InsideLeft* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1667) END InsideLeft; PROCEDURE (this: PlotArea) InsideTop* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1668) END InsideTop; PROCEDURE (this: PlotArea) InsideWidth* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1669) END InsideWidth; PROCEDURE (this: PlotArea) InsideHeight* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 1670) END InsideHeight; (* ---------- ChartArea ---------- *) PROCEDURE (this: ChartArea) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ChartArea) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ChartArea) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ChartArea) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ChartArea) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ChartArea) Clear* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 111, ret); RETURN CtlC.VarAny(ret) END Clear; PROCEDURE (this: ChartArea) ClearContents* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 113, ret); RETURN CtlC.VarAny(ret) END ClearContents; PROCEDURE (this: ChartArea) Copy* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 551, ret); RETURN CtlC.VarAny(ret) END Copy; PROCEDURE (this: ChartArea) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: ChartArea) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: ChartArea) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: ChartArea) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: ChartArea) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: ChartArea) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: ChartArea) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: ChartArea) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: ChartArea) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: ChartArea) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: ChartArea) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: ChartArea) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: ChartArea) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: ChartArea) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: ChartArea) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: ChartArea) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- Legend ---------- *) PROCEDURE (this: Legend) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: Legend) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: Legend) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: Legend) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: Legend) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: Legend) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: Legend) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: Legend) LegendEntries* ((* optional *) Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 173, arg, ret); RETURN CtlC.VarObj(ret) END LegendEntries; PROCEDURE (this: Legend) Position* (): XlLegendPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END Position; PROCEDURE (this: Legend) PUTPosition* (p1: XlLegendPosition), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTPosition; PROCEDURE (this: Legend) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: Legend) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: Legend) Clear* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 111, ret); RETURN CtlC.VarAny(ret) END Clear; PROCEDURE (this: Legend) Height* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 123) END Height; PROCEDURE (this: Legend) PUTHeight* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 123, p1) END PUTHeight; PROCEDURE (this: Legend) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: Legend) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: Legend) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: Legend) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: Legend) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: Legend) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: Legend) Width* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 122) END Width; PROCEDURE (this: Legend) PUTWidth* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 122, p1) END PUTWidth; PROCEDURE (this: Legend) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: Legend) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- ErrorBars ---------- *) PROCEDURE (this: ErrorBars) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: ErrorBars) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: ErrorBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: ErrorBars) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: ErrorBars) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: ErrorBars) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: ErrorBars) ClearFormats* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 112, ret); RETURN CtlC.VarAny(ret) END ClearFormats; PROCEDURE (this: ErrorBars) EndStyle* (): XlEndStyleCap, NEW; BEGIN RETURN CtlC.GetInt(this, 1124) END EndStyle; PROCEDURE (this: ErrorBars) PUTEndStyle* (p1: XlEndStyleCap), NEW; BEGIN CtlC.PutInt(this, 1124, p1) END PUTEndStyle; (* ---------- DataTable ---------- *) PROCEDURE (this: DataTable) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DataTable) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DataTable) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DataTable) ShowLegendKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 171) END ShowLegendKey; PROCEDURE (this: DataTable) PUTShowLegendKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 171, p1) END PUTShowLegendKey; PROCEDURE (this: DataTable) HasBorderHorizontal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1671) END HasBorderHorizontal; PROCEDURE (this: DataTable) PUTHasBorderHorizontal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1671, p1) END PUTHasBorderHorizontal; PROCEDURE (this: DataTable) HasBorderVertical* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1672) END HasBorderVertical; PROCEDURE (this: DataTable) PUTHasBorderVertical* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1672, p1) END PUTHasBorderVertical; PROCEDURE (this: DataTable) HasBorderOutline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1673) END HasBorderOutline; PROCEDURE (this: DataTable) PUTHasBorderOutline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1673, p1) END PUTHasBorderOutline; PROCEDURE (this: DataTable) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DataTable) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DataTable) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 117, NIL); END Delete; PROCEDURE (this: DataTable) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DataTable) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; (* ---------- DisplayUnitLabel ---------- *) PROCEDURE (this: DisplayUnitLabel) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 148)) END Application; PROCEDURE (this: DisplayUnitLabel) Creator* (): XlCreator, NEW; BEGIN RETURN CtlC.GetInt(this, 149) END Creator; PROCEDURE (this: DisplayUnitLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 150) END Parent; PROCEDURE (this: DisplayUnitLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Name; PROCEDURE (this: DisplayUnitLabel) Border* (): Border, NEW; BEGIN RETURN ThisBorder(CtlC.GetAny(this, 128)) END Border; PROCEDURE (this: DisplayUnitLabel) Delete* (): CtlT.Any, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 117, ret); RETURN CtlC.VarAny(ret) END Delete; PROCEDURE (this: DisplayUnitLabel) Interior* (): Interior, NEW; BEGIN RETURN ThisInterior(CtlC.GetAny(this, 129)) END Interior; PROCEDURE (this: DisplayUnitLabel) Fill* (): ChartFillFormat, NEW; BEGIN RETURN ThisChartFillFormat(CtlC.GetAny(this, 1663)) END Fill; PROCEDURE (this: DisplayUnitLabel) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 139) END Caption; PROCEDURE (this: DisplayUnitLabel) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 139, p1) END PUTCaption; PROCEDURE (this: DisplayUnitLabel) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 146)) END Font; PROCEDURE (this: DisplayUnitLabel) HorizontalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 136) END HorizontalAlignment; PROCEDURE (this: DisplayUnitLabel) PUTHorizontalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 136, p1) END PUTHorizontalAlignment; PROCEDURE (this: DisplayUnitLabel) Left* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 127) END Left; PROCEDURE (this: DisplayUnitLabel) PUTLeft* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 127, p1) END PUTLeft; PROCEDURE (this: DisplayUnitLabel) Orientation* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 134) END Orientation; PROCEDURE (this: DisplayUnitLabel) PUTOrientation* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 134, p1) END PUTOrientation; PROCEDURE (this: DisplayUnitLabel) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Shadow; PROCEDURE (this: DisplayUnitLabel) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTShadow; PROCEDURE (this: DisplayUnitLabel) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 138) END Text; PROCEDURE (this: DisplayUnitLabel) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 138, p1) END PUTText; PROCEDURE (this: DisplayUnitLabel) Top* (): REAL, NEW; BEGIN RETURN CtlC.GetReal(this, 126) END Top; PROCEDURE (this: DisplayUnitLabel) PUTTop* (p1: REAL), NEW; BEGIN CtlC.PutReal(this, 126, p1) END PUTTop; PROCEDURE (this: DisplayUnitLabel) VerticalAlignment* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 137) END VerticalAlignment; PROCEDURE (this: DisplayUnitLabel) PUTVerticalAlignment* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 137, p1) END PUTVerticalAlignment; PROCEDURE (this: DisplayUnitLabel) ReadingOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 975) END ReadingOrder; PROCEDURE (this: DisplayUnitLabel) PUTReadingOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 975, p1) END PUTReadingOrder; PROCEDURE (this: DisplayUnitLabel) AutoScaleFont* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1525) END AutoScaleFont; PROCEDURE (this: DisplayUnitLabel) PUTAutoScaleFont* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1525, p1) END PUTAutoScaleFont; PROCEDURE NewGlobal* (): _Global; BEGIN RETURN This_Global(CtlC.NewObj("{00020800-0000-0000-C000-000000000046}")) END NewGlobal; END CtlGraph9.

Ctl/Mod/Graph9.odc

MODULE CtlMSForms; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Forms 2.0 Object Library, help: C:\WIN95\SYSTEM\fm20.hlp, id: 0 *) (* guid: {0D452EE1-E08F-101A-852E-02608C4D0BB4}, lcid: 0, syskind: win32, version: 2.0, control *) IMPORT CtlT, CtlC, CtlStdType; CONST (* fmDropEffect *) fmDropEffectNone* = 0; (* None *) fmDropEffectCopy* = 1; (* Copy *) fmDropEffectMove* = 2; (* Move *) fmDropEffectCopyOrMove* = 3; (* CopyOrMove *) (* fmAction *) fmActionCut* = 0; (* Cut *) fmActionCopy* = 1; (* Copy *) fmActionPaste* = 2; (* Paste *) fmActionDragDrop* = 3; (* DragDrop *) (* fmMode *) fmModeInherit* = -2; (* Inherit *) fmModeOn* = -1; (* On *) fmModeOff* = 0; (* Off *) (* fmMousePointer *) fmMousePointerDefault* = 0; (* Default *) fmMousePointerArrow* = 1; (* Arrow *) fmMousePointerCross* = 2; (* Cross *) fmMousePointerIBeam* = 3; (* IBeam *) fmMousePointerSizeNESW* = 6; (* SizeNESW *) fmMousePointerSizeNS* = 7; (* SizeNS *) fmMousePointerSizeNWSE* = 8; (* SizeNWSE *) fmMousePointerSizeWE* = 9; (* SizeWE *) fmMousePointerUpArrow* = 10; (* UpArrow *) fmMousePointerHourGlass* = 11; (* HourGlass *) fmMousePointerNoDrop* = 12; (* NoDrop *) fmMousePointerAppStarting* = 13; (* AppStarting *) fmMousePointerHelp* = 14; (* Help *) fmMousePointerSizeAll* = 15; (* SizeAll *) fmMousePointerCustom* = 99; (* Custom *) (* fmScrollBars *) fmScrollBarsNone* = 0; (* None *) fmScrollBarsHorizontal* = 1; (* Horizontal *) fmScrollBarsVertical* = 2; (* Vertical *) fmScrollBarsBoth* = 3; (* Both *) (* fmScrollAction *) fmScrollActionNoChange* = 0; (* NoChange *) fmScrollActionLineUp* = 1; (* LineUp *) fmScrollActionLineDown* = 2; (* LineDown *) fmScrollActionPageUp* = 3; (* PageUp *) fmScrollActionPageDown* = 4; (* PageDown *) fmScrollActionBegin* = 5; (* Begin *) fmScrollActionEnd* = 6; (* End *) _fmScrollActionAbsoluteChange* = 7; (* AbsoluteChange *) fmScrollActionPropertyChange* = 8; (* PropertyChange *) fmScrollActionControlRequest* = 9; (* ControlRequest *) fmScrollActionFocusRequest* = 10; (* FocusRequest *) (* fmCycle *) fmCycleAllForms* = 0; (* AllForms *) fmCycleCurrentForm* = 2; (* CurrentForm *) (* fmZOrder *) fmZOrderFront* = 0; (* Front *) fmZOrderBack* = 1; (* Back *) (* fmBorderStyle *) fmBorderStyleNone* = 0; (* None *) fmBorderStyleSingle* = 1; (* Single *) (* fmTextAlign *) fmTextAlignLeft* = 1; (* Left *) fmTextAlignCenter* = 2; (* Center *) fmTextAlignRight* = 3; (* Right *) (* fmAlignment *) fmAlignmentLeft* = 0; (* Left *) fmAlignmentRight* = 1; (* Right *) (* fmBorders *) fmBordersNone* = 0; (* None *) fmBordersBox* = 1; (* Box *) fmBordersLeft* = 2; (* Left *) fmBordersTop* = 3; (* Top *) (* fmBackStyle *) fmBackStyleTransparent* = 0; (* Transparent *) fmBackStyleOpaque* = 1; (* Opaque *) (* fmButtonStyle *) fmButtonStylePushButton* = 0; (* PushButton *) fmButtonStyleToggleButton* = 1; (* ToggleButton *) (* fmPicPosition *) fmPicPositionCenter* = 0; (* Center *) fmPicPositionTopLeft* = 1; (* TopLeft *) fmPicPositionTopCenter* = 2; (* TopCenter *) fmPicPositionTopRight* = 3; (* TopRight *) fmPicPositionCenterLeft* = 4; (* CenterLeft *) fmPicPositionCenterRight* = 5; (* CenterRight *) fmPicPositionBottomLeft* = 6; (* BottomLeft *) fmPicPositionBottomCenter* = 7; (* BottomCenter *) fmPicPositionBottomRight* = 8; (* BottomRight *) (* fmVerticalScrollBarSide *) fmVerticalScrollBarSideRight* = 0; (* Right *) fmVerticalScrollBarSideLeft* = 1; (* Left *) (* fmLayoutEffect *) fmLayoutEffectNone* = 0; (* None *) fmLayoutEffectInitiate* = 1; (* Initiate *) _fmLayoutEffectRespond* = 2; (* Respond *) (* fmSpecialEffect *) fmSpecialEffectFlat* = 0; (* Flat *) fmSpecialEffectRaised* = 1; (* Raised *) fmSpecialEffectSunken* = 2; (* Sunken *) fmSpecialEffectEtched* = 3; (* Etched *) fmSpecialEffectBump* = 6; (* Bump *) (* fmDragState *) fmDragStateEnter* = 0; (* Enter *) fmDragStateLeave* = 1; (* Leave *) fmDragStateOver* = 2; (* Over *) (* fmPictureSizeMode *) fmPictureSizeModeClip* = 0; (* Clip *) fmPictureSizeModeStretch* = 1; (* Stretch *) fmPictureSizeModeZoom* = 3; (* Zoom *) (* fmPictureAlignment *) fmPictureAlignmentTopLeft* = 0; (* TopLeft *) fmPictureAlignmentTopRight* = 1; (* TopRight *) fmPictureAlignmentCenter* = 2; (* Center *) fmPictureAlignmentBottomLeft* = 3; (* BottomLeft *) fmPictureAlignmentBottomRight* = 4; (* BottomRight *) (* fmButtonEffect *) fmButtonEffectFlat* = 0; (* Flat *) fmButtonEffectSunken* = 2; (* Sunken *) (* fmOrientation *) fmOrientationAuto* = -1; (* Auto *) fmOrientationVertical* = 0; (* Vertical *) fmOrientationHorizontal* = 1; (* Horizontal *) (* fmSnapPoint *) fmSnapPointTopLeft* = 0; (* TopLeft *) fmSnapPointTopCenter* = 1; (* TopCenter *) fmSnapPointTopRight* = 2; (* TopRight *) fmSnapPointCenterLeft* = 3; (* CenterLeft *) fmSnapPointCenter* = 4; (* Center *) fmSnapPointCenterRight* = 5; (* CenterRight *) fmSnapPointBottomLeft* = 6; (* BottomLeft *) fmSnapPointBottomCenter* = 7; (* BottomCenter *) fmSnapPointBottomRight* = 8; (* BottomRight *) (* fmPicturePosition *) fmPicturePositionLeftTop* = 0; (* LeftTop *) fmPicturePositionLeftCenter* = 1; (* LeftCenter *) fmPicturePositionLeftBottom* = 2; (* LeftBottom *) fmPicturePositionRightTop* = 3; (* RightTop *) fmPicturePositionRightCenter* = 4; (* RightCenter *) fmPicturePositionRightBottom* = 5; (* RightBottom *) fmPicturePositionAboveLeft* = 6; (* AboveLeft *) fmPicturePositionAboveCenter* = 7; (* AboveCenter *) fmPicturePositionAboveRight* = 8; (* AboveRight *) fmPicturePositionBelowLeft* = 9; (* BelowLeft *) fmPicturePositionBelowCenter* = 10; (* BelowCenter *) fmPicturePositionBelowRight* = 11; (* BelowRight *) fmPicturePositionCenter* = 12; (* Center *) (* fmDisplayStyle *) fmDisplayStyleText* = 1; (* Text *) fmDisplayStyleList* = 2; (* List *) fmDisplayStyleCombo* = 3; (* Combo *) fmDisplayStyleCheckBox* = 4; (* CheckBox *) fmDisplayStyleOptionButton* = 5; (* OptionButton *) fmDisplayStyleToggle* = 6; (* Toggle *) fmDisplayStyleDropList* = 7; (* DropList *) (* fmShowListWhen *) fmShowListWhenNever* = 0; (* Never *) fmShowListWhenButton* = 1; (* Button *) fmShowListWhenFocus* = 2; (* Focus *) fmShowListWhenAlways* = 3; (* Always *) (* fmShowDropButtonWhen *) fmShowDropButtonWhenNever* = 0; (* Never *) fmShowDropButtonWhenFocus* = 1; (* Focus *) fmShowDropButtonWhenAlways* = 2; (* Always *) (* fmMultiSelect *) fmMultiSelectSingle* = 0; (* Single *) fmMultiSelectMulti* = 1; (* Multi *) fmMultiSelectExtended* = 2; (* Extended *) (* fmListStyle *) fmListStylePlain* = 0; (* Plain *) fmListStyleOption* = 1; (* Option *) (* fmEnterFieldBehavior *) fmEnterFieldBehaviorSelectAll* = 0; (* SelectAll *) fmEnterFieldBehaviorRecallSelection* = 1; (* RecallSelection *) (* fmDragBehavior *) fmDragBehaviorDisabled* = 0; (* Disabled *) fmDragBehaviorEnabled* = 1; (* Enabled *) (* fmMatchEntry *) fmMatchEntryFirstLetter* = 0; (* FirstLetter *) fmMatchEntryComplete* = 1; (* Complete *) fmMatchEntryNone* = 2; (* None *) (* fmDropButtonStyle *) fmDropButtonStylePlain* = 0; (* Plain *) fmDropButtonStyleArrow* = 1; (* Arrow *) fmDropButtonStyleEllipsis* = 2; (* Ellipsis *) fmDropButtonStyleReduce* = 3; (* Reduce *) (* fmStyle *) fmStyleDropDownCombo* = 0; (* DropDownCombo *) fmStyleDropDownList* = 2; (* DropDownList *) (* fmTabOrientation *) fmTabOrientationTop* = 0; (* Top *) fmTabOrientationBottom* = 1; (* Bottom *) fmTabOrientationLeft* = 2; (* Left *) fmTabOrientationRight* = 3; (* Right *) (* fmTabStyle *) fmTabStyleTabs* = 0; (* Tabs *) fmTabStyleButtons* = 1; (* Buttons *) fmTabStyleNone* = 2; (* None *) (* fmIMEMode *) fmIMEModeNoControl* = 0; (* NoControl *) fmIMEModeOn* = 1; (* On *) fmIMEModeOff* = 2; (* Off *) fmIMEModeDisable* = 3; (* Disable *) fmIMEModeHiragana* = 4; (* Hiragana *) fmIMEModeKatakana* = 5; (* Katakana *) fmIMEModeKatakanaHalf* = 6; (* KatakanaHalf *) fmIMEModeAlphaFull* = 7; (* AlphaFull *) fmIMEModeAlpha* = 8; (* Alpha *) fmIMEModeHangulFull* = 9; (* HangulFull *) fmIMEModeHangul* = 10; (* Hangul *) fmIMEModeHanziFull* = 11; (* HanziFull *) fmIMEModeHanzi* = 12; (* Hanzi *) (* fmTransitionEffect *) fmTransitionEffectNone* = 0; (* None *) fmTransitionEffectCoverUp* = 1; (* CoverUp *) fmTransitionEffectCoverRightUp* = 2; (* CoverRightUp *) fmTransitionEffectCoverRight* = 3; (* CoverRight *) fmTransitionEffectCoverRightDown* = 4; (* CoverRightDown *) fmTransitionEffectCoverDown* = 5; (* CoverDown *) fmTransitionEffectCoverLeftDown* = 6; (* CoverLeftDown *) fmTransitionEffectCoverLeft* = 7; (* CoverLeft *) fmTransitionEffectCoverLeftUp* = 8; (* CoverLeftUp *) fmTransitionEffectPushUp* = 9; (* PushUp *) fmTransitionEffectPushRight* = 10; (* PushRight *) fmTransitionEffectPushDown* = 11; (* PushDown *) fmTransitionEffectPushLeft* = 12; (* PushLeft *) (* fmListBoxStyles, hidden *) _fmListBoxStylesNone* = 0; (* None *) _fmListBoxStylesListBox* = 1; (* ListBox *) _fmListBoxStylesComboBox* = 2; (* ComboBox *) (* fmRepeatDirection, hidden *) _fmRepeatDirectionHorizontal* = 0; (* Horizontal *) _fmRepeatDirectionVertical* = 1; (* Vertical *) (* fmEnAutoSize, hidden *) _fmEnAutoSizeNone* = 0; (* None *) _fmEnAutoSizeHorizontal* = 1; (* Horizontal *) _fmEnAutoSizeVertical* = 2; (* Vertical *) _fmEnAutoSizeBoth* = 3; (* Both *) TYPE OLE_COLOR* = INTEGER; OLE_HANDLE* = INTEGER; OLE_OPTEXCLUSIVE* = BOOLEAN; Font* = POINTER TO RECORD (CtlT.Object) END; fmDropEffect* = INTEGER; fmAction* = INTEGER; IDataAutoWrapper* = POINTER TO RECORD (CtlT.Object) END; IReturnInteger* = POINTER TO RECORD (CtlT.Object) END; IReturnBoolean* = POINTER TO RECORD (CtlT.Object) END; IReturnString* = POINTER TO RECORD (CtlT.Object) END; IReturnSingle* = POINTER TO RECORD (CtlT.Object) END; IReturnEffect* = POINTER TO RECORD (CtlT.Object) END; ReturnInteger* = IReturnInteger; ReturnBoolean* = IReturnBoolean; ReturnString* = IReturnString; ReturnSingle* = IReturnSingle; ReturnEffect* = IReturnEffect; DataObject* = IDataAutoWrapper; fmMode* = INTEGER; fmMousePointer* = INTEGER; fmScrollBars* = INTEGER; fmScrollAction* = INTEGER; fmCycle* = INTEGER; fmZOrder* = INTEGER; fmBorderStyle* = INTEGER; fmTextAlign* = INTEGER; fmAlignment* = INTEGER; fmBorders* = INTEGER; fmBackStyle* = INTEGER; fmButtonStyle* = INTEGER; fmPicPosition* = INTEGER; fmVerticalScrollBarSide* = INTEGER; fmLayoutEffect* = INTEGER; fmSpecialEffect* = INTEGER; fmDragState* = INTEGER; fmPictureSizeMode* = INTEGER; fmPictureAlignment* = INTEGER; IControl* = POINTER TO RECORD (CtlT.Object) END; Controls* = POINTER TO RECORD (CtlT.Object) END; IOptionFrame* = POINTER TO RECORD (CtlT.Object) END; _UserForm* = POINTER TO RECORD (CtlT.Object) END; ControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Control* = IControl; FormEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; OptionFrameEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; UserForm* = _UserForm; Frame* = IOptionFrame; fmButtonEffect* = INTEGER; fmOrientation* = INTEGER; fmSnapPoint* = INTEGER; fmPicturePosition* = INTEGER; fmDisplayStyle* = INTEGER; fmShowListWhen* = INTEGER; fmShowDropButtonWhen* = INTEGER; fmMultiSelect* = INTEGER; fmListStyle* = INTEGER; fmEnterFieldBehavior* = INTEGER; fmDragBehavior* = INTEGER; fmMatchEntry* = INTEGER; fmDropButtonStyle* = INTEGER; fmStyle* = INTEGER; fmTabOrientation* = INTEGER; fmTabStyle* = INTEGER; fmIMEMode* = INTEGER; ILabelControl* = POINTER TO RECORD (CtlT.Object) END; ICommandButton* = POINTER TO RECORD (CtlT.Object) END; PIROWSET* = CtlT.IUnknown; IMdcText* = POINTER TO RECORD (CtlT.Object) END; IMdcList* = POINTER TO RECORD (CtlT.Object) END; IMdcCombo* = POINTER TO RECORD (CtlT.Object) END; IMdcCheckBox* = POINTER TO RECORD (CtlT.Object) END; IMdcOptionButton* = POINTER TO RECORD (CtlT.Object) END; IMdcToggleButton* = POINTER TO RECORD (CtlT.Object) END; IScrollbar* = POINTER TO RECORD (CtlT.Object) END; Tab* = POINTER TO RECORD (CtlT.Object) END; Tabs* = POINTER TO RECORD (CtlT.Object) END; ITabStrip* = POINTER TO RECORD (CtlT.Object) END; ISpinbutton* = POINTER TO RECORD (CtlT.Object) END; IImage* = POINTER TO RECORD (CtlT.Object) END; IWHTMLSubmitButton* = POINTER TO RECORD (CtlT.Object) END; IWHTMLImage* = POINTER TO RECORD (CtlT.Object) END; IWHTMLReset* = POINTER TO RECORD (CtlT.Object) END; IWHTMLCheckbox* = POINTER TO RECORD (CtlT.Object) END; IWHTMLOption* = POINTER TO RECORD (CtlT.Object) END; IWHTMLText* = POINTER TO RECORD (CtlT.Object) END; IWHTMLHidden* = POINTER TO RECORD (CtlT.Object) END; IWHTMLPassword* = POINTER TO RECORD (CtlT.Object) END; IWHTMLSelect* = POINTER TO RECORD (CtlT.Object) END; IWHTMLTextArea* = POINTER TO RECORD (CtlT.Object) END; LabelControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Label* = ILabelControl; CommandButtonEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; CommandButton* = ICommandButton; MdcTextEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; TextBox* = IMdcText; MdcListEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; ListBox* = IMdcList; MdcComboEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; ComboBox* = IMdcCombo; MdcCheckBoxEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; MdcOptionButtonEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; MdcToggleButtonEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; CheckBox* = IMdcCheckBox; OptionButton* = IMdcOptionButton; ToggleButton* = IMdcToggleButton; NewFont* = Font; ScrollbarEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; ScrollBar* = IScrollbar; TabStripEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; TabStrip* = ITabStrip; SpinbuttonEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; SpinButton* = ISpinbutton; ImageEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Image* = IImage; WHTMLControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents1* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents2* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents3* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents4* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents5* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents6* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents7* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents9* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WHTMLControlEvents10* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; HTMLSubmit* = IWHTMLSubmitButton; HTMLImage* = IWHTMLImage; HTMLReset* = IWHTMLReset; HTMLCheckbox* = IWHTMLCheckbox; HTMLOption* = IWHTMLOption; HTMLText* = IWHTMLText; HTMLHidden* = IWHTMLHidden; HTMLPassword* = IWHTMLPassword; HTMLSelect* = IWHTMLSelect; HTMLTextArea* = IWHTMLTextArea; fmTransitionEffect* = INTEGER; IPage* = POINTER TO RECORD (CtlT.Object) END; Pages* = POINTER TO RECORD (CtlT.Object) END; IMultiPage* = POINTER TO RECORD (CtlT.Object) END; MultiPageEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; MultiPage* = IMultiPage; Page* = IPage; fmListBoxStyles* = INTEGER; fmRepeatDirection* = INTEGER; fmEnAutoSize* = INTEGER; PROCEDURE ThisFont* (v: CtlT.Any): Font; VAR new: Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{BEF6E003-A874-101A-8BBA-00AA00300CAB}"); RETURN new ELSE RETURN NIL END END ThisFont; PROCEDURE IsFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{BEF6E003-A874-101A-8BBA-00AA00300CAB}") END IsFont; PROCEDURE ThisIDataAutoWrapper* (v: CtlT.Any): IDataAutoWrapper; VAR new: IDataAutoWrapper; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{EC72F590-F375-11CE-B9E8-00AA006B1A69}"); RETURN new ELSE RETURN NIL END END ThisIDataAutoWrapper; PROCEDURE IsIDataAutoWrapper* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{EC72F590-F375-11CE-B9E8-00AA006B1A69}") END IsIDataAutoWrapper; PROCEDURE ThisIReturnInteger* (v: CtlT.Any): IReturnInteger; VAR new: IReturnInteger; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{82B02370-B5BC-11CF-810F-00A0C9030074}"); RETURN new ELSE RETURN NIL END END ThisIReturnInteger; PROCEDURE IsIReturnInteger* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{82B02370-B5BC-11CF-810F-00A0C9030074}") END IsIReturnInteger; PROCEDURE ThisIReturnBoolean* (v: CtlT.Any): IReturnBoolean; VAR new: IReturnBoolean; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{82B02371-B5BC-11CF-810F-00A0C9030074}"); RETURN new ELSE RETURN NIL END END ThisIReturnBoolean; PROCEDURE IsIReturnBoolean* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{82B02371-B5BC-11CF-810F-00A0C9030074}") END IsIReturnBoolean; PROCEDURE ThisIReturnString* (v: CtlT.Any): IReturnString; VAR new: IReturnString; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{82B02372-B5BC-11CF-810F-00A0C9030074}"); RETURN new ELSE RETURN NIL END END ThisIReturnString; PROCEDURE IsIReturnString* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{82B02372-B5BC-11CF-810F-00A0C9030074}") END IsIReturnString; PROCEDURE ThisIReturnSingle* (v: CtlT.Any): IReturnSingle; VAR new: IReturnSingle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8A683C90-BA84-11CF-8110-00A0C9030074}"); RETURN new ELSE RETURN NIL END END ThisIReturnSingle; PROCEDURE IsIReturnSingle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8A683C90-BA84-11CF-8110-00A0C9030074}") END IsIReturnSingle; PROCEDURE ThisIReturnEffect* (v: CtlT.Any): IReturnEffect; VAR new: IReturnEffect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8A683C91-BA84-11CF-8110-00A0C9030074}"); RETURN new ELSE RETURN NIL END END ThisIReturnEffect; PROCEDURE IsIReturnEffect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8A683C91-BA84-11CF-8110-00A0C9030074}") END IsIReturnEffect; PROCEDURE ThisIControl* (v: CtlT.Any): IControl; VAR new: IControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC6-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisIControl; PROCEDURE IsIControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC6-866C-11CF-AB7C-00AA00C08FCF}") END IsIControl; PROCEDURE ThisControls* (v: CtlT.Any): Controls; VAR new: Controls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC7-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisControls; PROCEDURE IsControls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC7-866C-11CF-AB7C-00AA00C08FCF}") END IsControls; PROCEDURE ThisIOptionFrame* (v: CtlT.Any): IOptionFrame; VAR new: IOptionFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{29B86A70-F52E-11CE-9BCE-00AA00608E01}"); RETURN new ELSE RETURN NIL END END ThisIOptionFrame; PROCEDURE IsIOptionFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{29B86A70-F52E-11CE-9BCE-00AA00608E01}") END IsIOptionFrame; PROCEDURE This_UserForm* (v: CtlT.Any): _UserForm; VAR new: _UserForm; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC8-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END This_UserForm; PROCEDURE Is_UserForm* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC8-866C-11CF-AB7C-00AA00C08FCF}") END Is_UserForm; PROCEDURE ThisILabelControl* (v: CtlT.Any): ILabelControl; VAR new: ILabelControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC1-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisILabelControl; PROCEDURE IsILabelControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC1-866C-11CF-AB7C-00AA00C08FCF}") END IsILabelControl; PROCEDURE ThisICommandButton* (v: CtlT.Any): ICommandButton; VAR new: ICommandButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC4-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisICommandButton; PROCEDURE IsICommandButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC4-866C-11CF-AB7C-00AA00C08FCF}") END IsICommandButton; PROCEDURE ThisIMdcText* (v: CtlT.Any): IMdcText; VAR new: IMdcText; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D13-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcText; PROCEDURE IsIMdcText* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D13-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcText; PROCEDURE ThisIMdcList* (v: CtlT.Any): IMdcList; VAR new: IMdcList; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D23-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcList; PROCEDURE IsIMdcList* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D23-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcList; PROCEDURE ThisIMdcCombo* (v: CtlT.Any): IMdcCombo; VAR new: IMdcCombo; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D33-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcCombo; PROCEDURE IsIMdcCombo* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D33-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcCombo; PROCEDURE ThisIMdcCheckBox* (v: CtlT.Any): IMdcCheckBox; VAR new: IMdcCheckBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D43-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcCheckBox; PROCEDURE IsIMdcCheckBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D43-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcCheckBox; PROCEDURE ThisIMdcOptionButton* (v: CtlT.Any): IMdcOptionButton; VAR new: IMdcOptionButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D53-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcOptionButton; PROCEDURE IsIMdcOptionButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D53-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcOptionButton; PROCEDURE ThisIMdcToggleButton* (v: CtlT.Any): IMdcToggleButton; VAR new: IMdcToggleButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{8BD21D63-EC42-11CE-9E0D-00AA006002F3}"); RETURN new ELSE RETURN NIL END END ThisIMdcToggleButton; PROCEDURE IsIMdcToggleButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{8BD21D63-EC42-11CE-9E0D-00AA006002F3}") END IsIMdcToggleButton; PROCEDURE ThisIScrollbar* (v: CtlT.Any): IScrollbar; VAR new: IScrollbar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC3-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisIScrollbar; PROCEDURE IsIScrollbar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC3-866C-11CF-AB7C-00AA00C08FCF}") END IsIScrollbar; PROCEDURE ThisTab* (v: CtlT.Any): Tab; VAR new: Tab; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{A38BFFC3-A5A0-11CE-8107-00AA00611080}"); RETURN new ELSE RETURN NIL END END ThisTab; PROCEDURE IsTab* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{A38BFFC3-A5A0-11CE-8107-00AA00611080}") END IsTab; PROCEDURE ThisTabs* (v: CtlT.Any): Tabs; VAR new: Tabs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{944ACF93-A1E6-11CE-8104-00AA00611080}"); RETURN new ELSE RETURN NIL END END ThisTabs; PROCEDURE IsTabs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{944ACF93-A1E6-11CE-8104-00AA00611080}") END IsTabs; PROCEDURE ThisITabStrip* (v: CtlT.Any): ITabStrip; VAR new: ITabStrip; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC2-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisITabStrip; PROCEDURE IsITabStrip* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC2-866C-11CF-AB7C-00AA00C08FCF}") END IsITabStrip; PROCEDURE ThisISpinbutton* (v: CtlT.Any): ISpinbutton; VAR new: ISpinbutton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{79176FB3-B7F2-11CE-97EF-00AA006D2776}"); RETURN new ELSE RETURN NIL END END ThisISpinbutton; PROCEDURE IsISpinbutton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{79176FB3-B7F2-11CE-97EF-00AA006D2776}") END IsISpinbutton; PROCEDURE ThisIImage* (v: CtlT.Any): IImage; VAR new: IImage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{4C599243-6926-101B-9992-00000B65C6F9}"); RETURN new ELSE RETURN NIL END END ThisIImage; PROCEDURE IsIImage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{4C599243-6926-101B-9992-00000B65C6F9}") END IsIImage; PROCEDURE ThisIWHTMLSubmitButton* (v: CtlT.Any): IWHTMLSubmitButton; VAR new: IWHTMLSubmitButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D111-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLSubmitButton; PROCEDURE IsIWHTMLSubmitButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D111-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLSubmitButton; PROCEDURE ThisIWHTMLImage* (v: CtlT.Any): IWHTMLImage; VAR new: IWHTMLImage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D113-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLImage; PROCEDURE IsIWHTMLImage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D113-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLImage; PROCEDURE ThisIWHTMLReset* (v: CtlT.Any): IWHTMLReset; VAR new: IWHTMLReset; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D115-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLReset; PROCEDURE IsIWHTMLReset* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D115-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLReset; PROCEDURE ThisIWHTMLCheckbox* (v: CtlT.Any): IWHTMLCheckbox; VAR new: IWHTMLCheckbox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D117-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLCheckbox; PROCEDURE IsIWHTMLCheckbox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D117-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLCheckbox; PROCEDURE ThisIWHTMLOption* (v: CtlT.Any): IWHTMLOption; VAR new: IWHTMLOption; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D119-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLOption; PROCEDURE IsIWHTMLOption* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D119-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLOption; PROCEDURE ThisIWHTMLText* (v: CtlT.Any): IWHTMLText; VAR new: IWHTMLText; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D11B-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLText; PROCEDURE IsIWHTMLText* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D11B-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLText; PROCEDURE ThisIWHTMLHidden* (v: CtlT.Any): IWHTMLHidden; VAR new: IWHTMLHidden; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D11D-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLHidden; PROCEDURE IsIWHTMLHidden* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D11D-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLHidden; PROCEDURE ThisIWHTMLPassword* (v: CtlT.Any): IWHTMLPassword; VAR new: IWHTMLPassword; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D11F-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLPassword; PROCEDURE IsIWHTMLPassword* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D11F-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLPassword; PROCEDURE ThisIWHTMLSelect* (v: CtlT.Any): IWHTMLSelect; VAR new: IWHTMLSelect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D123-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLSelect; PROCEDURE IsIWHTMLSelect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D123-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLSelect; PROCEDURE ThisIWHTMLTextArea* (v: CtlT.Any): IWHTMLTextArea; VAR new: IWHTMLTextArea; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5512D125-5CC6-11CF-8D67-00AA00BDCE1D}"); RETURN new ELSE RETURN NIL END END ThisIWHTMLTextArea; PROCEDURE IsIWHTMLTextArea* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5512D125-5CC6-11CF-8D67-00AA00BDCE1D}") END IsIWHTMLTextArea; PROCEDURE ThisIPage* (v: CtlT.Any): IPage; VAR new: IPage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{5CEF5613-713D-11CE-80C9-00AA00611080}"); RETURN new ELSE RETURN NIL END END ThisIPage; PROCEDURE IsIPage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{5CEF5613-713D-11CE-80C9-00AA00611080}") END IsIPage; PROCEDURE ThisPages* (v: CtlT.Any): Pages; VAR new: Pages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{92E11A03-7358-11CE-80CB-00AA00611080}"); RETURN new ELSE RETURN NIL END END ThisPages; PROCEDURE IsPages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{92E11A03-7358-11CE-80CB-00AA00611080}") END IsPages; PROCEDURE ThisIMultiPage* (v: CtlT.Any): IMultiPage; VAR new: IMultiPage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{04598FC9-866C-11CF-AB7C-00AA00C08FCF}"); RETURN new ELSE RETURN NIL END END ThisIMultiPage; PROCEDURE IsIMultiPage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{04598FC9-866C-11CF-AB7C-00AA00C08FCF}") END IsIMultiPage; (* ---------- Font ---------- *) PROCEDURE (this: Font) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Font) PUTName* (val: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, val) END PUTName; PROCEDURE (this: Font) Size* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END Size; PROCEDURE (this: Font) PUTSize* (val: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, val) END PUTSize; PROCEDURE (this: Font) Bold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END Bold; PROCEDURE (this: Font) PUTBold* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, val) END PUTBold; PROCEDURE (this: Font) Italic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END Italic; PROCEDURE (this: Font) PUTItalic* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, val) END PUTItalic; PROCEDURE (this: Font) Underline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Underline; PROCEDURE (this: Font) PUTUnderline* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, val) END PUTUnderline; PROCEDURE (this: Font) Strikethrough* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Strikethrough; PROCEDURE (this: Font) PUTStrikethrough* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, val) END PUTStrikethrough; PROCEDURE (this: Font) Weight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END Weight; PROCEDURE (this: Font) PUTWeight* (val: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, val) END PUTWeight; PROCEDURE (this: Font) Charset* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 8) END Charset; PROCEDURE (this: Font) PUTCharset* (val: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 8, val) END PUTCharset; (* ---------- IDataAutoWrapper, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IDataAutoWrapper) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 1610743808, NIL); END Clear; PROCEDURE (this: IDataAutoWrapper) GetFormat* (Format: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 1610743809, arg, ret); RETURN CtlC.VarBool(ret) END GetFormat; PROCEDURE (this: IDataAutoWrapper) GetText* ((* optional *) Format: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 1610743810, arg, ret); RETURN CtlC.VarStr(ret) END GetText; PROCEDURE (this: IDataAutoWrapper) SetText* (Text: ARRAY OF CHAR; (* optional *) Format: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 1610743811, arg, NIL); END SetText; PROCEDURE (this: IDataAutoWrapper) PutInClipboard* (), NEW; BEGIN CtlC.CallMethod(this, 1610743812, NIL); END PutInClipboard; PROCEDURE (this: IDataAutoWrapper) GetFromClipboard* (), NEW; BEGIN CtlC.CallMethod(this, 1610743813, NIL); END GetFromClipboard; PROCEDURE (this: IDataAutoWrapper) StartDrag* ((* optional *) OKEffect: CtlT.Any): fmDropEffect, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(OKEffect, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, ret); RETURN CtlC.VarInt(ret) END StartDrag; (* ---------- IReturnInteger, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IReturnInteger) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTValue; PROCEDURE (this: IReturnInteger) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Value; (* ---------- IReturnBoolean, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IReturnBoolean) PUTValue* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 0, p1) END PUTValue; PROCEDURE (this: IReturnBoolean) Value* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Value; (* ---------- IReturnString, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IReturnString) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: IReturnString) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; (* ---------- IReturnSingle, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IReturnSingle) PUTValue* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 0, p1) END PUTValue; PROCEDURE (this: IReturnSingle) Value* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 0) END Value; (* ---------- IReturnEffect, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IReturnEffect) PUTValue* (p1: fmDropEffect), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTValue; PROCEDURE (this: IReturnEffect) Value* (): fmDropEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Value; (* ---------- IControl, dual ---------- *) PROCEDURE (this: IControl) PUTCancel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418056, p1) END PUTCancel; PROCEDURE (this: IControl) Cancel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418056) END Cancel; PROCEDURE (this: IControl) PUTControlSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147385343, p1) END PUTControlSource; PROCEDURE (this: IControl) ControlSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147385343) END ControlSource; PROCEDURE (this: IControl) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418043, p1) END PUTControlTipText; PROCEDURE (this: IControl) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418043) END ControlTipText; PROCEDURE (this: IControl) PUTDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418057, p1) END PUTDefault; PROCEDURE (this: IControl) Default* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418057) END Default; PROCEDURE (this: IControl) _SetHeight* (Height: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 1610743816, arg, NIL); END _SetHeight; PROCEDURE (this: IControl) _GetHeight* (OUT Height: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Height, arg[0]); CtlC.CallParMethod(this, 1610743817, arg, NIL); END _GetHeight; PROCEDURE (this: IControl) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418106, p1) END PUTHeight; PROCEDURE (this: IControl) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418106) END Height; PROCEDURE (this: IControl) PUTHelpContextID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -2147418062, p1) END PUTHelpContextID; PROCEDURE (this: IControl) HelpContextID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147418062) END HelpContextID; PROCEDURE (this: IControl) PUTInSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147385341, p1) END PUTInSelection; PROCEDURE (this: IControl) InSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147385341) END InSelection; PROCEDURE (this: IControl) LayoutEffect* (): fmLayoutEffect, NEW; BEGIN RETURN CtlC.GetInt(this, -2147385340) END LayoutEffect; PROCEDURE (this: IControl) _SetLeft* (Left: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[0]); CtlC.CallParMethod(this, 1610743825, arg, NIL); END _SetLeft; PROCEDURE (this: IControl) _GetLeft* (OUT Left: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Left, arg[0]); CtlC.CallParMethod(this, 1610743826, arg, NIL); END _GetLeft; PROCEDURE (this: IControl) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418109, p1) END PUTLeft; PROCEDURE (this: IControl) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418109) END Left; PROCEDURE (this: IControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: IControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: IControl) _GetOldHeight* (OUT OldHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(OldHeight, arg[0]); CtlC.CallParMethod(this, 1610743831, arg, NIL); END _GetOldHeight; PROCEDURE (this: IControl) OldHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147385339) END OldHeight; PROCEDURE (this: IControl) _GetOldLeft* (OUT OldLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(OldLeft, arg[0]); CtlC.CallParMethod(this, 1610743833, arg, NIL); END _GetOldLeft; PROCEDURE (this: IControl) OldLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147385338) END OldLeft; PROCEDURE (this: IControl) _GetOldTop* (OUT OldTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(OldTop, arg[0]); CtlC.CallParMethod(this, 1610743835, arg, NIL); END _GetOldTop; PROCEDURE (this: IControl) OldTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147385337) END OldTop; PROCEDURE (this: IControl) _GetOldWidth* (OUT OldWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(OldWidth, arg[0]); CtlC.CallParMethod(this, 1610743837, arg, NIL); END _GetOldWidth; PROCEDURE (this: IControl) OldWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147385336) END OldWidth; PROCEDURE (this: IControl) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147385335) END Object; PROCEDURE (this: IControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147418104) END Parent; PROCEDURE (this: IControl) PUTRowSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147385330, p1) END PUTRowSource; PROCEDURE (this: IControl) RowSource* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147385330) END RowSource; PROCEDURE (this: IControl) PUTRowSourceType* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, -2147385329, p1) END PUTRowSourceType; PROCEDURE (this: IControl) RowSourceType* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, -2147385329) END RowSourceType; PROCEDURE (this: IControl) PUTTabIndex* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, -2147418097, p1) END PUTTabIndex; PROCEDURE (this: IControl) TabIndex* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, -2147418097) END TabIndex; PROCEDURE (this: IControl) PUTTabStop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418098, p1) END PUTTabStop; PROCEDURE (this: IControl) TabStop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418098) END TabStop; PROCEDURE (this: IControl) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418101, p1) END PUTTag; PROCEDURE (this: IControl) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418101) END Tag; PROCEDURE (this: IControl) _SetTop* (Top: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Top, arg[0]); CtlC.CallParMethod(this, 1610743851, arg, NIL); END _SetTop; PROCEDURE (this: IControl) _GetTop* (OUT Top: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Top, arg[0]); CtlC.CallParMethod(this, 1610743852, arg, NIL); END _GetTop; PROCEDURE (this: IControl) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418108, p1) END PUTTop; PROCEDURE (this: IControl) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418108) END Top; PROCEDURE (this: IControl) PUTBoundValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, -2147385328, p1) END PUTBoundValue; PROCEDURE (this: IControl) BoundValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -2147385328) END BoundValue; PROCEDURE (this: IControl) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418105, p1) END PUTVisible; PROCEDURE (this: IControl) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418105) END Visible; PROCEDURE (this: IControl) _SetWidth* (Width: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Width, arg[0]); CtlC.CallParMethod(this, 1610743859, arg, NIL); END _SetWidth; PROCEDURE (this: IControl) _GetWidth* (OUT Width: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Width, arg[0]); CtlC.CallParMethod(this, 1610743860, arg, NIL); END _GetWidth; PROCEDURE (this: IControl) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418107, p1) END PUTWidth; PROCEDURE (this: IControl) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418107) END Width; PROCEDURE (this: IControl) Move* ((* optional *) Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any; Layout: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Left, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Width, arg[2]); CtlC.AnyVar(Height, arg[1]); CtlC.AnyVar(Layout, arg[0]); CtlC.CallParMethod(this, -2147385088, arg, NIL); END Move; PROCEDURE (this: IControl) ZOrder* ((* optional *) zPosition: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(zPosition, arg[0]); CtlC.CallParMethod(this, -2147385083, arg, NIL); END ZOrder; PROCEDURE (this: IControl) Select* (SelectInGroup: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(SelectInGroup, arg[0]); CtlC.CallParMethod(this, -2147385086, arg, NIL); END Select; PROCEDURE (this: IControl) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, -2147385085, NIL); END SetFocus; PROCEDURE (this: IControl) _GethWnd* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743867, ret); RETURN CtlC.VarInt(ret) END _GethWnd; PROCEDURE (this: IControl) _GetID* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743868, ret); RETURN CtlC.VarInt(ret) END _GetID; PROCEDURE (this: IControl) _Move* (Left: INTEGER; Top: INTEGER; Width: INTEGER; Height: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[3]); CtlC.IntVar(Top, arg[2]); CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 1610743869, arg, NIL); END _Move; PROCEDURE (this: IControl) _ZOrder* (zPosition: fmZOrder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(zPosition, arg[0]); CtlC.CallParMethod(this, 1610743870, arg, NIL); END _ZOrder; (* ---------- Controls, dual ---------- *) PROCEDURE (this: Controls) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END Count; PROCEDURE (this: Controls) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Controls) Item* (varg: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Controls) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 62, NIL); END Clear; PROCEDURE (this: Controls) _Move* (cx: INTEGER; cy: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(cx, arg[1]); CtlC.IntVar(cy, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, NIL); END _Move; PROCEDURE (this: Controls) SelectAll* (), NEW; BEGIN CtlC.CallMethod(this, 65, NIL); END SelectAll; PROCEDURE (this: Controls) _AddByClass* (VAR clsid: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RefIntVar(clsid, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _AddByClass; PROCEDURE (this: Controls) AlignToGrid* (), NEW; BEGIN CtlC.CallMethod(this, 1610743815, NIL); END AlignToGrid; PROCEDURE (this: Controls) BringForward* (), NEW; BEGIN CtlC.CallMethod(this, 1610743816, NIL); END BringForward; PROCEDURE (this: Controls) BringToFront* (), NEW; BEGIN CtlC.CallMethod(this, 1610743817, NIL); END BringToFront; PROCEDURE (this: Controls) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 1610743818, NIL); END Copy; PROCEDURE (this: Controls) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 1610743819, NIL); END Cut; PROCEDURE (this: Controls) Enum* (): CtlT.IUnknown, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743820, ret); RETURN CtlC.VarIntfce(ret) END Enum; PROCEDURE (this: Controls) _GetItemByIndex* (lIndex: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lIndex, arg[0]); CtlC.CallParMethod(this, 1610743821, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _GetItemByIndex; PROCEDURE (this: Controls) _GetItemByName* (pstr: ARRAY OF CHAR): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(pstr, arg[0]); CtlC.CallParMethod(this, 1610743822, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _GetItemByName; PROCEDURE (this: Controls) _GetItemByID* (ID: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ID, arg[0]); CtlC.CallParMethod(this, 1610743823, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _GetItemByID; PROCEDURE (this: Controls) SendBackward* (), NEW; BEGIN CtlC.CallMethod(this, 1610743824, NIL); END SendBackward; PROCEDURE (this: Controls) SendToBack* (), NEW; BEGIN CtlC.CallMethod(this, 1610743825, NIL); END SendToBack; PROCEDURE (this: Controls) Move* (cx: SHORTREAL; cy: SHORTREAL), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(cx, arg[1]); CtlC.SRealVar(cy, arg[0]); CtlC.CallParMethod(this, 63, arg, NIL); END Move; PROCEDURE (this: Controls) Add* (bstrProgID: ARRAY OF CHAR; (* optional *) Name: CtlT.Any; Visible: CtlT.Any): Control, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrProgID, arg[2]); CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(Visible, arg[0]); CtlC.CallParMethod(this, 66, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Controls) Remove* (varg: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 67, arg, NIL); END Remove; (* ---------- IOptionFrame, hidden, dual ---------- *) PROCEDURE (this: IOptionFrame) ActiveControl* (): Control, NEW; BEGIN RETURN ThisIControl(CtlC.GetAny(this, 256)) END ActiveControl; PROCEDURE (this: IOptionFrame) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IOptionFrame) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IOptionFrame) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: IOptionFrame) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: IOptionFrame) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: IOptionFrame) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: IOptionFrame) CanPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 257) END CanPaste; PROCEDURE (this: IOptionFrame) CanRedo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 258) END CanRedo; PROCEDURE (this: IOptionFrame) CanUndo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 259) END CanUndo; PROCEDURE (this: IOptionFrame) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: IOptionFrame) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: IOptionFrame) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: IOptionFrame) PUTCycle* (p1: fmCycle), NEW; BEGIN CtlC.PutInt(this, 260, p1) END PUTCycle; PROCEDURE (this: IOptionFrame) Cycle* (): fmCycle, NEW; BEGIN RETURN CtlC.GetInt(this, 260) END Cycle; PROCEDURE (this: IOptionFrame) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IOptionFrame) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IOptionFrame) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IOptionFrame) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IOptionFrame) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IOptionFrame) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IOptionFrame) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IOptionFrame) _GetInsideHeight* (OUT InsideHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideHeight, arg[0]); CtlC.CallParMethod(this, 1610743830, arg, NIL); END _GetInsideHeight; PROCEDURE (this: IOptionFrame) InsideHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 262) END InsideHeight; PROCEDURE (this: IOptionFrame) _GetInsideWidth* (OUT InsideWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideWidth, arg[0]); CtlC.CallParMethod(this, 1610743832, arg, NIL); END _GetInsideWidth; PROCEDURE (this: IOptionFrame) InsideWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 263) END InsideWidth; PROCEDURE (this: IOptionFrame) PUTKeepScrollBarsVisible* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 264, p1) END PUTKeepScrollBarsVisible; PROCEDURE (this: IOptionFrame) KeepScrollBarsVisible* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 264) END KeepScrollBarsVisible; PROCEDURE (this: IOptionFrame) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IOptionFrame) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IOptionFrame) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IOptionFrame) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IOptionFrame) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IOptionFrame) PUTPictureAlignment* (p1: fmPictureAlignment), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTPictureAlignment; PROCEDURE (this: IOptionFrame) PictureAlignment* (): fmPictureAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END PictureAlignment; PROCEDURE (this: IOptionFrame) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IOptionFrame) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IOptionFrame) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IOptionFrame) PUTPictureSizeMode* (p1: fmPictureSizeMode), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTPictureSizeMode; PROCEDURE (this: IOptionFrame) PictureSizeMode* (): fmPictureSizeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END PictureSizeMode; PROCEDURE (this: IOptionFrame) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTPictureTiling; PROCEDURE (this: IOptionFrame) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END PictureTiling; PROCEDURE (this: IOptionFrame) PUTScrollBars* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 265, p1) END PUTScrollBars; PROCEDURE (this: IOptionFrame) ScrollBars* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 265) END ScrollBars; PROCEDURE (this: IOptionFrame) _SetScrollHeight* (ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743852, arg, NIL); END _SetScrollHeight; PROCEDURE (this: IOptionFrame) _GetScrollHeight* (OUT ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743853, arg, NIL); END _GetScrollHeight; PROCEDURE (this: IOptionFrame) PUTScrollHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 266, p1) END PUTScrollHeight; PROCEDURE (this: IOptionFrame) ScrollHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 266) END ScrollHeight; PROCEDURE (this: IOptionFrame) _SetScrollLeft* (ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743856, arg, NIL); END _SetScrollLeft; PROCEDURE (this: IOptionFrame) _GetScrollLeft* (OUT ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743857, arg, NIL); END _GetScrollLeft; PROCEDURE (this: IOptionFrame) PUTScrollLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 267, p1) END PUTScrollLeft; PROCEDURE (this: IOptionFrame) ScrollLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 267) END ScrollLeft; PROCEDURE (this: IOptionFrame) _SetScrollTop* (ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743860, arg, NIL); END _SetScrollTop; PROCEDURE (this: IOptionFrame) _GetScrollTop* (OUT ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743861, arg, NIL); END _GetScrollTop; PROCEDURE (this: IOptionFrame) PUTScrollTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 268, p1) END PUTScrollTop; PROCEDURE (this: IOptionFrame) ScrollTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 268) END ScrollTop; PROCEDURE (this: IOptionFrame) _SetScrollWidth* (ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743864, arg, NIL); END _SetScrollWidth; PROCEDURE (this: IOptionFrame) _GetScrollWidth* (OUT ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743865, arg, NIL); END _GetScrollWidth; PROCEDURE (this: IOptionFrame) PUTScrollWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 269, p1) END PUTScrollWidth; PROCEDURE (this: IOptionFrame) ScrollWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 269) END ScrollWidth; PROCEDURE (this: IOptionFrame) Selected* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 270)) END Selected; PROCEDURE (this: IOptionFrame) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IOptionFrame) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IOptionFrame) PUTVerticalScrollBarSide* (p1: fmVerticalScrollBarSide), NEW; BEGIN CtlC.PutInt(this, 271, p1) END PUTVerticalScrollBarSide; PROCEDURE (this: IOptionFrame) VerticalScrollBarSide* (): fmVerticalScrollBarSide, NEW; BEGIN RETURN CtlC.GetInt(this, 271) END VerticalScrollBarSide; PROCEDURE (this: IOptionFrame) PUTZoom* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 272, p1) END PUTZoom; PROCEDURE (this: IOptionFrame) Zoom* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 272) END Zoom; PROCEDURE (this: IOptionFrame) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 512, NIL); END Copy; PROCEDURE (this: IOptionFrame) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 513, NIL); END Cut; PROCEDURE (this: IOptionFrame) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 514, NIL); END Paste; PROCEDURE (this: IOptionFrame) RedoAction* (), NEW; BEGIN CtlC.CallMethod(this, 515, NIL); END RedoAction; PROCEDURE (this: IOptionFrame) Repaint* (), NEW; BEGIN CtlC.CallMethod(this, 516, NIL); END Repaint; PROCEDURE (this: IOptionFrame) Scroll* ((* optional *) xAction: CtlT.Any; yAction: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(xAction, arg[1]); CtlC.AnyVar(yAction, arg[0]); CtlC.CallParMethod(this, 517, arg, NIL); END Scroll; PROCEDURE (this: IOptionFrame) SetDefaultTabOrder* (), NEW; BEGIN CtlC.CallMethod(this, 518, NIL); END SetDefaultTabOrder; PROCEDURE (this: IOptionFrame) UndoAction* (), NEW; BEGIN CtlC.CallMethod(this, 519, NIL); END UndoAction; PROCEDURE (this: IOptionFrame) PUTDesignMode* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 384, p1) END PUTDesignMode; PROCEDURE (this: IOptionFrame) DesignMode* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 384) END DesignMode; PROCEDURE (this: IOptionFrame) PUTShowToolbox* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 385, p1) END PUTShowToolbox; PROCEDURE (this: IOptionFrame) ShowToolbox* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 385) END ShowToolbox; PROCEDURE (this: IOptionFrame) PUTShowGridDots* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 386, p1) END PUTShowGridDots; PROCEDURE (this: IOptionFrame) ShowGridDots* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 386) END ShowGridDots; PROCEDURE (this: IOptionFrame) PUTSnapToGrid* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 387, p1) END PUTSnapToGrid; PROCEDURE (this: IOptionFrame) SnapToGrid* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 387) END SnapToGrid; PROCEDURE (this: IOptionFrame) PUTGridX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 388, p1) END PUTGridX; PROCEDURE (this: IOptionFrame) GridX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 388) END GridX; PROCEDURE (this: IOptionFrame) _SetGridX* (GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743893, arg, NIL); END _SetGridX; PROCEDURE (this: IOptionFrame) _GetGridX* (OUT GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743894, arg, NIL); END _GetGridX; PROCEDURE (this: IOptionFrame) PUTGridY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 389, p1) END PUTGridY; PROCEDURE (this: IOptionFrame) GridY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 389) END GridY; PROCEDURE (this: IOptionFrame) _SetGridY* (GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743897, arg, NIL); END _SetGridY; PROCEDURE (this: IOptionFrame) _GetGridY* (OUT GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743898, arg, NIL); END _GetGridY; (* ---------- _UserForm, hidden, dual ---------- *) PROCEDURE (this: _UserForm) ActiveControl* (): Control, NEW; BEGIN RETURN ThisIControl(CtlC.GetAny(this, 256)) END ActiveControl; PROCEDURE (this: _UserForm) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: _UserForm) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: _UserForm) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: _UserForm) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: _UserForm) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: _UserForm) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: _UserForm) CanPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 257) END CanPaste; PROCEDURE (this: _UserForm) CanRedo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 258) END CanRedo; PROCEDURE (this: _UserForm) CanUndo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 259) END CanUndo; PROCEDURE (this: _UserForm) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: _UserForm) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: _UserForm) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: _UserForm) PUTCycle* (p1: fmCycle), NEW; BEGIN CtlC.PutInt(this, 260, p1) END PUTCycle; PROCEDURE (this: _UserForm) Cycle* (): fmCycle, NEW; BEGIN RETURN CtlC.GetInt(this, 260) END Cycle; PROCEDURE (this: _UserForm) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: _UserForm) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: _UserForm) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: _UserForm) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: _UserForm) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: _UserForm) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: _UserForm) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: _UserForm) _GetInsideHeight* (OUT InsideHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideHeight, arg[0]); CtlC.CallParMethod(this, 1610743830, arg, NIL); END _GetInsideHeight; PROCEDURE (this: _UserForm) InsideHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 262) END InsideHeight; PROCEDURE (this: _UserForm) _GetInsideWidth* (OUT InsideWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideWidth, arg[0]); CtlC.CallParMethod(this, 1610743832, arg, NIL); END _GetInsideWidth; PROCEDURE (this: _UserForm) InsideWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 263) END InsideWidth; PROCEDURE (this: _UserForm) PUTKeepScrollBarsVisible* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 264, p1) END PUTKeepScrollBarsVisible; PROCEDURE (this: _UserForm) KeepScrollBarsVisible* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 264) END KeepScrollBarsVisible; PROCEDURE (this: _UserForm) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: _UserForm) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: _UserForm) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: _UserForm) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: _UserForm) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: _UserForm) PUTPictureAlignment* (p1: fmPictureAlignment), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTPictureAlignment; PROCEDURE (this: _UserForm) PictureAlignment* (): fmPictureAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END PictureAlignment; PROCEDURE (this: _UserForm) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: _UserForm) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: _UserForm) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: _UserForm) PUTPictureSizeMode* (p1: fmPictureSizeMode), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTPictureSizeMode; PROCEDURE (this: _UserForm) PictureSizeMode* (): fmPictureSizeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END PictureSizeMode; PROCEDURE (this: _UserForm) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTPictureTiling; PROCEDURE (this: _UserForm) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END PictureTiling; PROCEDURE (this: _UserForm) PUTScrollBars* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 265, p1) END PUTScrollBars; PROCEDURE (this: _UserForm) ScrollBars* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 265) END ScrollBars; PROCEDURE (this: _UserForm) _SetScrollHeight* (ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743852, arg, NIL); END _SetScrollHeight; PROCEDURE (this: _UserForm) _GetScrollHeight* (OUT ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743853, arg, NIL); END _GetScrollHeight; PROCEDURE (this: _UserForm) PUTScrollHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 266, p1) END PUTScrollHeight; PROCEDURE (this: _UserForm) ScrollHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 266) END ScrollHeight; PROCEDURE (this: _UserForm) _SetScrollLeft* (ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743856, arg, NIL); END _SetScrollLeft; PROCEDURE (this: _UserForm) _GetScrollLeft* (OUT ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743857, arg, NIL); END _GetScrollLeft; PROCEDURE (this: _UserForm) PUTScrollLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 267, p1) END PUTScrollLeft; PROCEDURE (this: _UserForm) ScrollLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 267) END ScrollLeft; PROCEDURE (this: _UserForm) _SetScrollTop* (ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743860, arg, NIL); END _SetScrollTop; PROCEDURE (this: _UserForm) _GetScrollTop* (OUT ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743861, arg, NIL); END _GetScrollTop; PROCEDURE (this: _UserForm) PUTScrollTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 268, p1) END PUTScrollTop; PROCEDURE (this: _UserForm) ScrollTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 268) END ScrollTop; PROCEDURE (this: _UserForm) _SetScrollWidth* (ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743864, arg, NIL); END _SetScrollWidth; PROCEDURE (this: _UserForm) _GetScrollWidth* (OUT ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743865, arg, NIL); END _GetScrollWidth; PROCEDURE (this: _UserForm) PUTScrollWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 269, p1) END PUTScrollWidth; PROCEDURE (this: _UserForm) ScrollWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 269) END ScrollWidth; PROCEDURE (this: _UserForm) Selected* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 270)) END Selected; PROCEDURE (this: _UserForm) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: _UserForm) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: _UserForm) PUTVerticalScrollBarSide* (p1: fmVerticalScrollBarSide), NEW; BEGIN CtlC.PutInt(this, 271, p1) END PUTVerticalScrollBarSide; PROCEDURE (this: _UserForm) VerticalScrollBarSide* (): fmVerticalScrollBarSide, NEW; BEGIN RETURN CtlC.GetInt(this, 271) END VerticalScrollBarSide; PROCEDURE (this: _UserForm) PUTZoom* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 272, p1) END PUTZoom; PROCEDURE (this: _UserForm) Zoom* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 272) END Zoom; PROCEDURE (this: _UserForm) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 512, NIL); END Copy; PROCEDURE (this: _UserForm) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 513, NIL); END Cut; PROCEDURE (this: _UserForm) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 514, NIL); END Paste; PROCEDURE (this: _UserForm) RedoAction* (), NEW; BEGIN CtlC.CallMethod(this, 515, NIL); END RedoAction; PROCEDURE (this: _UserForm) Repaint* (), NEW; BEGIN CtlC.CallMethod(this, 516, NIL); END Repaint; PROCEDURE (this: _UserForm) Scroll* ((* optional *) xAction: CtlT.Any; yAction: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(xAction, arg[1]); CtlC.AnyVar(yAction, arg[0]); CtlC.CallParMethod(this, 517, arg, NIL); END Scroll; PROCEDURE (this: _UserForm) SetDefaultTabOrder* (), NEW; BEGIN CtlC.CallMethod(this, 518, NIL); END SetDefaultTabOrder; PROCEDURE (this: _UserForm) UndoAction* (), NEW; BEGIN CtlC.CallMethod(this, 519, NIL); END UndoAction; PROCEDURE (this: _UserForm) PUTDesignMode* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 384, p1) END PUTDesignMode; PROCEDURE (this: _UserForm) DesignMode* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 384) END DesignMode; PROCEDURE (this: _UserForm) PUTShowToolbox* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 385, p1) END PUTShowToolbox; PROCEDURE (this: _UserForm) ShowToolbox* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 385) END ShowToolbox; PROCEDURE (this: _UserForm) PUTShowGridDots* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 386, p1) END PUTShowGridDots; PROCEDURE (this: _UserForm) ShowGridDots* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 386) END ShowGridDots; PROCEDURE (this: _UserForm) PUTSnapToGrid* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 387, p1) END PUTSnapToGrid; PROCEDURE (this: _UserForm) SnapToGrid* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 387) END SnapToGrid; PROCEDURE (this: _UserForm) PUTGridX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 388, p1) END PUTGridX; PROCEDURE (this: _UserForm) GridX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 388) END GridX; PROCEDURE (this: _UserForm) _SetGridX* (GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743893, arg, NIL); END _SetGridX; PROCEDURE (this: _UserForm) _GetGridX* (OUT GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743894, arg, NIL); END _GetGridX; PROCEDURE (this: _UserForm) PUTGridY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 389, p1) END PUTGridY; PROCEDURE (this: _UserForm) GridY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 389) END GridY; PROCEDURE (this: _UserForm) _SetGridY* (GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743897, arg, NIL); END _SetGridY; PROCEDURE (this: _UserForm) _GetGridY* (OUT GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743898, arg, NIL); END _GetGridY; PROCEDURE (this: _UserForm) PUTDrawBuffer* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 395, p1) END PUTDrawBuffer; PROCEDURE (this: _UserForm) DrawBuffer* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 395) END DrawBuffer; (* ---------- ControlEvents, hidden ---------- *) PROCEDURE (this: ControlEvents) Enter* (), NEW, ABSTRACT; PROCEDURE (this: ControlEvents) Exit* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: ControlEvents) BeforeUpdate* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: ControlEvents) AfterUpdate* (), NEW, ABSTRACT; PROCEDURE (this: ControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -2147384830: ASSERT(n = 0, 11); this.Enter() | -2147384829: ASSERT(n = 1, 11); this.Exit(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -2147384831: ASSERT(n = 1, 11); this.BeforeUpdate(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -2147384832: ASSERT(n = 0, 11); this.AfterUpdate() END END Invoke; PROCEDURE (this: ControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{9A4BBF53-4E46-101B-8BBD-00AA003E3B29}" END GetIID; (* ---------- FormEvents, hidden ---------- *) PROCEDURE (this: FormEvents) AddControl* (control: Control), NEW, ABSTRACT; PROCEDURE (this: FormEvents) BeforeDragOver* (Cancel: ReturnBoolean; control: Control; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; State: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: FormEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; control: Control; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: FormEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: FormEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: FormEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: FormEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Layout* (), NEW, ABSTRACT; PROCEDURE (this: FormEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: FormEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: FormEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: FormEvents) RemoveControl* (control: Control), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Scroll* (ActionX: fmScrollAction; ActionY: fmScrollAction; RequestDx: SHORTREAL; RequestDy: SHORTREAL; ActualDx: ReturnSingle; ActualDy: ReturnSingle), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Zoom* (VAR Percent: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: FormEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 768: ASSERT(n = 1, 11); this.AddControl(ThisIControl(CtlC.VarAny(par[0]))) | 3: ASSERT(n = 8, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 8, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -600: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 770: ASSERT(n = 0, 11); this.Layout() | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | 771: ASSERT(n = 1, 11); this.RemoveControl(ThisIControl(CtlC.VarAny(par[0]))) | 772: ASSERT(n = 6, 11); this.Scroll(CtlC.VarInt(par[5]), CtlC.VarInt(par[4]), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnSingle(CtlC.VarAny(par[1])), ThisIReturnSingle(CtlC.VarAny(par[0]))) | 773: ASSERT(n = 1, 11); this.Zoom(CtlC.VarRefSInt(par[0])[0]) END END Invoke; PROCEDURE (this: FormEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{5B9D8FC8-4A71-101B-97A6-00000B65C08B}" END GetIID; (* ---------- OptionFrameEvents, hidden ---------- *) PROCEDURE (this: OptionFrameEvents) AddControl* (control: Control), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) BeforeDragOver* (Cancel: ReturnBoolean; control: Control; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; State: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; control: Control; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Layout* (), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) RemoveControl* (control: Control), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Scroll* (ActionX: fmScrollAction; ActionY: fmScrollAction; RequestDx: SHORTREAL; RequestDy: SHORTREAL; ActualDx: ReturnSingle; ActualDy: ReturnSingle), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Zoom* (VAR Percent: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: OptionFrameEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 768: ASSERT(n = 1, 11); this.AddControl(ThisIControl(CtlC.VarAny(par[0]))) | 3: ASSERT(n = 8, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 8, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -600: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 770: ASSERT(n = 0, 11); this.Layout() | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | 771: ASSERT(n = 1, 11); this.RemoveControl(ThisIControl(CtlC.VarAny(par[0]))) | 772: ASSERT(n = 6, 11); this.Scroll(CtlC.VarInt(par[5]), CtlC.VarInt(par[4]), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnSingle(CtlC.VarAny(par[1])), ThisIReturnSingle(CtlC.VarAny(par[0]))) | 773: ASSERT(n = 1, 11); this.Zoom(CtlC.VarRefSInt(par[0])[0]) END END Invoke; PROCEDURE (this: OptionFrameEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{CF3F94A0-F546-11CE-9BCE-00AA00608E01}" END GetIID; (* ---------- ILabelControl, hidden, dual ---------- *) PROCEDURE (this: ILabelControl) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: ILabelControl) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: ILabelControl) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: ILabelControl) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: ILabelControl) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: ILabelControl) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: ILabelControl) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: ILabelControl) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: ILabelControl) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: ILabelControl) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: ILabelControl) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTCaption; PROCEDURE (this: ILabelControl) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Caption; PROCEDURE (this: ILabelControl) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: ILabelControl) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: ILabelControl) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: ILabelControl) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: ILabelControl) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: ILabelControl) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: ILabelControl) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: ILabelControl) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: ILabelControl) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: ILabelControl) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: ILabelControl) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: ILabelControl) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: ILabelControl) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: ILabelControl) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: ILabelControl) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: ILabelControl) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: ILabelControl) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: ILabelControl) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: ILabelControl) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: ILabelControl) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: ILabelControl) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: ILabelControl) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: ILabelControl) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: ILabelControl) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: ILabelControl) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: ILabelControl) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: ILabelControl) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: ILabelControl) PUTPicturePosition* (p1: fmPicturePosition), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTPicturePosition; PROCEDURE (this: ILabelControl) PicturePosition* (): fmPicturePosition, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END PicturePosition; PROCEDURE (this: ILabelControl) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: ILabelControl) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: ILabelControl) PUTTextAlign* (p1: fmTextAlign), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTTextAlign; PROCEDURE (this: ILabelControl) TextAlign* (): fmTextAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END TextAlign; PROCEDURE (this: ILabelControl) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: ILabelControl) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: ILabelControl) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: ILabelControl) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: ILabelControl) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: ILabelControl) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: ILabelControl) PUT_Value* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUT_Value; PROCEDURE (this: ILabelControl) _Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END _Value; (* ---------- ICommandButton, hidden, dual ---------- *) PROCEDURE (this: ICommandButton) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: ICommandButton) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: ICommandButton) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: ICommandButton) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: ICommandButton) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: ICommandButton) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: ICommandButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: ICommandButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: ICommandButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: ICommandButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: ICommandButton) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: ICommandButton) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: ICommandButton) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: ICommandButton) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: ICommandButton) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: ICommandButton) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: ICommandButton) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: ICommandButton) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: ICommandButton) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: ICommandButton) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: ICommandButton) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: ICommandButton) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: ICommandButton) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: ICommandButton) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: ICommandButton) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: ICommandButton) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: ICommandButton) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: ICommandButton) PUTTakeFocusOnClick* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 203, p1) END PUTTakeFocusOnClick; PROCEDURE (this: ICommandButton) TakeFocusOnClick* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 203) END TakeFocusOnClick; PROCEDURE (this: ICommandButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: ICommandButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: ICommandButton) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: ICommandButton) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: ICommandButton) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: ICommandButton) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: ICommandButton) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: ICommandButton) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: ICommandButton) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: ICommandButton) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: ICommandButton) PUTPicturePosition* (p1: fmPicturePosition), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTPicturePosition; PROCEDURE (this: ICommandButton) PicturePosition* (): fmPicturePosition, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END PicturePosition; PROCEDURE (this: ICommandButton) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: ICommandButton) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: ICommandButton) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: ICommandButton) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: ICommandButton) PUTValue* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 0, p1) END PUTValue; PROCEDURE (this: ICommandButton) Value* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Value; PROCEDURE (this: ICommandButton) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: ICommandButton) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; (* ---------- IMdcText, hidden, dual ---------- *) PROCEDURE (this: IMdcText) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IMdcText) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IMdcText) PUTAutoTab* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 217, p1) END PUTAutoTab; PROCEDURE (this: IMdcText) AutoTab* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 217) END AutoTab; PROCEDURE (this: IMdcText) PUTAutoWordSelect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 218, p1) END PUTAutoWordSelect; PROCEDURE (this: IMdcText) AutoWordSelect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 218) END AutoWordSelect; PROCEDURE (this: IMdcText) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcText) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcText) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IMdcText) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IMdcText) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: IMdcText) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: IMdcText) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: IMdcText) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: IMdcText) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcText) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcText) CanPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END CanPaste; PROCEDURE (this: IMdcText) PUTCurLine* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 212, p1) END PUTCurLine; PROCEDURE (this: IMdcText) CurLine* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 212) END CurLine; PROCEDURE (this: IMdcText) CurTargetX* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 210) END CurTargetX; PROCEDURE (this: IMdcText) CurTargetY* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 221) END CurTargetY; PROCEDURE (this: IMdcText) PUTCurX* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 208, p1) END PUTCurX; PROCEDURE (this: IMdcText) CurX* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 208) END CurX; PROCEDURE (this: IMdcText) PUTCurY* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 209, p1) END PUTCurY; PROCEDURE (this: IMdcText) CurY* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 209) END CurY; PROCEDURE (this: IMdcText) PUTDropButtonStyle* (p1: fmDropButtonStyle), NEW; BEGIN CtlC.PutInt(this, 305, p1) END PUTDropButtonStyle; PROCEDURE (this: IMdcText) DropButtonStyle* (): fmDropButtonStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 305) END DropButtonStyle; PROCEDURE (this: IMdcText) PUTEnterKeyBehavior* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -544, p1) END PUTEnterKeyBehavior; PROCEDURE (this: IMdcText) EnterKeyBehavior* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -544) END EnterKeyBehavior; PROCEDURE (this: IMdcText) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcText) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcText) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcText) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcText) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcText) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcText) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcText) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcText) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcText) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcText) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcText) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcText) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcText) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcText) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcText) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcText) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcText) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcText) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcText) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcText) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcText) PUTHideSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 207, p1) END PUTHideSelection; PROCEDURE (this: IMdcText) HideSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 207) END HideSelection; PROCEDURE (this: IMdcText) PUTIntegralHeight* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 604, p1) END PUTIntegralHeight; PROCEDURE (this: IMdcText) IntegralHeight* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 604) END IntegralHeight; PROCEDURE (this: IMdcText) LineCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 214) END LineCount; PROCEDURE (this: IMdcText) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcText) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcText) PUTMaxLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -533, p1) END PUTMaxLength; PROCEDURE (this: IMdcText) MaxLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -533) END MaxLength; PROCEDURE (this: IMdcText) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcText) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcText) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcText) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcText) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcText) PUTMultiLine* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -537, p1) END PUTMultiLine; PROCEDURE (this: IMdcText) MultiLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -537) END MultiLine; PROCEDURE (this: IMdcText) PUTPasswordChar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -534, p1) END PUTPasswordChar; PROCEDURE (this: IMdcText) PasswordChar* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -534) END PasswordChar; PROCEDURE (this: IMdcText) PUTScrollBars* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, -535, p1) END PUTScrollBars; PROCEDURE (this: IMdcText) ScrollBars* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, -535) END ScrollBars; PROCEDURE (this: IMdcText) PUTSelectionMargin* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 220, p1) END PUTSelectionMargin; PROCEDURE (this: IMdcText) SelectionMargin* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 220) END SelectionMargin; PROCEDURE (this: IMdcText) PUTSelLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -548, p1) END PUTSelLength; PROCEDURE (this: IMdcText) SelLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -548) END SelLength; PROCEDURE (this: IMdcText) PUTSelStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -547, p1) END PUTSelStart; PROCEDURE (this: IMdcText) SelStart* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -547) END SelStart; PROCEDURE (this: IMdcText) PUTSelText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -546, p1) END PUTSelText; PROCEDURE (this: IMdcText) SelText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -546) END SelText; PROCEDURE (this: IMdcText) PUTShowDropButtonWhen* (p1: fmShowDropButtonWhen), NEW; BEGIN CtlC.PutInt(this, 304, p1) END PUTShowDropButtonWhen; PROCEDURE (this: IMdcText) ShowDropButtonWhen* (): fmShowDropButtonWhen, NEW; BEGIN RETURN CtlC.GetInt(this, 304) END ShowDropButtonWhen; PROCEDURE (this: IMdcText) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcText) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcText) PUTTabKeyBehavior* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -545, p1) END PUTTabKeyBehavior; PROCEDURE (this: IMdcText) TabKeyBehavior* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -545) END TabKeyBehavior; PROCEDURE (this: IMdcText) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -517, p1) END PUTText; PROCEDURE (this: IMdcText) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -517) END Text; PROCEDURE (this: IMdcText) PUTTextAlign* (p1: fmTextAlign), NEW; BEGIN CtlC.PutInt(this, 10004, p1) END PUTTextAlign; PROCEDURE (this: IMdcText) TextAlign* (): fmTextAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 10004) END TextAlign; PROCEDURE (this: IMdcText) TextLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 216) END TextLength; PROCEDURE (this: IMdcText) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcText) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcText) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcText) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: IMdcText) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: IMdcText) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END Copy; PROCEDURE (this: IMdcText) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 21, NIL); END Cut; PROCEDURE (this: IMdcText) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 24, NIL); END Paste; PROCEDURE (this: IMdcText) PUTIMEMode* (p1: fmIMEMode), NEW; BEGIN CtlC.PutInt(this, -542, p1) END PUTIMEMode; PROCEDURE (this: IMdcText) IMEMode* (): fmIMEMode, NEW; BEGIN RETURN CtlC.GetInt(this, -542) END IMEMode; PROCEDURE (this: IMdcText) PUTEnterFieldBehavior* (p1: fmEnterFieldBehavior), NEW; BEGIN CtlC.PutInt(this, 224, p1) END PUTEnterFieldBehavior; PROCEDURE (this: IMdcText) EnterFieldBehavior* (): fmEnterFieldBehavior, NEW; BEGIN RETURN CtlC.GetInt(this, 224) END EnterFieldBehavior; PROCEDURE (this: IMdcText) PUTDragBehavior* (p1: fmDragBehavior), NEW; BEGIN CtlC.PutInt(this, 225, p1) END PUTDragBehavior; PROCEDURE (this: IMdcText) DragBehavior* (): fmDragBehavior, NEW; BEGIN RETURN CtlC.GetInt(this, 225) END DragBehavior; PROCEDURE (this: IMdcText) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; (* ---------- IMdcList, hidden, dual ---------- *) PROCEDURE (this: IMdcList) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcList) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcList) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: IMdcList) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: IMdcList) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: IMdcList) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: IMdcList) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcList) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcList) PUTBoundColumn* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 501, p1) END PUTBoundColumn; PROCEDURE (this: IMdcList) BoundColumn* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 501) END BoundColumn; PROCEDURE (this: IMdcList) PUTColumnCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 601, p1) END PUTColumnCount; PROCEDURE (this: IMdcList) ColumnCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 601) END ColumnCount; PROCEDURE (this: IMdcList) PUTColumnHeads* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 602, p1) END PUTColumnHeads; PROCEDURE (this: IMdcList) ColumnHeads* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 602) END ColumnHeads; PROCEDURE (this: IMdcList) PUTColumnWidths* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 603, p1) END PUTColumnWidths; PROCEDURE (this: IMdcList) ColumnWidths* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 603) END ColumnWidths; PROCEDURE (this: IMdcList) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcList) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcList) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcList) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcList) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcList) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcList) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcList) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcList) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcList) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcList) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcList) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcList) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcList) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcList) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcList) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcList) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcList) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcList) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcList) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcList) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcList) PUTIntegralHeight* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 604, p1) END PUTIntegralHeight; PROCEDURE (this: IMdcList) IntegralHeight* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 604) END IntegralHeight; PROCEDURE (this: IMdcList) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -531) END ListCount; PROCEDURE (this: IMdcList) PUTListCursor* (p1: CtlT.IUnknown), NEW; BEGIN CtlC.PutIntfce(this, 403, p1) END PUTListCursor; PROCEDURE (this: IMdcList) ListCursor* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 403) END ListCursor; PROCEDURE (this: IMdcList) PUTListIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, -526, p1) END PUTListIndex; PROCEDURE (this: IMdcList) ListIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -526) END ListIndex; PROCEDURE (this: IMdcList) PUTListStyle* (p1: fmListStyle), NEW; BEGIN CtlC.PutInt(this, 307, p1) END PUTListStyle; PROCEDURE (this: IMdcList) ListStyle* (): fmListStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 307) END ListStyle; PROCEDURE (this: IMdcList) PUTListWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 606, p1) END PUTListWidth; PROCEDURE (this: IMdcList) ListWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 606) END ListWidth; PROCEDURE (this: IMdcList) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcList) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcList) PUTMatchEntry* (p1: fmMatchEntry), NEW; BEGIN CtlC.PutInt(this, 504, p1) END PUTMatchEntry; PROCEDURE (this: IMdcList) MatchEntry* (): fmMatchEntry, NEW; BEGIN RETURN CtlC.GetInt(this, 504) END MatchEntry; PROCEDURE (this: IMdcList) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcList) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcList) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcList) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcList) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcList) PUTMultiSelect* (p1: fmMultiSelect), NEW; BEGIN CtlC.PutInt(this, -532, p1) END PUTMultiSelect; PROCEDURE (this: IMdcList) MultiSelect* (): fmMultiSelect, NEW; BEGIN RETURN CtlC.GetInt(this, -532) END MultiSelect; PROCEDURE (this: IMdcList) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcList) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcList) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -517, p1) END PUTText; PROCEDURE (this: IMdcList) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -517) END Text; PROCEDURE (this: IMdcList) PUTTextColumn* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 502, p1) END PUTTextColumn; PROCEDURE (this: IMdcList) TextColumn* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 502) END TextColumn; PROCEDURE (this: IMdcList) PUTTopIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTTopIndex; PROCEDURE (this: IMdcList) TopIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END TopIndex; PROCEDURE (this: IMdcList) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcList) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcList) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcList) Column* ((* optional *) pvargColumn: CtlT.Any; pvargIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(pvargColumn, arg[1]); CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallGetMethod(this, -529, arg, ret); RETURN CtlC.VarAny(ret) END Column; PROCEDURE (this: IMdcList) PUTColumn* (pvargColumn: CtlT.Any; (* optional *) pvargIndex: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargColumn, arg[2]); CtlC.AnyVar(pvargIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, -529, arg, NIL); END PUTColumn; PROCEDURE (this: IMdcList) List* ((* optional *) pvargIndex: CtlT.Any; pvargColumn: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[1]); CtlC.AnyVar(pvargColumn, arg[0]); CtlC.CallGetMethod(this, -528, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: IMdcList) PUTList* (pvargIndex: CtlT.Any; (* optional *) pvargColumn: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[2]); CtlC.AnyVar(pvargColumn, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, -528, arg, NIL); END PUTList; PROCEDURE (this: IMdcList) Selected* (pvargIndex: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallGetMethod(this, -527, arg, ret); RETURN CtlC.VarBool(ret) END Selected; PROCEDURE (this: IMdcList) PUTSelected* (pvargIndex: CtlT.Any; p2: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[1]); CtlC.BoolVar(p2, arg[0]); CtlC.CallPutMethod(this, -527, arg, NIL); END PUTSelected; PROCEDURE (this: IMdcList) AddItem* ((* optional *) pvargItem: CtlT.Any; pvargIndex: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargItem, arg[1]); CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallParMethod(this, -553, arg, NIL); END AddItem; PROCEDURE (this: IMdcList) Clear* (), NEW; BEGIN CtlC.CallMethod(this, -554, NIL); END Clear; PROCEDURE (this: IMdcList) RemoveItem* (pvargIndex: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallParMethod(this, -555, arg, NIL); END RemoveItem; PROCEDURE (this: IMdcList) PUTIMEMode* (p1: fmIMEMode), NEW; BEGIN CtlC.PutInt(this, -542, p1) END PUTIMEMode; PROCEDURE (this: IMdcList) IMEMode* (): fmIMEMode, NEW; BEGIN RETURN CtlC.GetInt(this, -542) END IMEMode; PROCEDURE (this: IMdcList) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; (* ---------- IMdcCombo, hidden, dual ---------- *) PROCEDURE (this: IMdcCombo) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IMdcCombo) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IMdcCombo) PUTAutoTab* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 217, p1) END PUTAutoTab; PROCEDURE (this: IMdcCombo) AutoTab* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 217) END AutoTab; PROCEDURE (this: IMdcCombo) PUTAutoWordSelect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 218, p1) END PUTAutoWordSelect; PROCEDURE (this: IMdcCombo) AutoWordSelect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 218) END AutoWordSelect; PROCEDURE (this: IMdcCombo) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcCombo) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcCombo) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IMdcCombo) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IMdcCombo) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: IMdcCombo) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: IMdcCombo) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: IMdcCombo) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: IMdcCombo) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcCombo) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcCombo) PUTBoundColumn* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 501, p1) END PUTBoundColumn; PROCEDURE (this: IMdcCombo) BoundColumn* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 501) END BoundColumn; PROCEDURE (this: IMdcCombo) CanPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END CanPaste; PROCEDURE (this: IMdcCombo) PUTColumnCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 601, p1) END PUTColumnCount; PROCEDURE (this: IMdcCombo) ColumnCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 601) END ColumnCount; PROCEDURE (this: IMdcCombo) PUTColumnHeads* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 602, p1) END PUTColumnHeads; PROCEDURE (this: IMdcCombo) ColumnHeads* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 602) END ColumnHeads; PROCEDURE (this: IMdcCombo) PUTColumnWidths* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 603, p1) END PUTColumnWidths; PROCEDURE (this: IMdcCombo) ColumnWidths* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 603) END ColumnWidths; PROCEDURE (this: IMdcCombo) CurTargetX* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 210) END CurTargetX; PROCEDURE (this: IMdcCombo) CurTargetY* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 221) END CurTargetY; PROCEDURE (this: IMdcCombo) PUTCurX* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 208, p1) END PUTCurX; PROCEDURE (this: IMdcCombo) CurX* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 208) END CurX; PROCEDURE (this: IMdcCombo) PUTDropButtonStyle* (p1: fmDropButtonStyle), NEW; BEGIN CtlC.PutInt(this, 305, p1) END PUTDropButtonStyle; PROCEDURE (this: IMdcCombo) DropButtonStyle* (): fmDropButtonStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 305) END DropButtonStyle; PROCEDURE (this: IMdcCombo) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcCombo) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcCombo) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcCombo) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcCombo) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcCombo) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcCombo) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcCombo) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcCombo) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcCombo) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcCombo) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcCombo) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcCombo) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcCombo) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcCombo) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcCombo) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcCombo) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcCombo) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcCombo) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcCombo) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcCombo) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcCombo) PUTHideSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 207, p1) END PUTHideSelection; PROCEDURE (this: IMdcCombo) HideSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 207) END HideSelection; PROCEDURE (this: IMdcCombo) LineCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 214) END LineCount; PROCEDURE (this: IMdcCombo) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -531) END ListCount; PROCEDURE (this: IMdcCombo) PUTListCursor* (p1: CtlT.IUnknown), NEW; BEGIN CtlC.PutIntfce(this, 403, p1) END PUTListCursor; PROCEDURE (this: IMdcCombo) ListCursor* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 403) END ListCursor; PROCEDURE (this: IMdcCombo) PUTListIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, -526, p1) END PUTListIndex; PROCEDURE (this: IMdcCombo) ListIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -526) END ListIndex; PROCEDURE (this: IMdcCombo) PUTListRows* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 605, p1) END PUTListRows; PROCEDURE (this: IMdcCombo) ListRows* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 605) END ListRows; PROCEDURE (this: IMdcCombo) PUTListStyle* (p1: fmListStyle), NEW; BEGIN CtlC.PutInt(this, 307, p1) END PUTListStyle; PROCEDURE (this: IMdcCombo) ListStyle* (): fmListStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 307) END ListStyle; PROCEDURE (this: IMdcCombo) PUTListWidth* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 606, p1) END PUTListWidth; PROCEDURE (this: IMdcCombo) ListWidth* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 606) END ListWidth; PROCEDURE (this: IMdcCombo) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcCombo) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcCombo) PUTMatchEntry* (p1: fmMatchEntry), NEW; BEGIN CtlC.PutInt(this, 504, p1) END PUTMatchEntry; PROCEDURE (this: IMdcCombo) MatchEntry* (): fmMatchEntry, NEW; BEGIN RETURN CtlC.GetInt(this, 504) END MatchEntry; PROCEDURE (this: IMdcCombo) MatchFound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 505) END MatchFound; PROCEDURE (this: IMdcCombo) PUTMatchRequired* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 503, p1) END PUTMatchRequired; PROCEDURE (this: IMdcCombo) MatchRequired* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 503) END MatchRequired; PROCEDURE (this: IMdcCombo) PUTMaxLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -533, p1) END PUTMaxLength; PROCEDURE (this: IMdcCombo) MaxLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -533) END MaxLength; PROCEDURE (this: IMdcCombo) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcCombo) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcCombo) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcCombo) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcCombo) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcCombo) PUTSelectionMargin* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 220, p1) END PUTSelectionMargin; PROCEDURE (this: IMdcCombo) SelectionMargin* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 220) END SelectionMargin; PROCEDURE (this: IMdcCombo) PUTSelLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -548, p1) END PUTSelLength; PROCEDURE (this: IMdcCombo) SelLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -548) END SelLength; PROCEDURE (this: IMdcCombo) PUTSelStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -547, p1) END PUTSelStart; PROCEDURE (this: IMdcCombo) SelStart* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -547) END SelStart; PROCEDURE (this: IMdcCombo) PUTSelText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -546, p1) END PUTSelText; PROCEDURE (this: IMdcCombo) SelText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -546) END SelText; PROCEDURE (this: IMdcCombo) PUTShowDropButtonWhen* (p1: fmShowDropButtonWhen), NEW; BEGIN CtlC.PutInt(this, 304, p1) END PUTShowDropButtonWhen; PROCEDURE (this: IMdcCombo) ShowDropButtonWhen* (): fmShowDropButtonWhen, NEW; BEGIN RETURN CtlC.GetInt(this, 304) END ShowDropButtonWhen; PROCEDURE (this: IMdcCombo) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcCombo) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcCombo) PUTStyle* (p1: fmStyle), NEW; BEGIN CtlC.PutInt(this, 308, p1) END PUTStyle; PROCEDURE (this: IMdcCombo) Style* (): fmStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 308) END Style; PROCEDURE (this: IMdcCombo) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -517, p1) END PUTText; PROCEDURE (this: IMdcCombo) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -517) END Text; PROCEDURE (this: IMdcCombo) PUTTextAlign* (p1: fmTextAlign), NEW; BEGIN CtlC.PutInt(this, 10004, p1) END PUTTextAlign; PROCEDURE (this: IMdcCombo) TextAlign* (): fmTextAlign, NEW; BEGIN RETURN CtlC.GetInt(this, 10004) END TextAlign; PROCEDURE (this: IMdcCombo) PUTTextColumn* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 502, p1) END PUTTextColumn; PROCEDURE (this: IMdcCombo) TextColumn* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 502) END TextColumn; PROCEDURE (this: IMdcCombo) TextLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 216) END TextLength; PROCEDURE (this: IMdcCombo) PUTTopIndex* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTTopIndex; PROCEDURE (this: IMdcCombo) TopIndex* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END TopIndex; PROCEDURE (this: IMdcCombo) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcCombo) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcCombo) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcCombo) Column* ((* optional *) pvargColumn: CtlT.Any; pvargIndex: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(pvargColumn, arg[1]); CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallGetMethod(this, -529, arg, ret); RETURN CtlC.VarAny(ret) END Column; PROCEDURE (this: IMdcCombo) PUTColumn* (pvargColumn: CtlT.Any; (* optional *) pvargIndex: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargColumn, arg[2]); CtlC.AnyVar(pvargIndex, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, -529, arg, NIL); END PUTColumn; PROCEDURE (this: IMdcCombo) List* ((* optional *) pvargIndex: CtlT.Any; pvargColumn: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[1]); CtlC.AnyVar(pvargColumn, arg[0]); CtlC.CallGetMethod(this, -528, arg, ret); RETURN CtlC.VarAny(ret) END List; PROCEDURE (this: IMdcCombo) PUTList* (pvargIndex: CtlT.Any; (* optional *) pvargColumn: CtlT.Any; p3: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[2]); CtlC.AnyVar(pvargColumn, arg[1]); CtlC.AnyVar(p3, arg[0]); CtlC.CallPutMethod(this, -528, arg, NIL); END PUTList; PROCEDURE (this: IMdcCombo) AddItem* ((* optional *) pvargItem: CtlT.Any; pvargIndex: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargItem, arg[1]); CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallParMethod(this, -553, arg, NIL); END AddItem; PROCEDURE (this: IMdcCombo) Clear* (), NEW; BEGIN CtlC.CallMethod(this, -554, NIL); END Clear; PROCEDURE (this: IMdcCombo) DropDown* (), NEW; BEGIN CtlC.CallMethod(this, 1001, NIL); END DropDown; PROCEDURE (this: IMdcCombo) RemoveItem* (pvargIndex: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(pvargIndex, arg[0]); CtlC.CallParMethod(this, -555, arg, NIL); END RemoveItem; PROCEDURE (this: IMdcCombo) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END Copy; PROCEDURE (this: IMdcCombo) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 21, NIL); END Cut; PROCEDURE (this: IMdcCombo) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 24, NIL); END Paste; PROCEDURE (this: IMdcCombo) PUTIMEMode* (p1: fmIMEMode), NEW; BEGIN CtlC.PutInt(this, -542, p1) END PUTIMEMode; PROCEDURE (this: IMdcCombo) IMEMode* (): fmIMEMode, NEW; BEGIN RETURN CtlC.GetInt(this, -542) END IMEMode; PROCEDURE (this: IMdcCombo) PUTEnterFieldBehavior* (p1: fmEnterFieldBehavior), NEW; BEGIN CtlC.PutInt(this, 224, p1) END PUTEnterFieldBehavior; PROCEDURE (this: IMdcCombo) EnterFieldBehavior* (): fmEnterFieldBehavior, NEW; BEGIN RETURN CtlC.GetInt(this, 224) END EnterFieldBehavior; PROCEDURE (this: IMdcCombo) PUTDragBehavior* (p1: fmDragBehavior), NEW; BEGIN CtlC.PutInt(this, 225, p1) END PUTDragBehavior; PROCEDURE (this: IMdcCombo) DragBehavior* (): fmDragBehavior, NEW; BEGIN RETURN CtlC.GetInt(this, 225) END DragBehavior; PROCEDURE (this: IMdcCombo) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; (* ---------- IMdcCheckBox, hidden, dual ---------- *) PROCEDURE (this: IMdcCheckBox) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: IMdcCheckBox) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: IMdcCheckBox) PUTAlignment* (p1: fmAlignment), NEW; BEGIN CtlC.PutInt(this, 710, p1) END PUTAlignment; PROCEDURE (this: IMdcCheckBox) Alignment* (): fmAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 710) END Alignment; PROCEDURE (this: IMdcCheckBox) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IMdcCheckBox) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IMdcCheckBox) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcCheckBox) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcCheckBox) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IMdcCheckBox) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IMdcCheckBox) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcCheckBox) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcCheckBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: IMdcCheckBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: IMdcCheckBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcCheckBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcCheckBox) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcCheckBox) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcCheckBox) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcCheckBox) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcCheckBox) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcCheckBox) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcCheckBox) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcCheckBox) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcCheckBox) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcCheckBox) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcCheckBox) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcCheckBox) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcCheckBox) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcCheckBox) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcCheckBox) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcCheckBox) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcCheckBox) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcCheckBox) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcCheckBox) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcCheckBox) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcCheckBox) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcCheckBox) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcCheckBox) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcCheckBox) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcCheckBox) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcCheckBox) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcCheckBox) PUTMultiSelect* (p1: fmMultiSelect), NEW; BEGIN CtlC.PutInt(this, -532, p1) END PUTMultiSelect; PROCEDURE (this: IMdcCheckBox) MultiSelect* (): fmMultiSelect, NEW; BEGIN RETURN CtlC.GetInt(this, -532) END MultiSelect; PROCEDURE (this: IMdcCheckBox) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IMdcCheckBox) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IMdcCheckBox) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IMdcCheckBox) PUTPicturePosition* (p1: fmPicturePosition), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTPicturePosition; PROCEDURE (this: IMdcCheckBox) PicturePosition* (): fmPicturePosition, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END PicturePosition; PROCEDURE (this: IMdcCheckBox) PUTSpecialEffect* (p1: fmButtonEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcCheckBox) SpecialEffect* (): fmButtonEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcCheckBox) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 700, p1) END PUTTripleState; PROCEDURE (this: IMdcCheckBox) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 700) END TripleState; PROCEDURE (this: IMdcCheckBox) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcCheckBox) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcCheckBox) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcCheckBox) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: IMdcCheckBox) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: IMdcCheckBox) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; PROCEDURE (this: IMdcCheckBox) PUTGroupName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTGroupName; PROCEDURE (this: IMdcCheckBox) GroupName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END GroupName; (* ---------- IMdcOptionButton, hidden, dual ---------- *) PROCEDURE (this: IMdcOptionButton) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: IMdcOptionButton) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: IMdcOptionButton) PUTAlignment* (p1: fmAlignment), NEW; BEGIN CtlC.PutInt(this, 710, p1) END PUTAlignment; PROCEDURE (this: IMdcOptionButton) Alignment* (): fmAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 710) END Alignment; PROCEDURE (this: IMdcOptionButton) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IMdcOptionButton) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IMdcOptionButton) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcOptionButton) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcOptionButton) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IMdcOptionButton) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IMdcOptionButton) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcOptionButton) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcOptionButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: IMdcOptionButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: IMdcOptionButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcOptionButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcOptionButton) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcOptionButton) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcOptionButton) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcOptionButton) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcOptionButton) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcOptionButton) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcOptionButton) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcOptionButton) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcOptionButton) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcOptionButton) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcOptionButton) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcOptionButton) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcOptionButton) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcOptionButton) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcOptionButton) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcOptionButton) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcOptionButton) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcOptionButton) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcOptionButton) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcOptionButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcOptionButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcOptionButton) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcOptionButton) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcOptionButton) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcOptionButton) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcOptionButton) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcOptionButton) PUTMultiSelect* (p1: fmMultiSelect), NEW; BEGIN CtlC.PutInt(this, -532, p1) END PUTMultiSelect; PROCEDURE (this: IMdcOptionButton) MultiSelect* (): fmMultiSelect, NEW; BEGIN RETURN CtlC.GetInt(this, -532) END MultiSelect; PROCEDURE (this: IMdcOptionButton) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IMdcOptionButton) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IMdcOptionButton) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IMdcOptionButton) PUTPicturePosition* (p1: fmPicturePosition), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTPicturePosition; PROCEDURE (this: IMdcOptionButton) PicturePosition* (): fmPicturePosition, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END PicturePosition; PROCEDURE (this: IMdcOptionButton) PUTSpecialEffect* (p1: fmButtonEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcOptionButton) SpecialEffect* (): fmButtonEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcOptionButton) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 700, p1) END PUTTripleState; PROCEDURE (this: IMdcOptionButton) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 700) END TripleState; PROCEDURE (this: IMdcOptionButton) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcOptionButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcOptionButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcOptionButton) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: IMdcOptionButton) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: IMdcOptionButton) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; PROCEDURE (this: IMdcOptionButton) PUTGroupName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTGroupName; PROCEDURE (this: IMdcOptionButton) GroupName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END GroupName; (* ---------- IMdcToggleButton, hidden, dual ---------- *) PROCEDURE (this: IMdcToggleButton) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: IMdcToggleButton) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: IMdcToggleButton) PUTAlignment* (p1: fmAlignment), NEW; BEGIN CtlC.PutInt(this, 710, p1) END PUTAlignment; PROCEDURE (this: IMdcToggleButton) Alignment* (): fmAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 710) END Alignment; PROCEDURE (this: IMdcToggleButton) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IMdcToggleButton) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IMdcToggleButton) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMdcToggleButton) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMdcToggleButton) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IMdcToggleButton) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IMdcToggleButton) PUTBordersSuppress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBordersSuppress; PROCEDURE (this: IMdcToggleButton) BordersSuppress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BordersSuppress; PROCEDURE (this: IMdcToggleButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: IMdcToggleButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: IMdcToggleButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMdcToggleButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMdcToggleButton) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMdcToggleButton) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMdcToggleButton) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMdcToggleButton) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMdcToggleButton) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMdcToggleButton) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMdcToggleButton) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMdcToggleButton) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMdcToggleButton) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMdcToggleButton) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMdcToggleButton) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMdcToggleButton) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMdcToggleButton) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMdcToggleButton) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMdcToggleButton) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMdcToggleButton) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMdcToggleButton) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; PROCEDURE (this: IMdcToggleButton) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMdcToggleButton) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMdcToggleButton) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTLocked; PROCEDURE (this: IMdcToggleButton) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Locked; PROCEDURE (this: IMdcToggleButton) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IMdcToggleButton) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IMdcToggleButton) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IMdcToggleButton) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IMdcToggleButton) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IMdcToggleButton) PUTMultiSelect* (p1: fmMultiSelect), NEW; BEGIN CtlC.PutInt(this, -532, p1) END PUTMultiSelect; PROCEDURE (this: IMdcToggleButton) MultiSelect* (): fmMultiSelect, NEW; BEGIN RETURN CtlC.GetInt(this, -532) END MultiSelect; PROCEDURE (this: IMdcToggleButton) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IMdcToggleButton) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IMdcToggleButton) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IMdcToggleButton) PUTPicturePosition* (p1: fmPicturePosition), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTPicturePosition; PROCEDURE (this: IMdcToggleButton) PicturePosition* (): fmPicturePosition, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END PicturePosition; PROCEDURE (this: IMdcToggleButton) PUTSpecialEffect* (p1: fmButtonEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IMdcToggleButton) SpecialEffect* (): fmButtonEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: IMdcToggleButton) PUTTripleState* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 700, p1) END PUTTripleState; PROCEDURE (this: IMdcToggleButton) TripleState* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 700) END TripleState; PROCEDURE (this: IMdcToggleButton) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -524) END Valid; PROCEDURE (this: IMdcToggleButton) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: IMdcToggleButton) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: IMdcToggleButton) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -536, p1) END PUTWordWrap; PROCEDURE (this: IMdcToggleButton) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -536) END WordWrap; PROCEDURE (this: IMdcToggleButton) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; PROCEDURE (this: IMdcToggleButton) PUTGroupName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTGroupName; PROCEDURE (this: IMdcToggleButton) GroupName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END GroupName; (* ---------- IScrollbar, hidden, dual ---------- *) PROCEDURE (this: IScrollbar) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IScrollbar) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IScrollbar) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IScrollbar) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IScrollbar) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IScrollbar) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IScrollbar) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IScrollbar) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IScrollbar) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTValue; PROCEDURE (this: IScrollbar) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Value; PROCEDURE (this: IScrollbar) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTMin; PROCEDURE (this: IScrollbar) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Min; PROCEDURE (this: IScrollbar) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTMax; PROCEDURE (this: IScrollbar) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Max; PROCEDURE (this: IScrollbar) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTSmallChange; PROCEDURE (this: IScrollbar) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SmallChange; PROCEDURE (this: IScrollbar) PUTLargeChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTLargeChange; PROCEDURE (this: IScrollbar) LargeChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END LargeChange; PROCEDURE (this: IScrollbar) PUTProportionalThumb* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 104, p1) END PUTProportionalThumb; PROCEDURE (this: IScrollbar) ProportionalThumb* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 104) END ProportionalThumb; PROCEDURE (this: IScrollbar) PUTOrientation* (p1: fmOrientation), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTOrientation; PROCEDURE (this: IScrollbar) Orientation* (): fmOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Orientation; PROCEDURE (this: IScrollbar) PUTDelay* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTDelay; PROCEDURE (this: IScrollbar) Delay* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Delay; PROCEDURE (this: IScrollbar) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IScrollbar) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IScrollbar) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; (* ---------- Tab, dual ---------- *) PROCEDURE (this: Tab) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: Tab) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: Tab) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418043, p1) END PUTControlTipText; PROCEDURE (this: Tab) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418043) END ControlTipText; PROCEDURE (this: Tab) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: Tab) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: Tab) PUTIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTIndex; PROCEDURE (this: Tab) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: Tab) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: Tab) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: Tab) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418101, p1) END PUTTag; PROCEDURE (this: Tab) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418101) END Tag; PROCEDURE (this: Tab) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418105, p1) END PUTVisible; PROCEDURE (this: Tab) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418105) END Visible; PROCEDURE (this: Tab) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: Tab) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; (* ---------- Tabs, dual ---------- *) PROCEDURE (this: Tabs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END Count; PROCEDURE (this: Tabs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Tabs) _GetItemByIndex* (lIndex: INTEGER): Tab, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lIndex, arg[0]); CtlC.CallParMethod(this, 1610743810, arg, ret); RETURN ThisTab(CtlC.VarAny(ret)) END _GetItemByIndex; PROCEDURE (this: Tabs) _GetItemByName* (bstr: ARRAY OF CHAR): Tab, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstr, arg[0]); CtlC.CallParMethod(this, 1610743811, arg, ret); RETURN ThisTab(CtlC.VarAny(ret)) END _GetItemByName; PROCEDURE (this: Tabs) Item* (varg: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Tabs) Enum* (): CtlT.IUnknown, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743813, ret); RETURN CtlC.VarIntfce(ret) END Enum; PROCEDURE (this: Tabs) Add* ((* optional *) bstrName: CtlT.Any; bstrCaption: CtlT.Any; lIndex: CtlT.Any): Tab, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(bstrName, arg[2]); CtlC.AnyVar(bstrCaption, arg[1]); CtlC.AnyVar(lIndex, arg[0]); CtlC.CallParMethod(this, 66, arg, ret); RETURN ThisTab(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Tabs) _Add* (bstrName: ARRAY OF CHAR; bstrCaption: ARRAY OF CHAR): Tab, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrName, arg[1]); CtlC.StrVar(bstrCaption, arg[0]); CtlC.CallParMethod(this, 1610743815, arg, ret); RETURN ThisTab(CtlC.VarAny(ret)) END _Add; PROCEDURE (this: Tabs) _Insert* (bstrName: ARRAY OF CHAR; bstrCaption: ARRAY OF CHAR; lIndex: INTEGER): Tab, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrName, arg[2]); CtlC.StrVar(bstrCaption, arg[1]); CtlC.IntVar(lIndex, arg[0]); CtlC.CallParMethod(this, 1610743816, arg, ret); RETURN ThisTab(CtlC.VarAny(ret)) END _Insert; PROCEDURE (this: Tabs) Remove* (varg: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 67, arg, NIL); END Remove; PROCEDURE (this: Tabs) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 62, NIL); END Clear; (* ---------- ITabStrip, hidden, dual ---------- *) PROCEDURE (this: ITabStrip) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: ITabStrip) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: ITabStrip) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: ITabStrip) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: ITabStrip) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: ITabStrip) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: ITabStrip) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: ITabStrip) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: ITabStrip) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: ITabStrip) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: ITabStrip) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: ITabStrip) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: ITabStrip) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: ITabStrip) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: ITabStrip) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: ITabStrip) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: ITabStrip) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: ITabStrip) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: ITabStrip) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: ITabStrip) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: ITabStrip) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: ITabStrip) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: ITabStrip) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: ITabStrip) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: ITabStrip) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: ITabStrip) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: ITabStrip) PUTMultiRow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 514, p1) END PUTMultiRow; PROCEDURE (this: ITabStrip) MultiRow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 514) END MultiRow; PROCEDURE (this: ITabStrip) PUTStyle* (p1: fmTabStyle), NEW; BEGIN CtlC.PutInt(this, 513, p1) END PUTStyle; PROCEDURE (this: ITabStrip) Style* (): fmTabStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 513) END Style; PROCEDURE (this: ITabStrip) PUTTabOrientation* (p1: fmTabOrientation), NEW; BEGIN CtlC.PutInt(this, 512, p1) END PUTTabOrientation; PROCEDURE (this: ITabStrip) TabOrientation* (): fmTabOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 512) END TabOrientation; PROCEDURE (this: ITabStrip) _SetTabFixedWidth* (TabFixedWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(TabFixedWidth, arg[0]); CtlC.CallParMethod(this, 1610743840, arg, NIL); END _SetTabFixedWidth; PROCEDURE (this: ITabStrip) _GetTabFixedWidth* (OUT TabFixedWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(TabFixedWidth, arg[0]); CtlC.CallParMethod(this, 1610743841, arg, NIL); END _GetTabFixedWidth; PROCEDURE (this: ITabStrip) _SetTabFixedHeight* (TabFixedHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(TabFixedHeight, arg[0]); CtlC.CallParMethod(this, 1610743842, arg, NIL); END _SetTabFixedHeight; PROCEDURE (this: ITabStrip) _GetTabFixedHeight* (OUT TabFixedHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(TabFixedHeight, arg[0]); CtlC.CallParMethod(this, 1610743843, arg, NIL); END _GetTabFixedHeight; PROCEDURE (this: ITabStrip) _GetClientTop* (OUT ClientTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ClientTop, arg[0]); CtlC.CallParMethod(this, 1610743844, arg, NIL); END _GetClientTop; PROCEDURE (this: ITabStrip) ClientTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 548) END ClientTop; PROCEDURE (this: ITabStrip) _GetClientLeft* (OUT ClientLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ClientLeft, arg[0]); CtlC.CallParMethod(this, 1610743846, arg, NIL); END _GetClientLeft; PROCEDURE (this: ITabStrip) ClientLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 547) END ClientLeft; PROCEDURE (this: ITabStrip) _GetClientWidth* (OUT ClientWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ClientWidth, arg[0]); CtlC.CallParMethod(this, 1610743848, arg, NIL); END _GetClientWidth; PROCEDURE (this: ITabStrip) ClientWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 549) END ClientWidth; PROCEDURE (this: ITabStrip) _GetClientHeight* (OUT ClientHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ClientHeight, arg[0]); CtlC.CallParMethod(this, 1610743850, arg, NIL); END _GetClientHeight; PROCEDURE (this: ITabStrip) ClientHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 546) END ClientHeight; PROCEDURE (this: ITabStrip) Tabs* (): Tabs, NEW; BEGIN RETURN ThisTabs(CtlC.GetAny(this, 0)) END Tabs; PROCEDURE (this: ITabStrip) SelectedItem* (): Tab, NEW; BEGIN RETURN ThisTab(CtlC.GetAny(this, 545)) END SelectedItem; PROCEDURE (this: ITabStrip) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 528, p1) END PUTValue; PROCEDURE (this: ITabStrip) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 528) END Value; PROCEDURE (this: ITabStrip) PUTTabFixedWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 515, p1) END PUTTabFixedWidth; PROCEDURE (this: ITabStrip) TabFixedWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 515) END TabFixedWidth; PROCEDURE (this: ITabStrip) PUTTabFixedHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 516, p1) END PUTTabFixedHeight; PROCEDURE (this: ITabStrip) TabFixedHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 516) END TabFixedHeight; PROCEDURE (this: ITabStrip) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: ITabStrip) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; (* ---------- ISpinbutton, hidden, dual ---------- *) PROCEDURE (this: ISpinbutton) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: ISpinbutton) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: ISpinbutton) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: ISpinbutton) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: ISpinbutton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: ISpinbutton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: ISpinbutton) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: ISpinbutton) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: ISpinbutton) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTValue; PROCEDURE (this: ISpinbutton) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Value; PROCEDURE (this: ISpinbutton) PUTMin* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTMin; PROCEDURE (this: ISpinbutton) Min* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Min; PROCEDURE (this: ISpinbutton) PUTMax* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTMax; PROCEDURE (this: ISpinbutton) Max* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Max; PROCEDURE (this: ISpinbutton) PUTSmallChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTSmallChange; PROCEDURE (this: ISpinbutton) SmallChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SmallChange; PROCEDURE (this: ISpinbutton) PUTOrientation* (p1: fmOrientation), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTOrientation; PROCEDURE (this: ISpinbutton) Orientation* (): fmOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Orientation; PROCEDURE (this: ISpinbutton) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: ISpinbutton) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: ISpinbutton) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: ISpinbutton) PUTDelay* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTDelay; PROCEDURE (this: ISpinbutton) Delay* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Delay; (* ---------- IImage, hidden, dual ---------- *) PROCEDURE (this: IImage) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IImage) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IImage) PUTMousePointer* (p1: fmMousePointer), NEW; BEGIN CtlC.PutInt(this, -521, p1) END PUTMousePointer; PROCEDURE (this: IImage) MousePointer* (): fmMousePointer, NEW; BEGIN RETURN CtlC.GetInt(this, -521) END MousePointer; PROCEDURE (this: IImage) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -500, p1) END PUTAutoSize; PROCEDURE (this: IImage) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -500) END AutoSize; PROCEDURE (this: IImage) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IImage) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IImage) PUTBackStyle* (p1: fmBackStyle), NEW; BEGIN CtlC.PutInt(this, -502, p1) END PUTBackStyle; PROCEDURE (this: IImage) BackStyle* (): fmBackStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -502) END BackStyle; PROCEDURE (this: IImage) PUTBorderColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -503, p1) END PUTBorderColor; PROCEDURE (this: IImage) BorderColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -503) END BorderColor; PROCEDURE (this: IImage) PUTBorderStyle* (p1: fmBorderStyle), NEW; BEGIN CtlC.PutInt(this, -504, p1) END PUTBorderStyle; PROCEDURE (this: IImage) BorderStyle* (): fmBorderStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -504) END BorderStyle; PROCEDURE (this: IImage) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IImage) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IImage) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IImage) PUTMouseIcon* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -522, p1) END PUTMouseIcon; PROCEDURE (this: IImage) PUTREFMouseIcon* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -522, arg, NIL); END PUTREFMouseIcon; PROCEDURE (this: IImage) MouseIcon* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -522)) END MouseIcon; PROCEDURE (this: IImage) PUTPictureSizeMode* (p1: fmPictureSizeMode), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTPictureSizeMode; PROCEDURE (this: IImage) PictureSizeMode* (): fmPictureSizeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END PictureSizeMode; PROCEDURE (this: IImage) PUTPictureAlignment* (p1: fmPictureAlignment), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTPictureAlignment; PROCEDURE (this: IImage) PictureAlignment* (): fmPictureAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END PictureAlignment; PROCEDURE (this: IImage) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTPictureTiling; PROCEDURE (this: IImage) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END PictureTiling; PROCEDURE (this: IImage) PUTSpecialEffect* (p1: fmSpecialEffect), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; PROCEDURE (this: IImage) SpecialEffect* (): fmSpecialEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; (* ---------- IWHTMLSubmitButton, hidden, dual ---------- *) PROCEDURE (this: IWHTMLSubmitButton) PUTAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 601, p1) END PUTAction; PROCEDURE (this: IWHTMLSubmitButton) Action* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 601) END Action; PROCEDURE (this: IWHTMLSubmitButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 602, p1) END PUTCaption; PROCEDURE (this: IWHTMLSubmitButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 602) END Caption; PROCEDURE (this: IWHTMLSubmitButton) PUTEncoding* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 603, p1) END PUTEncoding; PROCEDURE (this: IWHTMLSubmitButton) Encoding* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 603) END Encoding; PROCEDURE (this: IWHTMLSubmitButton) PUTMethod* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 604, p1) END PUTMethod; PROCEDURE (this: IWHTMLSubmitButton) Method* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 604) END Method; PROCEDURE (this: IWHTMLSubmitButton) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLSubmitButton) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLSubmitButton) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLSubmitButton) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLImage, hidden, dual ---------- *) PROCEDURE (this: IWHTMLImage) PUTAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 601, p1) END PUTAction; PROCEDURE (this: IWHTMLImage) Action* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 601) END Action; PROCEDURE (this: IWHTMLImage) PUTSource* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 606, p1) END PUTSource; PROCEDURE (this: IWHTMLImage) Source* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 606) END Source; PROCEDURE (this: IWHTMLImage) PUTEncoding* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 603, p1) END PUTEncoding; PROCEDURE (this: IWHTMLImage) Encoding* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 603) END Encoding; PROCEDURE (this: IWHTMLImage) PUTMethod* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 604, p1) END PUTMethod; PROCEDURE (this: IWHTMLImage) Method* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 604) END Method; PROCEDURE (this: IWHTMLImage) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLImage) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLImage) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLImage) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLReset, hidden, dual ---------- *) PROCEDURE (this: IWHTMLReset) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 602, p1) END PUTCaption; PROCEDURE (this: IWHTMLReset) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 602) END Caption; PROCEDURE (this: IWHTMLReset) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLReset) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLReset) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLReset) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLCheckbox, hidden, dual ---------- *) PROCEDURE (this: IWHTMLCheckbox) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLCheckbox) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLCheckbox) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 607, p1) END PUTValue; PROCEDURE (this: IWHTMLCheckbox) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 607) END Value; PROCEDURE (this: IWHTMLCheckbox) PUTChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 0, p1) END PUTChecked; PROCEDURE (this: IWHTMLCheckbox) Checked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Checked; PROCEDURE (this: IWHTMLCheckbox) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLCheckbox) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLOption, hidden, dual ---------- *) PROCEDURE (this: IWHTMLOption) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLOption) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLOption) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 607, p1) END PUTValue; PROCEDURE (this: IWHTMLOption) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 607) END Value; PROCEDURE (this: IWHTMLOption) PUTChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 0, p1) END PUTChecked; PROCEDURE (this: IWHTMLOption) Checked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Checked; PROCEDURE (this: IWHTMLOption) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLOption) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; PROCEDURE (this: IWHTMLOption) DisplayStyle* (): fmDisplayStyle, NEW; BEGIN RETURN CtlC.GetInt(this, -540) END DisplayStyle; (* ---------- IWHTMLText, hidden, dual ---------- *) PROCEDURE (this: IWHTMLText) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLText) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLText) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: IWHTMLText) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: IWHTMLText) PUTMaxLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 609, p1) END PUTMaxLength; PROCEDURE (this: IWHTMLText) MaxLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 609) END MaxLength; PROCEDURE (this: IWHTMLText) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 610, p1) END PUTWidth; PROCEDURE (this: IWHTMLText) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 610) END Width; PROCEDURE (this: IWHTMLText) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLText) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLHidden, hidden, dual ---------- *) PROCEDURE (this: IWHTMLHidden) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLHidden) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLHidden) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: IWHTMLHidden) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: IWHTMLHidden) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLHidden) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLPassword, hidden, dual ---------- *) PROCEDURE (this: IWHTMLPassword) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLPassword) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLPassword) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: IWHTMLPassword) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: IWHTMLPassword) PUTMaxLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 609, p1) END PUTMaxLength; PROCEDURE (this: IWHTMLPassword) MaxLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 609) END MaxLength; PROCEDURE (this: IWHTMLPassword) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 610, p1) END PUTWidth; PROCEDURE (this: IWHTMLPassword) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 610) END Width; PROCEDURE (this: IWHTMLPassword) PUTHTMLType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 618, p1) END PUTHTMLType; PROCEDURE (this: IWHTMLPassword) HTMLType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 618) END HTMLType; (* ---------- IWHTMLSelect, hidden, dual ---------- *) PROCEDURE (this: IWHTMLSelect) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLSelect) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLSelect) PUTValues* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 611, p1) END PUTValues; PROCEDURE (this: IWHTMLSelect) Values* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 611) END Values; PROCEDURE (this: IWHTMLSelect) PUTDisplayValues* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 612, p1) END PUTDisplayValues; PROCEDURE (this: IWHTMLSelect) DisplayValues* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 612) END DisplayValues; PROCEDURE (this: IWHTMLSelect) PUTSelected* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 613, p1) END PUTSelected; PROCEDURE (this: IWHTMLSelect) Selected* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 613) END Selected; PROCEDURE (this: IWHTMLSelect) PUTMultiSelect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 614, p1) END PUTMultiSelect; PROCEDURE (this: IWHTMLSelect) MultiSelect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 614) END MultiSelect; PROCEDURE (this: IWHTMLSelect) PUTSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 619, p1) END PUTSize; PROCEDURE (this: IWHTMLSelect) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 619) END Size; (* ---------- IWHTMLTextArea, hidden, dual ---------- *) PROCEDURE (this: IWHTMLTextArea) PUTHTMLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -541, p1) END PUTHTMLName; PROCEDURE (this: IWHTMLTextArea) HTMLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -541) END HTMLName; PROCEDURE (this: IWHTMLTextArea) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: IWHTMLTextArea) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: IWHTMLTextArea) PUTRows* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 615, p1) END PUTRows; PROCEDURE (this: IWHTMLTextArea) Rows* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 615) END Rows; PROCEDURE (this: IWHTMLTextArea) PUTColumns* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 616, p1) END PUTColumns; PROCEDURE (this: IWHTMLTextArea) Columns* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 616) END Columns; PROCEDURE (this: IWHTMLTextArea) PUTWordWrap* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 617, p1) END PUTWordWrap; PROCEDURE (this: IWHTMLTextArea) WordWrap* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 617) END WordWrap; (* ---------- LabelControlEvents, hidden ---------- *) PROCEDURE (this: LabelControlEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: LabelControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -600: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: LabelControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{978C9E22-D4B0-11CE-BF2D-00AA003F40D0}" END GetIID; (* ---------- CommandButtonEvents, hidden ---------- *) PROCEDURE (this: CommandButtonEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: CommandButtonEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -600: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: CommandButtonEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{7B020EC1-AF6C-11CE-9F46-00AA00574A4F}" END GetIID; (* ---------- MdcTextEvents, hidden ---------- *) PROCEDURE (this: MdcTextEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) DropButtonClick* (), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcTextEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | 2002: ASSERT(n = 0, 11); this.DropButtonClick() | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcTextEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D12-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- MdcListEvents, hidden ---------- *) PROCEDURE (this: MdcListEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcListEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -610: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcListEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D22-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- MdcComboEvents, hidden ---------- *) PROCEDURE (this: MdcComboEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) DropButtonClick* (), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcComboEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -610: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | 2002: ASSERT(n = 0, 11); this.DropButtonClick() | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcComboEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D32-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- MdcCheckBoxEvents, hidden ---------- *) PROCEDURE (this: MdcCheckBoxEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcCheckBoxEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -610: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcCheckBoxEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D42-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- MdcOptionButtonEvents, hidden ---------- *) PROCEDURE (this: MdcOptionButtonEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcOptionButtonEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -610: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcOptionButtonEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D52-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- MdcToggleButtonEvents, hidden ---------- *) PROCEDURE (this: MdcToggleButtonEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MdcToggleButtonEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -610: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: MdcToggleButtonEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{8BD21D62-EC42-11CE-9E0D-00AA006002F3}" END GetIID; (* ---------- ScrollbarEvents, hidden ---------- *) PROCEDURE (this: ScrollbarEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) Scroll* (), NEW, ABSTRACT; PROCEDURE (this: ScrollbarEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 7: ASSERT(n = 0, 11); this.Scroll() END END Invoke; PROCEDURE (this: ScrollbarEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{7B020EC2-AF6C-11CE-9F46-00AA00574A4F}" END GetIID; (* ---------- TabStripEvents, hidden ---------- *) PROCEDURE (this: TabStripEvents) BeforeDragOver* (Index: INTEGER; Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) BeforeDropOrPaste* (Index: INTEGER; Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) Click* (Index: INTEGER), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) DblClick* (Index: INTEGER; Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) MouseDown* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) MouseMove* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) MouseUp* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: TabStripEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 8, 11); this.BeforeDragOver(CtlC.VarInt(par[7]), ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 8, 11); this.BeforeDropOrPaste(CtlC.VarInt(par[7]), ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -600: ASSERT(n = 1, 11); this.Click(CtlC.VarInt(par[0])) | -601: ASSERT(n = 2, 11); this.DblClick(CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -605: ASSERT(n = 5, 11); this.MouseDown(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 5, 11); this.MouseMove(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 5, 11); this.MouseUp(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: TabStripEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{7B020EC7-AF6C-11CE-9F46-00AA00574A4F}" END GetIID; (* ---------- SpinbuttonEvents, hidden ---------- *) PROCEDURE (this: SpinbuttonEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) SpinUp* (), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) SpinDown* (), NEW, ABSTRACT; PROCEDURE (this: SpinbuttonEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 5: ASSERT(n = 0, 11); this.SpinUp() | 6: ASSERT(n = 0, 11); this.SpinDown() END END Invoke; PROCEDURE (this: SpinbuttonEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{79176FB2-B7F2-11CE-97EF-00AA006D2776}" END GetIID; (* ---------- ImageEvents, hidden ---------- *) PROCEDURE (this: ImageEvents) BeforeDragOver* (Cancel: ReturnBoolean; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; DragState: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) BeforeDropOrPaste* (Cancel: ReturnBoolean; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) DblClick* (Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) Error* (Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) MouseDown* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) MouseMove* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) MouseUp* (Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: ImageEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 3: ASSERT(n = 7, 11); this.BeforeDragOver(ThisIReturnBoolean(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 7, 11); this.BeforeDropOrPaste(ThisIReturnBoolean(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -600: ASSERT(n = 0, 11); this.Click() | -601: ASSERT(n = 1, 11); this.DblClick(ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 7, 11); this.Error(CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -605: ASSERT(n = 4, 11); this.MouseDown(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 4, 11); this.MouseMove(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 4, 11); this.MouseUp(CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) END END Invoke; PROCEDURE (this: ImageEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{4C5992A5-6926-101B-9992-00000B65C6F9}" END GetIID; (* ---------- WHTMLControlEvents, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{796ED650-5FE9-11CF-8D68-00AA00BDCE1D}" END GetIID; (* ---------- WHTMLControlEvents1, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents1) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents1) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents1) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE0-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents2, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents2) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents2) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents2) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE1-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents3, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents3) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents3) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents3) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE2-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents4, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents4) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents4) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents4) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE3-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents5, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents5) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents5) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents5) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE4-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents6, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents6) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents6) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents6) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE5-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents7, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents7) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents7) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents7) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE6-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents9, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents9) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents9) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents9) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE8-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- WHTMLControlEvents10, hidden ---------- *) PROCEDURE (this: WHTMLControlEvents10) Click* (), NEW, ABSTRACT; PROCEDURE (this: WHTMLControlEvents10) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -600: ASSERT(n = 0, 11); this.Click() END END Invoke; PROCEDURE (this: WHTMLControlEvents10) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{47FF8FE9-6198-11CF-8CE8-00AA006CB389}" END GetIID; (* ---------- IPage, hidden, dual ---------- *) PROCEDURE (this: IPage) Controls* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 0)) END Controls; PROCEDURE (this: IPage) Selected* (): Controls, NEW; BEGIN RETURN ThisControls(CtlC.GetAny(this, 270)) END Selected; PROCEDURE (this: IPage) ActiveControl* (): Control, NEW; BEGIN RETURN ThisIControl(CtlC.GetAny(this, 256)) END ActiveControl; PROCEDURE (this: IPage) CanPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 257) END CanPaste; PROCEDURE (this: IPage) CanRedo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 258) END CanRedo; PROCEDURE (this: IPage) CanUndo* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 259) END CanUndo; PROCEDURE (this: IPage) PUTCycle* (p1: fmCycle), NEW; BEGIN CtlC.PutInt(this, 260, p1) END PUTCycle; PROCEDURE (this: IPage) Cycle* (): fmCycle, NEW; BEGIN RETURN CtlC.GetInt(this, 260) END Cycle; PROCEDURE (this: IPage) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -518, p1) END PUTCaption; PROCEDURE (this: IPage) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -518) END Caption; PROCEDURE (this: IPage) PUTControlTipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418043, p1) END PUTControlTipText; PROCEDURE (this: IPage) ControlTipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418043) END ControlTipText; PROCEDURE (this: IPage) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IPage) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IPage) PUTIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -2147356416, p1) END PUTIndex; PROCEDURE (this: IPage) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147356416) END Index; PROCEDURE (this: IPage) _GetInsideHeight* (OUT InsideHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideHeight, arg[0]); CtlC.CallParMethod(this, 1610743824, arg, NIL); END _GetInsideHeight; PROCEDURE (this: IPage) InsideHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 262) END InsideHeight; PROCEDURE (this: IPage) _GetInsideWidth* (OUT InsideWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(InsideWidth, arg[0]); CtlC.CallParMethod(this, 1610743826, arg, NIL); END _GetInsideWidth; PROCEDURE (this: IPage) InsideWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 263) END InsideWidth; PROCEDURE (this: IPage) PUTKeepScrollBarsVisible* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 264, p1) END PUTKeepScrollBarsVisible; PROCEDURE (this: IPage) KeepScrollBarsVisible* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 264) END KeepScrollBarsVisible; PROCEDURE (this: IPage) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: IPage) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: IPage) PUTPictureAlignment* (p1: fmPictureAlignment), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTPictureAlignment; PROCEDURE (this: IPage) PictureAlignment* (): fmPictureAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END PictureAlignment; PROCEDURE (this: IPage) PUTPicture* (p1: CtlStdType.Picture), NEW; BEGIN CtlC.PutObj(this, -523, p1) END PUTPicture; PROCEDURE (this: IPage) PUTREFPicture* (p1: CtlStdType.Picture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -523, arg, NIL); END PUTREFPicture; PROCEDURE (this: IPage) Picture* (): CtlStdType.Picture, NEW; BEGIN RETURN CtlStdType.ThisPicture(CtlC.GetAny(this, -523)) END Picture; PROCEDURE (this: IPage) PUTPictureSizeMode* (p1: fmPictureSizeMode), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTPictureSizeMode; PROCEDURE (this: IPage) PictureSizeMode* (): fmPictureSizeMode, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END PictureSizeMode; PROCEDURE (this: IPage) PUTPictureTiling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTPictureTiling; PROCEDURE (this: IPage) PictureTiling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END PictureTiling; PROCEDURE (this: IPage) PUTScrollBars* (p1: fmScrollBars), NEW; BEGIN CtlC.PutInt(this, 265, p1) END PUTScrollBars; PROCEDURE (this: IPage) ScrollBars* (): fmScrollBars, NEW; BEGIN RETURN CtlC.GetInt(this, 265) END ScrollBars; PROCEDURE (this: IPage) _SetScrollHeight* (ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743843, arg, NIL); END _SetScrollHeight; PROCEDURE (this: IPage) _GetScrollHeight* (OUT ScrollHeight: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollHeight, arg[0]); CtlC.CallParMethod(this, 1610743844, arg, NIL); END _GetScrollHeight; PROCEDURE (this: IPage) PUTScrollHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 266, p1) END PUTScrollHeight; PROCEDURE (this: IPage) ScrollHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 266) END ScrollHeight; PROCEDURE (this: IPage) _SetScrollLeft* (ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743847, arg, NIL); END _SetScrollLeft; PROCEDURE (this: IPage) _GetScrollLeft* (OUT ScrollLeft: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollLeft, arg[0]); CtlC.CallParMethod(this, 1610743848, arg, NIL); END _GetScrollLeft; PROCEDURE (this: IPage) PUTScrollLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 267, p1) END PUTScrollLeft; PROCEDURE (this: IPage) ScrollLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 267) END ScrollLeft; PROCEDURE (this: IPage) _SetScrollTop* (ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743851, arg, NIL); END _SetScrollTop; PROCEDURE (this: IPage) _GetScrollTop* (OUT ScrollTop: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollTop, arg[0]); CtlC.CallParMethod(this, 1610743852, arg, NIL); END _GetScrollTop; PROCEDURE (this: IPage) PUTScrollTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 268, p1) END PUTScrollTop; PROCEDURE (this: IPage) ScrollTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 268) END ScrollTop; PROCEDURE (this: IPage) _SetScrollWidth* (ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743855, arg, NIL); END _SetScrollWidth; PROCEDURE (this: IPage) _GetScrollWidth* (OUT ScrollWidth: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScrollWidth, arg[0]); CtlC.CallParMethod(this, 1610743856, arg, NIL); END _GetScrollWidth; PROCEDURE (this: IPage) PUTScrollWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 269, p1) END PUTScrollWidth; PROCEDURE (this: IPage) ScrollWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 269) END ScrollWidth; PROCEDURE (this: IPage) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418101, p1) END PUTTag; PROCEDURE (this: IPage) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418101) END Tag; PROCEDURE (this: IPage) PUTTransitionEffect* (p1: fmTransitionEffect), NEW; BEGIN CtlC.PutInt(this, -2147356415, p1) END PUTTransitionEffect; PROCEDURE (this: IPage) TransitionEffect* (): fmTransitionEffect, NEW; BEGIN RETURN CtlC.GetInt(this, -2147356415) END TransitionEffect; PROCEDURE (this: IPage) PUTTransitionPeriod* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -2147356414, p1) END PUTTransitionPeriod; PROCEDURE (this: IPage) TransitionPeriod* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147356414) END TransitionPeriod; PROCEDURE (this: IPage) PUTVerticalScrollBarSide* (p1: fmVerticalScrollBarSide), NEW; BEGIN CtlC.PutInt(this, 271, p1) END PUTVerticalScrollBarSide; PROCEDURE (this: IPage) VerticalScrollBarSide* (): fmVerticalScrollBarSide, NEW; BEGIN RETURN CtlC.GetInt(this, 271) END VerticalScrollBarSide; PROCEDURE (this: IPage) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418105, p1) END PUTVisible; PROCEDURE (this: IPage) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418105) END Visible; PROCEDURE (this: IPage) PUTZoom* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 272, p1) END PUTZoom; PROCEDURE (this: IPage) Zoom* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 272) END Zoom; PROCEDURE (this: IPage) PUTDesignMode* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 384, p1) END PUTDesignMode; PROCEDURE (this: IPage) DesignMode* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 384) END DesignMode; PROCEDURE (this: IPage) PUTShowToolbox* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 385, p1) END PUTShowToolbox; PROCEDURE (this: IPage) ShowToolbox* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 385) END ShowToolbox; PROCEDURE (this: IPage) PUTShowGridDots* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 386, p1) END PUTShowGridDots; PROCEDURE (this: IPage) ShowGridDots* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 386) END ShowGridDots; PROCEDURE (this: IPage) PUTSnapToGrid* (p1: fmMode), NEW; BEGIN CtlC.PutInt(this, 387, p1) END PUTSnapToGrid; PROCEDURE (this: IPage) SnapToGrid* (): fmMode, NEW; BEGIN RETURN CtlC.GetInt(this, 387) END SnapToGrid; PROCEDURE (this: IPage) PUTGridX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 388, p1) END PUTGridX; PROCEDURE (this: IPage) GridX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 388) END GridX; PROCEDURE (this: IPage) _SetGridX* (GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743881, arg, NIL); END _SetGridX; PROCEDURE (this: IPage) _GetGridX* (OUT GridX: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridX, arg[0]); CtlC.CallParMethod(this, 1610743882, arg, NIL); END _GetGridX; PROCEDURE (this: IPage) PUTGridY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 389, p1) END PUTGridY; PROCEDURE (this: IPage) GridY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 389) END GridY; PROCEDURE (this: IPage) _SetGridY* (GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743885, arg, NIL); END _SetGridY; PROCEDURE (this: IPage) _GetGridY* (OUT GridY: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(GridY, arg[0]); CtlC.CallParMethod(this, 1610743886, arg, NIL); END _GetGridY; PROCEDURE (this: IPage) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 512, NIL); END Copy; PROCEDURE (this: IPage) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 513, NIL); END Cut; PROCEDURE (this: IPage) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 514, NIL); END Paste; PROCEDURE (this: IPage) RedoAction* (), NEW; BEGIN CtlC.CallMethod(this, 515, NIL); END RedoAction; PROCEDURE (this: IPage) Repaint* (), NEW; BEGIN CtlC.CallMethod(this, 516, NIL); END Repaint; PROCEDURE (this: IPage) Scroll* ((* optional *) xAction: CtlT.Any; yAction: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(xAction, arg[1]); CtlC.AnyVar(yAction, arg[0]); CtlC.CallParMethod(this, 517, arg, NIL); END Scroll; PROCEDURE (this: IPage) SetDefaultTabOrder* (), NEW; BEGIN CtlC.CallMethod(this, 518, NIL); END SetDefaultTabOrder; PROCEDURE (this: IPage) UndoAction* (), NEW; BEGIN CtlC.CallMethod(this, 519, NIL); END UndoAction; PROCEDURE (this: IPage) PUTAccelerator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -543, p1) END PUTAccelerator; PROCEDURE (this: IPage) Accelerator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -543) END Accelerator; PROCEDURE (this: IPage) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147418104) END Parent; (* ---------- Pages, dual ---------- *) PROCEDURE (this: Pages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END Count; PROCEDURE (this: Pages) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Pages) Item* (varg: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Pages) Enum* (): CtlT.IUnknown, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743811, ret); RETURN CtlC.VarIntfce(ret) END Enum; PROCEDURE (this: Pages) Add* ((* optional *) bstrName: CtlT.Any; bstrCaption: CtlT.Any; lIndex: CtlT.Any): Page, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(bstrName, arg[2]); CtlC.AnyVar(bstrCaption, arg[1]); CtlC.AnyVar(lIndex, arg[0]); CtlC.CallParMethod(this, 66, arg, ret); RETURN ThisIPage(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Pages) _AddCtrl* (VAR clsid: INTEGER; bstrName: ARRAY OF CHAR; bstrCaption: ARRAY OF CHAR): Page, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RefIntVar(clsid, arg[2]); CtlC.StrVar(bstrName, arg[1]); CtlC.StrVar(bstrCaption, arg[0]); CtlC.CallParMethod(this, 1610743813, arg, ret); RETURN ThisIPage(CtlC.VarAny(ret)) END _AddCtrl; PROCEDURE (this: Pages) _InsertCtrl* (VAR clsid: INTEGER; bstrName: ARRAY OF CHAR; bstrCaption: ARRAY OF CHAR; lIndex: INTEGER): Page, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.RefIntVar(clsid, arg[3]); CtlC.StrVar(bstrName, arg[2]); CtlC.StrVar(bstrCaption, arg[1]); CtlC.IntVar(lIndex, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, ret); RETURN ThisIPage(CtlC.VarAny(ret)) END _InsertCtrl; PROCEDURE (this: Pages) _GetItemByIndex* (lIndex: INTEGER): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lIndex, arg[0]); CtlC.CallParMethod(this, 1610743815, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _GetItemByIndex; PROCEDURE (this: Pages) _GetItemByName* (pstrName: ARRAY OF CHAR): Control, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(pstrName, arg[0]); CtlC.CallParMethod(this, 1610743816, arg, ret); RETURN ThisIControl(CtlC.VarAny(ret)) END _GetItemByName; PROCEDURE (this: Pages) Remove* (varg: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varg, arg[0]); CtlC.CallParMethod(this, 67, arg, NIL); END Remove; PROCEDURE (this: Pages) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 62, NIL); END Clear; (* ---------- IMultiPage, hidden, dual ---------- *) PROCEDURE (this: IMultiPage) PUTBackColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: IMultiPage) BackColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: IMultiPage) PUTForeColor* (p1: OLE_COLOR), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: IMultiPage) ForeColor* (): OLE_COLOR, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: IMultiPage) PUT_Font_Reserved* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 2147483135, p1) END PUT_Font_Reserved; PROCEDURE (this: IMultiPage) PUTREFFont* (p1: Font), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, -512, arg, NIL); END PUTREFFont; PROCEDURE (this: IMultiPage) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, -512)) END Font; PROCEDURE (this: IMultiPage) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTFontName; PROCEDURE (this: IMultiPage) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END FontName; PROCEDURE (this: IMultiPage) PUTFontBold* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTFontBold; PROCEDURE (this: IMultiPage) FontBold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END FontBold; PROCEDURE (this: IMultiPage) PUTFontItalic* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTFontItalic; PROCEDURE (this: IMultiPage) FontItalic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END FontItalic; PROCEDURE (this: IMultiPage) PUTFontUnderline* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTFontUnderline; PROCEDURE (this: IMultiPage) FontUnderline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END FontUnderline; PROCEDURE (this: IMultiPage) PUTFontStrikethru* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTFontStrikethru; PROCEDURE (this: IMultiPage) FontStrikethru* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END FontStrikethru; PROCEDURE (this: IMultiPage) PUTFontSize* (p1: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, p1) END PUTFontSize; PROCEDURE (this: IMultiPage) FontSize* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END FontSize; PROCEDURE (this: IMultiPage) PUTMultiRow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 514, p1) END PUTMultiRow; PROCEDURE (this: IMultiPage) MultiRow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 514) END MultiRow; PROCEDURE (this: IMultiPage) PUTStyle* (p1: fmTabStyle), NEW; BEGIN CtlC.PutInt(this, 513, p1) END PUTStyle; PROCEDURE (this: IMultiPage) Style* (): fmTabStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 513) END Style; PROCEDURE (this: IMultiPage) PUTTabOrientation* (p1: fmTabOrientation), NEW; BEGIN CtlC.PutInt(this, 512, p1) END PUTTabOrientation; PROCEDURE (this: IMultiPage) TabOrientation* (): fmTabOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 512) END TabOrientation; PROCEDURE (this: IMultiPage) _SetTabFixedWidth* (Width: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Width, arg[0]); CtlC.CallParMethod(this, 1610743833, arg, NIL); END _SetTabFixedWidth; PROCEDURE (this: IMultiPage) _GetTabFixedWidth* (OUT Width: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Width, arg[0]); CtlC.CallParMethod(this, 1610743834, arg, NIL); END _GetTabFixedWidth; PROCEDURE (this: IMultiPage) _SetTabFixedHeight* (Height: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 1610743835, arg, NIL); END _SetTabFixedHeight; PROCEDURE (this: IMultiPage) _GetTabFixedHeight* (OUT Height: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.RefIntVar(Height, arg[0]); CtlC.CallParMethod(this, 1610743836, arg, NIL); END _GetTabFixedHeight; PROCEDURE (this: IMultiPage) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: IMultiPage) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: IMultiPage) SelectedItem* (): Page, NEW; BEGIN RETURN ThisIPage(CtlC.GetAny(this, 545)) END SelectedItem; PROCEDURE (this: IMultiPage) Pages* (): Pages, NEW; BEGIN RETURN ThisPages(CtlC.GetAny(this, 0)) END Pages; PROCEDURE (this: IMultiPage) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 528, p1) END PUTValue; PROCEDURE (this: IMultiPage) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 528) END Value; PROCEDURE (this: IMultiPage) PUTTabFixedWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 515, p1) END PUTTabFixedWidth; PROCEDURE (this: IMultiPage) TabFixedWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 515) END TabFixedWidth; PROCEDURE (this: IMultiPage) PUTTabFixedHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 516, p1) END PUTTabFixedHeight; PROCEDURE (this: IMultiPage) TabFixedHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 516) END TabFixedHeight; PROCEDURE (this: IMultiPage) PUTFontWeight* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, p1) END PUTFontWeight; PROCEDURE (this: IMultiPage) FontWeight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END FontWeight; (* ---------- MultiPageEvents, hidden ---------- *) PROCEDURE (this: MultiPageEvents) AddControl* (Index: INTEGER; control: Control), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) BeforeDragOver* (Index: INTEGER; Cancel: ReturnBoolean; control: Control; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; State: fmDragState; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) BeforeDropOrPaste* (Index: INTEGER; Cancel: ReturnBoolean; control: Control; Action: fmAction; Data: DataObject; X: SHORTREAL; Y: SHORTREAL; Effect: ReturnEffect; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Change* (), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Click* (Index: INTEGER), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) DblClick* (Index: INTEGER; Cancel: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Error* (Index: INTEGER; Number: SHORTINT; Description: ReturnString; SCode: INTEGER; Source: ARRAY OF CHAR; HelpFile: ARRAY OF CHAR; HelpContext: INTEGER; CancelDisplay: ReturnBoolean), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) KeyDown* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) KeyPress* (KeyAscii: ReturnInteger), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) KeyUp* (KeyCode: ReturnInteger; Shift: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Layout* (Index: INTEGER), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) MouseDown* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) MouseMove* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) MouseUp* (Index: INTEGER; Button: SHORTINT; Shift: SHORTINT; X: SHORTREAL; Y: SHORTREAL), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) RemoveControl* (Index: INTEGER; control: Control), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Scroll* (Index: INTEGER; ActionX: fmScrollAction; ActionY: fmScrollAction; RequestDx: SHORTREAL; RequestDy: SHORTREAL; ActualDx: ReturnSingle; ActualDy: ReturnSingle), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Zoom* (Index: INTEGER; VAR Percent: SHORTINT), NEW, ABSTRACT; PROCEDURE (this: MultiPageEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 768: ASSERT(n = 2, 11); this.AddControl(CtlC.VarInt(par[1]), ThisIControl(CtlC.VarAny(par[0]))) | 3: ASSERT(n = 9, 11); this.BeforeDragOver(CtlC.VarInt(par[8]), ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), ThisIDataAutoWrapper(CtlC.VarAny(par[5])), CtlC.VarSReal(par[4]), CtlC.VarSReal(par[3]), CtlC.VarInt(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 4: ASSERT(n = 9, 11); this.BeforeDropOrPaste(CtlC.VarInt(par[8]), ThisIReturnBoolean(CtlC.VarAny(par[7])), ThisIControl(CtlC.VarAny(par[6])), CtlC.VarInt(par[5]), ThisIDataAutoWrapper(CtlC.VarAny(par[4])), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnEffect(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 2: ASSERT(n = 0, 11); this.Change() | -600: ASSERT(n = 1, 11); this.Click(CtlC.VarInt(par[0])) | -601: ASSERT(n = 2, 11); this.DblClick(CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -608: ASSERT(n = 8, 11); this.Error(CtlC.VarInt(par[7]), CtlC.VarSInt(par[6]), ThisIReturnString(CtlC.VarAny(par[5])), CtlC.VarInt(par[4]), CtlC.VarStr(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), ThisIReturnBoolean(CtlC.VarAny(par[0]))) | -602: ASSERT(n = 2, 11); this.KeyDown(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | -603: ASSERT(n = 1, 11); this.KeyPress(ThisIReturnInteger(CtlC.VarAny(par[0]))) | -604: ASSERT(n = 2, 11); this.KeyUp(ThisIReturnInteger(CtlC.VarAny(par[1])), CtlC.VarSInt(par[0])) | 770: ASSERT(n = 1, 11); this.Layout(CtlC.VarInt(par[0])) | -605: ASSERT(n = 5, 11); this.MouseDown(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -606: ASSERT(n = 5, 11); this.MouseMove(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | -607: ASSERT(n = 5, 11); this.MouseUp(CtlC.VarInt(par[4]), CtlC.VarSInt(par[3]), CtlC.VarSInt(par[2]), CtlC.VarSReal(par[1]), CtlC.VarSReal(par[0])) | 771: ASSERT(n = 2, 11); this.RemoveControl(CtlC.VarInt(par[1]), ThisIControl(CtlC.VarAny(par[0]))) | 772: ASSERT(n = 7, 11); this.Scroll(CtlC.VarInt(par[6]), CtlC.VarInt(par[5]), CtlC.VarInt(par[4]), CtlC.VarSReal(par[3]), CtlC.VarSReal(par[2]), ThisIReturnSingle(CtlC.VarAny(par[1])), ThisIReturnSingle(CtlC.VarAny(par[0]))) | 773: ASSERT(n = 2, 11); this.Zoom(CtlC.VarInt(par[1]), CtlC.VarRefSInt(par[0])[0]) END END Invoke; PROCEDURE (this: MultiPageEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{7B020EC8-AF6C-11CE-9F46-00AA00574A4F}" END GetIID; PROCEDURE NewReturnInteger* (): IReturnInteger; BEGIN RETURN ThisIReturnInteger(CtlC.NewObj("{82B02373-B5BC-11CF-810F-00A0C9030074}")) END NewReturnInteger; PROCEDURE NewReturnBoolean* (): IReturnBoolean; BEGIN RETURN ThisIReturnBoolean(CtlC.NewObj("{82B02374-B5BC-11CF-810F-00A0C9030074}")) END NewReturnBoolean; PROCEDURE NewReturnString* (): IReturnString; BEGIN RETURN ThisIReturnString(CtlC.NewObj("{82B02375-B5BC-11CF-810F-00A0C9030074}")) END NewReturnString; PROCEDURE NewReturnSingle* (): IReturnSingle; BEGIN RETURN ThisIReturnSingle(CtlC.NewObj("{8A683C92-BA84-11CF-8110-00A0C9030074}")) END NewReturnSingle; PROCEDURE NewReturnEffect* (): IReturnEffect; BEGIN RETURN ThisIReturnEffect(CtlC.NewObj("{8A683C93-BA84-11CF-8110-00A0C9030074}")) END NewReturnEffect; PROCEDURE NewDataObject* (): IDataAutoWrapper; BEGIN RETURN ThisIDataAutoWrapper(CtlC.NewObj("{1C3B4210-F441-11CE-B9EA-00AA006B1A69}")) END NewDataObject; PROCEDURE NewControl* (): IControl; BEGIN RETURN ThisIControl(CtlC.NewObj("{909E0AE0-16DC-11CE-9E98-00AA00574A4F}")) END NewControl; PROCEDURE NewUserForm* (): _UserForm; BEGIN RETURN This_UserForm(CtlC.NewObj("{C62A69F0-16DC-11CE-9E98-00AA00574A4F}")) END NewUserForm; PROCEDURE NewFrame* (): IOptionFrame; BEGIN RETURN ThisIOptionFrame(CtlC.NewObj("{6E182020-F460-11CE-9BCD-00AA00608E01}")) END NewFrame; PROCEDURE NewLabel* (): ILabelControl; BEGIN RETURN ThisILabelControl(CtlC.NewObj("{978C9E23-D4B0-11CE-BF2D-00AA003F40D0}")) END NewLabel; PROCEDURE NewCommandButton* (): ICommandButton; BEGIN RETURN ThisICommandButton(CtlC.NewObj("{D7053240-CE69-11CD-A777-00DD01143C57}")) END NewCommandButton; PROCEDURE NewTextBox* (): IMdcText; BEGIN RETURN ThisIMdcText(CtlC.NewObj("{8BD21D10-EC42-11CE-9E0D-00AA006002F3}")) END NewTextBox; PROCEDURE NewListBox* (): IMdcList; BEGIN RETURN ThisIMdcList(CtlC.NewObj("{8BD21D20-EC42-11CE-9E0D-00AA006002F3}")) END NewListBox; PROCEDURE NewComboBox* (): IMdcCombo; BEGIN RETURN ThisIMdcCombo(CtlC.NewObj("{8BD21D30-EC42-11CE-9E0D-00AA006002F3}")) END NewComboBox; PROCEDURE NewCheckBox* (): IMdcCheckBox; BEGIN RETURN ThisIMdcCheckBox(CtlC.NewObj("{8BD21D40-EC42-11CE-9E0D-00AA006002F3}")) END NewCheckBox; PROCEDURE NewOptionButton* (): IMdcOptionButton; BEGIN RETURN ThisIMdcOptionButton(CtlC.NewObj("{8BD21D50-EC42-11CE-9E0D-00AA006002F3}")) END NewOptionButton; PROCEDURE NewToggleButton* (): IMdcToggleButton; BEGIN RETURN ThisIMdcToggleButton(CtlC.NewObj("{8BD21D60-EC42-11CE-9E0D-00AA006002F3}")) END NewToggleButton; PROCEDURE NewNewFont* (): Font; BEGIN RETURN ThisFont(CtlC.NewObj("{AFC20920-DA4E-11CE-B943-00AA006887B4}")) END NewNewFont; PROCEDURE NewScrollBar* (): IScrollbar; BEGIN RETURN ThisIScrollbar(CtlC.NewObj("{DFD181E0-5E2F-11CE-A449-00AA004A803D}")) END NewScrollBar; PROCEDURE NewTabStrip* (): ITabStrip; BEGIN RETURN ThisITabStrip(CtlC.NewObj("{EAE50EB0-4A62-11CE-BED6-00AA00611080}")) END NewTabStrip; PROCEDURE NewSpinButton* (): ISpinbutton; BEGIN RETURN ThisISpinbutton(CtlC.NewObj("{79176FB0-B7F2-11CE-97EF-00AA006D2776}")) END NewSpinButton; PROCEDURE NewImage* (): IImage; BEGIN RETURN ThisIImage(CtlC.NewObj("{4C599241-6926-101B-9992-00000B65C6F9}")) END NewImage; PROCEDURE NewHTMLSubmit* (): IWHTMLSubmitButton; BEGIN RETURN ThisIWHTMLSubmitButton(CtlC.NewObj("{5512D110-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLSubmit; PROCEDURE NewHTMLImage* (): IWHTMLImage; BEGIN RETURN ThisIWHTMLImage(CtlC.NewObj("{5512D112-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLImage; PROCEDURE NewHTMLReset* (): IWHTMLReset; BEGIN RETURN ThisIWHTMLReset(CtlC.NewObj("{5512D114-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLReset; PROCEDURE NewHTMLCheckbox* (): IWHTMLCheckbox; BEGIN RETURN ThisIWHTMLCheckbox(CtlC.NewObj("{5512D116-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLCheckbox; PROCEDURE NewHTMLOption* (): IWHTMLOption; BEGIN RETURN ThisIWHTMLOption(CtlC.NewObj("{5512D118-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLOption; PROCEDURE NewHTMLText* (): IWHTMLText; BEGIN RETURN ThisIWHTMLText(CtlC.NewObj("{5512D11A-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLText; PROCEDURE NewHTMLHidden* (): IWHTMLHidden; BEGIN RETURN ThisIWHTMLHidden(CtlC.NewObj("{5512D11C-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLHidden; PROCEDURE NewHTMLPassword* (): IWHTMLPassword; BEGIN RETURN ThisIWHTMLPassword(CtlC.NewObj("{5512D11E-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLPassword; PROCEDURE NewHTMLSelect* (): IWHTMLSelect; BEGIN RETURN ThisIWHTMLSelect(CtlC.NewObj("{5512D122-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLSelect; PROCEDURE NewHTMLTextArea* (): IWHTMLTextArea; BEGIN RETURN ThisIWHTMLTextArea(CtlC.NewObj("{5512D124-5CC6-11CF-8D67-00AA00BDCE1D}")) END NewHTMLTextArea; PROCEDURE NewMultiPage* (): IMultiPage; BEGIN RETURN ThisIMultiPage(CtlC.NewObj("{46E31370-3F7A-11CE-BED6-00AA00611080}")) END NewMultiPage; PROCEDURE NewPage* (): IPage; BEGIN RETURN ThisIPage(CtlC.NewObj("{5CEF5610-713D-11CE-80C9-00AA00611080}")) END NewPage; END CtlMSForms.

Ctl/Mod/MSForms.odc

MODULE CtlOffice; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Office 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\vbaoff9.chm, id: 1 *) (* guid: {2DF8D04C-5BFA-101B-BDE5-00AA0044DE52}, lcid: 0, syskind: win32, version: 2.1 *) IMPORT CtlT, CtlC; CONST (* MsoLineDashStyle *) msoLineDashStyleMixed* = -2; msoLineSolid* = 1; msoLineSquareDot* = 2; msoLineRoundDot* = 3; msoLineDash* = 4; msoLineDashDot* = 5; msoLineDashDotDot* = 6; msoLineLongDash* = 7; msoLineLongDashDot* = 8; (* MsoLineStyle *) msoLineStyleMixed* = -2; msoLineSingle* = 1; msoLineThinThin* = 2; msoLineThinThick* = 3; msoLineThickThin* = 4; msoLineThickBetweenThin* = 5; (* MsoArrowheadStyle *) msoArrowheadStyleMixed* = -2; msoArrowheadNone* = 1; msoArrowheadTriangle* = 2; msoArrowheadOpen* = 3; msoArrowheadStealth* = 4; msoArrowheadDiamond* = 5; msoArrowheadOval* = 6; (* MsoArrowheadWidth *) msoArrowheadWidthMixed* = -2; msoArrowheadNarrow* = 1; msoArrowheadWidthMedium* = 2; msoArrowheadWide* = 3; (* MsoArrowheadLength *) msoArrowheadLengthMixed* = -2; msoArrowheadShort* = 1; msoArrowheadLengthMedium* = 2; msoArrowheadLong* = 3; (* MsoFillType *) msoFillMixed* = -2; msoFillSolid* = 1; msoFillPatterned* = 2; msoFillGradient* = 3; msoFillTextured* = 4; msoFillBackground* = 5; msoFillPicture* = 6; (* MsoGradientStyle *) msoGradientMixed* = -2; msoGradientHorizontal* = 1; msoGradientVertical* = 2; msoGradientDiagonalUp* = 3; msoGradientDiagonalDown* = 4; msoGradientFromCorner* = 5; msoGradientFromTitle* = 6; msoGradientFromCenter* = 7; (* MsoGradientColorType *) msoGradientColorMixed* = -2; msoGradientOneColor* = 1; msoGradientTwoColors* = 2; msoGradientPresetColors* = 3; (* MsoTextureType *) msoTextureTypeMixed* = -2; msoTexturePreset* = 1; msoTextureUserDefined* = 2; (* MsoPresetTexture *) msoPresetTextureMixed* = -2; msoTexturePapyrus* = 1; msoTextureCanvas* = 2; msoTextureDenim* = 3; msoTextureWovenMat* = 4; msoTextureWaterDroplets* = 5; msoTexturePaperBag* = 6; msoTextureFishFossil* = 7; msoTextureSand* = 8; msoTextureGreenMarble* = 9; msoTextureWhiteMarble* = 10; msoTextureBrownMarble* = 11; msoTextureGranite* = 12; msoTextureNewsprint* = 13; msoTextureRecycledPaper* = 14; msoTextureParchment* = 15; msoTextureStationery* = 16; msoTextureBlueTissuePaper* = 17; msoTexturePinkTissuePaper* = 18; msoTexturePurpleMesh* = 19; msoTextureBouquet* = 20; msoTextureCork* = 21; msoTextureWalnut* = 22; msoTextureOak* = 23; msoTextureMediumWood* = 24; (* MsoPatternType *) msoPatternMixed* = -2; msoPattern5Percent* = 1; msoPattern10Percent* = 2; msoPattern20Percent* = 3; msoPattern25Percent* = 4; msoPattern30Percent* = 5; msoPattern40Percent* = 6; msoPattern50Percent* = 7; msoPattern60Percent* = 8; msoPattern70Percent* = 9; msoPattern75Percent* = 10; msoPattern80Percent* = 11; msoPattern90Percent* = 12; msoPatternDarkHorizontal* = 13; msoPatternDarkVertical* = 14; msoPatternDarkDownwardDiagonal* = 15; msoPatternDarkUpwardDiagonal* = 16; msoPatternSmallCheckerBoard* = 17; msoPatternTrellis* = 18; msoPatternLightHorizontal* = 19; msoPatternLightVertical* = 20; msoPatternLightDownwardDiagonal* = 21; msoPatternLightUpwardDiagonal* = 22; msoPatternSmallGrid* = 23; msoPatternDottedDiamond* = 24; msoPatternWideDownwardDiagonal* = 25; msoPatternWideUpwardDiagonal* = 26; msoPatternDashedUpwardDiagonal* = 27; msoPatternDashedDownwardDiagonal* = 28; msoPatternNarrowVertical* = 29; msoPatternNarrowHorizontal* = 30; msoPatternDashedVertical* = 31; msoPatternDashedHorizontal* = 32; msoPatternLargeConfetti* = 33; msoPatternLargeGrid* = 34; msoPatternHorizontalBrick* = 35; msoPatternLargeCheckerBoard* = 36; msoPatternSmallConfetti* = 37; msoPatternZigZag* = 38; msoPatternSolidDiamond* = 39; msoPatternDiagonalBrick* = 40; msoPatternOutlinedDiamond* = 41; msoPatternPlaid* = 42; msoPatternSphere* = 43; msoPatternWeave* = 44; msoPatternDottedGrid* = 45; msoPatternDivot* = 46; msoPatternShingle* = 47; msoPatternWave* = 48; (* MsoPresetGradientType *) msoPresetGradientMixed* = -2; msoGradientEarlySunset* = 1; msoGradientLateSunset* = 2; msoGradientNightfall* = 3; msoGradientDaybreak* = 4; msoGradientHorizon* = 5; msoGradientDesert* = 6; msoGradientOcean* = 7; msoGradientCalmWater* = 8; msoGradientFire* = 9; msoGradientFog* = 10; msoGradientMoss* = 11; msoGradientPeacock* = 12; msoGradientWheat* = 13; msoGradientParchment* = 14; msoGradientMahogany* = 15; msoGradientRainbow* = 16; msoGradientRainbowII* = 17; msoGradientGold* = 18; msoGradientGoldII* = 19; msoGradientBrass* = 20; msoGradientChrome* = 21; msoGradientChromeII* = 22; msoGradientSilver* = 23; msoGradientSapphire* = 24; (* MsoShadowType *) msoShadowMixed* = -2; msoShadow1* = 1; msoShadow2* = 2; msoShadow3* = 3; msoShadow4* = 4; msoShadow5* = 5; msoShadow6* = 6; msoShadow7* = 7; msoShadow8* = 8; msoShadow9* = 9; msoShadow10* = 10; msoShadow11* = 11; msoShadow12* = 12; msoShadow13* = 13; msoShadow14* = 14; msoShadow15* = 15; msoShadow16* = 16; msoShadow17* = 17; msoShadow18* = 18; msoShadow19* = 19; msoShadow20* = 20; (* MsoPresetTextEffect *) msoTextEffectMixed* = -2; msoTextEffect1* = 0; msoTextEffect2* = 1; msoTextEffect3* = 2; msoTextEffect4* = 3; msoTextEffect5* = 4; msoTextEffect6* = 5; msoTextEffect7* = 6; msoTextEffect8* = 7; msoTextEffect9* = 8; msoTextEffect10* = 9; msoTextEffect11* = 10; msoTextEffect12* = 11; msoTextEffect13* = 12; msoTextEffect14* = 13; msoTextEffect15* = 14; msoTextEffect16* = 15; msoTextEffect17* = 16; msoTextEffect18* = 17; msoTextEffect19* = 18; msoTextEffect20* = 19; msoTextEffect21* = 20; msoTextEffect22* = 21; msoTextEffect23* = 22; msoTextEffect24* = 23; msoTextEffect25* = 24; msoTextEffect26* = 25; msoTextEffect27* = 26; msoTextEffect28* = 27; msoTextEffect29* = 28; msoTextEffect30* = 29; (* MsoPresetTextEffectShape *) msoTextEffectShapeMixed* = -2; msoTextEffectShapePlainText* = 1; msoTextEffectShapeStop* = 2; msoTextEffectShapeTriangleUp* = 3; msoTextEffectShapeTriangleDown* = 4; msoTextEffectShapeChevronUp* = 5; msoTextEffectShapeChevronDown* = 6; msoTextEffectShapeRingInside* = 7; msoTextEffectShapeRingOutside* = 8; msoTextEffectShapeArchUpCurve* = 9; msoTextEffectShapeArchDownCurve* = 10; msoTextEffectShapeCircleCurve* = 11; msoTextEffectShapeButtonCurve* = 12; msoTextEffectShapeArchUpPour* = 13; msoTextEffectShapeArchDownPour* = 14; msoTextEffectShapeCirclePour* = 15; msoTextEffectShapeButtonPour* = 16; msoTextEffectShapeCurveUp* = 17; msoTextEffectShapeCurveDown* = 18; msoTextEffectShapeCanUp* = 19; msoTextEffectShapeCanDown* = 20; msoTextEffectShapeWave1* = 21; msoTextEffectShapeWave2* = 22; msoTextEffectShapeDoubleWave1* = 23; msoTextEffectShapeDoubleWave2* = 24; msoTextEffectShapeInflate* = 25; msoTextEffectShapeDeflate* = 26; msoTextEffectShapeInflateBottom* = 27; msoTextEffectShapeDeflateBottom* = 28; msoTextEffectShapeInflateTop* = 29; msoTextEffectShapeDeflateTop* = 30; msoTextEffectShapeDeflateInflate* = 31; msoTextEffectShapeDeflateInflateDeflate* = 32; msoTextEffectShapeFadeRight* = 33; msoTextEffectShapeFadeLeft* = 34; msoTextEffectShapeFadeUp* = 35; msoTextEffectShapeFadeDown* = 36; msoTextEffectShapeSlantUp* = 37; msoTextEffectShapeSlantDown* = 38; msoTextEffectShapeCascadeUp* = 39; msoTextEffectShapeCascadeDown* = 40; (* MsoTextEffectAlignment *) msoTextEffectAlignmentMixed* = -2; msoTextEffectAlignmentLeft* = 1; msoTextEffectAlignmentCentered* = 2; msoTextEffectAlignmentRight* = 3; msoTextEffectAlignmentLetterJustify* = 4; msoTextEffectAlignmentWordJustify* = 5; msoTextEffectAlignmentStretchJustify* = 6; (* MsoPresetLightingDirection *) msoPresetLightingDirectionMixed* = -2; msoLightingTopLeft* = 1; msoLightingTop* = 2; msoLightingTopRight* = 3; msoLightingLeft* = 4; msoLightingNone* = 5; msoLightingRight* = 6; msoLightingBottomLeft* = 7; msoLightingBottom* = 8; msoLightingBottomRight* = 9; (* MsoPresetLightingSoftness *) msoPresetLightingSoftnessMixed* = -2; msoLightingDim* = 1; msoLightingNormal* = 2; msoLightingBright* = 3; (* MsoPresetMaterial *) msoPresetMaterialMixed* = -2; msoMaterialMatte* = 1; msoMaterialPlastic* = 2; msoMaterialMetal* = 3; msoMaterialWireFrame* = 4; (* MsoPresetExtrusionDirection *) msoPresetExtrusionDirectionMixed* = -2; msoExtrusionBottomRight* = 1; msoExtrusionBottom* = 2; msoExtrusionBottomLeft* = 3; msoExtrusionRight* = 4; msoExtrusionNone* = 5; msoExtrusionLeft* = 6; msoExtrusionTopRight* = 7; msoExtrusionTop* = 8; msoExtrusionTopLeft* = 9; (* MsoPresetThreeDFormat *) msoPresetThreeDFormatMixed* = -2; msoThreeD1* = 1; msoThreeD2* = 2; msoThreeD3* = 3; msoThreeD4* = 4; msoThreeD5* = 5; msoThreeD6* = 6; msoThreeD7* = 7; msoThreeD8* = 8; msoThreeD9* = 9; msoThreeD10* = 10; msoThreeD11* = 11; msoThreeD12* = 12; msoThreeD13* = 13; msoThreeD14* = 14; msoThreeD15* = 15; msoThreeD16* = 16; msoThreeD17* = 17; msoThreeD18* = 18; msoThreeD19* = 19; msoThreeD20* = 20; (* MsoExtrusionColorType *) msoExtrusionColorTypeMixed* = -2; msoExtrusionColorAutomatic* = 1; msoExtrusionColorCustom* = 2; (* MsoAlignCmd *) msoAlignLefts* = 0; msoAlignCenters* = 1; msoAlignRights* = 2; msoAlignTops* = 3; msoAlignMiddles* = 4; msoAlignBottoms* = 5; (* MsoDistributeCmd *) msoDistributeHorizontally* = 0; msoDistributeVertically* = 1; (* MsoConnectorType *) msoConnectorTypeMixed* = -2; msoConnectorStraight* = 1; msoConnectorElbow* = 2; msoConnectorCurve* = 3; (* MsoHorizontalAnchor *) msoHorizontalAnchorMixed* = -2; msoAnchorNone* = 1; msoAnchorCenter* = 2; (* MsoVerticalAnchor *) msoVerticalAnchorMixed* = -2; msoAnchorTop* = 1; msoAnchorTopBaseline* = 2; msoAnchorMiddle* = 3; msoAnchorBottom* = 4; msoAnchorBottomBaseLine* = 5; (* MsoOrientation *) msoOrientationMixed* = -2; msoOrientationHorizontal* = 1; msoOrientationVertical* = 2; (* MsoZOrderCmd *) msoBringToFront* = 0; msoSendToBack* = 1; msoBringForward* = 2; msoSendBackward* = 3; msoBringInFrontOfText* = 4; msoSendBehindText* = 5; (* MsoSegmentType *) msoSegmentLine* = 0; msoSegmentCurve* = 1; (* MsoEditingType *) msoEditingAuto* = 0; msoEditingCorner* = 1; msoEditingSmooth* = 2; msoEditingSymmetric* = 3; (* MsoAutoShapeType *) msoShapeMixed* = -2; msoShapeRectangle* = 1; msoShapeParallelogram* = 2; msoShapeTrapezoid* = 3; msoShapeDiamond* = 4; msoShapeRoundedRectangle* = 5; msoShapeOctagon* = 6; msoShapeIsoscelesTriangle* = 7; msoShapeRightTriangle* = 8; msoShapeOval* = 9; msoShapeHexagon* = 10; msoShapeCross* = 11; msoShapeRegularPentagon* = 12; msoShapeCan* = 13; msoShapeCube* = 14; msoShapeBevel* = 15; msoShapeFoldedCorner* = 16; msoShapeSmileyFace* = 17; msoShapeDonut* = 18; msoShapeNoSymbol* = 19; msoShapeBlockArc* = 20; msoShapeHeart* = 21; msoShapeLightningBolt* = 22; msoShapeSun* = 23; msoShapeMoon* = 24; msoShapeArc* = 25; msoShapeDoubleBracket* = 26; msoShapeDoubleBrace* = 27; msoShapePlaque* = 28; msoShapeLeftBracket* = 29; msoShapeRightBracket* = 30; msoShapeLeftBrace* = 31; msoShapeRightBrace* = 32; msoShapeRightArrow* = 33; msoShapeLeftArrow* = 34; msoShapeUpArrow* = 35; msoShapeDownArrow* = 36; msoShapeLeftRightArrow* = 37; msoShapeUpDownArrow* = 38; msoShapeQuadArrow* = 39; msoShapeLeftRightUpArrow* = 40; msoShapeBentArrow* = 41; msoShapeUTurnArrow* = 42; msoShapeLeftUpArrow* = 43; msoShapeBentUpArrow* = 44; msoShapeCurvedRightArrow* = 45; msoShapeCurvedLeftArrow* = 46; msoShapeCurvedUpArrow* = 47; msoShapeCurvedDownArrow* = 48; msoShapeStripedRightArrow* = 49; msoShapeNotchedRightArrow* = 50; msoShapePentagon* = 51; msoShapeChevron* = 52; msoShapeRightArrowCallout* = 53; msoShapeLeftArrowCallout* = 54; msoShapeUpArrowCallout* = 55; msoShapeDownArrowCallout* = 56; msoShapeLeftRightArrowCallout* = 57; msoShapeUpDownArrowCallout* = 58; msoShapeQuadArrowCallout* = 59; msoShapeCircularArrow* = 60; msoShapeFlowchartProcess* = 61; msoShapeFlowchartAlternateProcess* = 62; msoShapeFlowchartDecision* = 63; msoShapeFlowchartData* = 64; msoShapeFlowchartPredefinedProcess* = 65; msoShapeFlowchartInternalStorage* = 66; msoShapeFlowchartDocument* = 67; msoShapeFlowchartMultidocument* = 68; msoShapeFlowchartTerminator* = 69; msoShapeFlowchartPreparation* = 70; msoShapeFlowchartManualInput* = 71; msoShapeFlowchartManualOperation* = 72; msoShapeFlowchartConnector* = 73; msoShapeFlowchartOffpageConnector* = 74; msoShapeFlowchartCard* = 75; msoShapeFlowchartPunchedTape* = 76; msoShapeFlowchartSummingJunction* = 77; msoShapeFlowchartOr* = 78; msoShapeFlowchartCollate* = 79; msoShapeFlowchartSort* = 80; msoShapeFlowchartExtract* = 81; msoShapeFlowchartMerge* = 82; msoShapeFlowchartStoredData* = 83; msoShapeFlowchartDelay* = 84; msoShapeFlowchartSequentialAccessStorage* = 85; msoShapeFlowchartMagneticDisk* = 86; msoShapeFlowchartDirectAccessStorage* = 87; msoShapeFlowchartDisplay* = 88; msoShapeExplosion1* = 89; msoShapeExplosion2* = 90; msoShape4pointStar* = 91; msoShape5pointStar* = 92; msoShape8pointStar* = 93; msoShape16pointStar* = 94; msoShape24pointStar* = 95; msoShape32pointStar* = 96; msoShapeUpRibbon* = 97; msoShapeDownRibbon* = 98; msoShapeCurvedUpRibbon* = 99; msoShapeCurvedDownRibbon* = 100; msoShapeVerticalScroll* = 101; msoShapeHorizontalScroll* = 102; msoShapeWave* = 103; msoShapeDoubleWave* = 104; msoShapeRectangularCallout* = 105; msoShapeRoundedRectangularCallout* = 106; msoShapeOvalCallout* = 107; msoShapeCloudCallout* = 108; msoShapeLineCallout1* = 109; msoShapeLineCallout2* = 110; msoShapeLineCallout3* = 111; msoShapeLineCallout4* = 112; msoShapeLineCallout1AccentBar* = 113; msoShapeLineCallout2AccentBar* = 114; msoShapeLineCallout3AccentBar* = 115; msoShapeLineCallout4AccentBar* = 116; msoShapeLineCallout1NoBorder* = 117; msoShapeLineCallout2NoBorder* = 118; msoShapeLineCallout3NoBorder* = 119; msoShapeLineCallout4NoBorder* = 120; msoShapeLineCallout1BorderandAccentBar* = 121; msoShapeLineCallout2BorderandAccentBar* = 122; msoShapeLineCallout3BorderandAccentBar* = 123; msoShapeLineCallout4BorderandAccentBar* = 124; msoShapeActionButtonCustom* = 125; msoShapeActionButtonHome* = 126; msoShapeActionButtonHelp* = 127; msoShapeActionButtonInformation* = 128; msoShapeActionButtonBackorPrevious* = 129; msoShapeActionButtonForwardorNext* = 130; msoShapeActionButtonBeginning* = 131; msoShapeActionButtonEnd* = 132; msoShapeActionButtonReturn* = 133; msoShapeActionButtonDocument* = 134; msoShapeActionButtonSound* = 135; msoShapeActionButtonMovie* = 136; msoShapeBalloon* = 137; msoShapeNotPrimitive* = 138; (* MsoShapeType *) msoShapeTypeMixed* = -2; msoAutoShape* = 1; msoCallout* = 2; msoChart* = 3; msoComment* = 4; msoFreeform* = 5; msoGroup* = 6; msoEmbeddedOLEObject* = 7; msoFormControl* = 8; msoLine* = 9; msoLinkedOLEObject* = 10; msoLinkedPicture* = 11; msoOLEControlObject* = 12; msoPicture* = 13; msoPlaceholder* = 14; msoTextEffect* = 15; msoMedia* = 16; msoTextBox* = 17; msoScriptAnchor* = 18; msoTable* = 19; (* MsoFlipCmd *) msoFlipHorizontal* = 0; msoFlipVertical* = 1; (* MsoTriState *) msoTrue* = -1; msoFalse* = 0; msoCTrue* = 1; msoTriStateToggle* = -3; msoTriStateMixed* = -2; (* MsoColorType *) msoColorTypeMixed* = -2; msoColorTypeRGB* = 1; msoColorTypeScheme* = 2; (* MsoPictureColorType *) msoPictureMixed* = -2; msoPictureAutomatic* = 1; msoPictureGrayscale* = 2; msoPictureBlackAndWhite* = 3; msoPictureWatermark* = 4; (* MsoCalloutAngleType *) msoCalloutAngleMixed* = -2; msoCalloutAngleAutomatic* = 1; msoCalloutAngle30* = 2; msoCalloutAngle45* = 3; msoCalloutAngle60* = 4; msoCalloutAngle90* = 5; (* MsoCalloutDropType *) msoCalloutDropMixed* = -2; msoCalloutDropCustom* = 1; msoCalloutDropTop* = 2; msoCalloutDropCenter* = 3; msoCalloutDropBottom* = 4; (* MsoCalloutType *) msoCalloutMixed* = -2; msoCalloutOne* = 1; msoCalloutTwo* = 2; msoCalloutThree* = 3; msoCalloutFour* = 4; (* MsoBlackWhiteMode *) msoBlackWhiteMixed* = -2; msoBlackWhiteAutomatic* = 1; msoBlackWhiteGrayScale* = 2; msoBlackWhiteLightGrayScale* = 3; msoBlackWhiteInverseGrayScale* = 4; msoBlackWhiteGrayOutline* = 5; msoBlackWhiteBlackTextAndLine* = 6; msoBlackWhiteHighContrast* = 7; msoBlackWhiteBlack* = 8; msoBlackWhiteWhite* = 9; msoBlackWhiteDontShow* = 10; (* MsoMixedType *) msoIntegerMixed* = 32768; msoSingleMixed* = 80000000H; (* MsoTextOrientation *) msoTextOrientationMixed* = -2; msoTextOrientationHorizontal* = 1; msoTextOrientationUpward* = 2; msoTextOrientationDownward* = 3; msoTextOrientationVerticalFarEast* = 4; msoTextOrientationVertical* = 5; msoTextOrientationHorizontalRotatedFarEast* = 6; (* MsoScaleFrom *) msoScaleFromTopLeft* = 0; msoScaleFromMiddle* = 1; msoScaleFromBottomRight* = 2; (* MsoBarPosition *) msoBarLeft* = 0; msoBarTop* = 1; msoBarRight* = 2; msoBarBottom* = 3; msoBarFloating* = 4; msoBarPopup* = 5; msoBarMenuBar* = 6; (* MsoBarProtection *) msoBarNoProtection* = 0; msoBarNoCustomize* = 1; msoBarNoResize* = 2; msoBarNoMove* = 4; msoBarNoChangeVisible* = 8; msoBarNoChangeDock* = 16; msoBarNoVerticalDock* = 32; msoBarNoHorizontalDock* = 64; (* MsoBarType *) msoBarTypeNormal* = 0; msoBarTypeMenuBar* = 1; msoBarTypePopup* = 2; (* MsoControlType *) msoControlCustom* = 0; msoControlButton* = 1; msoControlEdit* = 2; msoControlDropdown* = 3; msoControlComboBox* = 4; msoControlButtonDropdown* = 5; msoControlSplitDropdown* = 6; msoControlOCXDropdown* = 7; msoControlGenericDropdown* = 8; msoControlGraphicDropdown* = 9; msoControlPopup* = 10; msoControlGraphicPopup* = 11; msoControlButtonPopup* = 12; msoControlSplitButtonPopup* = 13; msoControlSplitButtonMRUPopup* = 14; msoControlLabel* = 15; msoControlExpandingGrid* = 16; msoControlSplitExpandingGrid* = 17; msoControlGrid* = 18; msoControlGauge* = 19; msoControlGraphicCombo* = 20; msoControlPane* = 21; msoControlActiveX* = 22; (* MsoButtonState *) msoButtonUp* = 0; msoButtonDown* = -1; msoButtonMixed* = 2; (* MsoControlOLEUsage *) msoControlOLEUsageNeither* = 0; msoControlOLEUsageServer* = 1; msoControlOLEUsageClient* = 2; msoControlOLEUsageBoth* = 3; (* MsoButtonStyleHidden, hidden *) msoButtonWrapText* = 4; msoButtonTextBelow* = 8; (* MsoButtonStyle *) msoButtonAutomatic* = 0; msoButtonIcon* = 1; msoButtonCaption* = 2; msoButtonIconAndCaption* = 3; msoButtonIconAndWrapCaption* = 7; msoButtonIconAndCaptionBelow* = 11; msoButtonWrapCaption* = 14; msoButtonIconAndWrapCaptionBelow* = 15; (* MsoComboStyle *) msoComboNormal* = 0; msoComboLabel* = 1; (* MsoOLEMenuGroup *) msoOLEMenuGroupNone* = -1; msoOLEMenuGroupFile* = 0; msoOLEMenuGroupEdit* = 1; msoOLEMenuGroupContainer* = 2; msoOLEMenuGroupObject* = 3; msoOLEMenuGroupWindow* = 4; msoOLEMenuGroupHelp* = 5; (* MsoMenuAnimation *) msoMenuAnimationNone* = 0; msoMenuAnimationRandom* = 1; msoMenuAnimationUnfold* = 2; msoMenuAnimationSlide* = 3; (* MsoBarRow *) msoBarRowFirst* = 0; msoBarRowLast* = -1; (* MsoCommandBarButtonHyperlinkType *) msoCommandBarButtonHyperlinkNone* = 0; msoCommandBarButtonHyperlinkOpen* = 1; msoCommandBarButtonHyperlinkInsertPicture* = 2; (* MsoHyperlinkType *) msoHyperlinkRange* = 0; msoHyperlinkShape* = 1; msoHyperlinkInlineShape* = 2; (* MsoExtraInfoMethod *) msoMethodGet* = 0; msoMethodPost* = 1; (* MsoAnimationType *) msoAnimationIdle* = 1; msoAnimationGreeting* = 2; msoAnimationGoodbye* = 3; msoAnimationBeginSpeaking* = 4; msoAnimationRestPose* = 5; msoAnimationCharacterSuccessMajor* = 6; msoAnimationGetAttentionMajor* = 11; msoAnimationGetAttentionMinor* = 12; msoAnimationSearching* = 13; msoAnimationPrinting* = 18; msoAnimationGestureRight* = 19; msoAnimationWritingNotingSomething* = 22; msoAnimationWorkingAtSomething* = 23; msoAnimationThinking* = 24; msoAnimationSendingMail* = 25; msoAnimationListensToComputer* = 26; msoAnimationDisappear* = 31; msoAnimationAppear* = 32; msoAnimationGetArtsy* = 100; msoAnimationGetTechy* = 101; msoAnimationGetWizardy* = 102; msoAnimationCheckingSomething* = 103; msoAnimationLookDown* = 104; msoAnimationLookDownLeft* = 105; msoAnimationLookDownRight* = 106; msoAnimationLookLeft* = 107; msoAnimationLookRight* = 108; msoAnimationLookUp* = 109; msoAnimationLookUpLeft* = 110; msoAnimationLookUpRight* = 111; msoAnimationSaving* = 112; msoAnimationGestureDown* = 113; msoAnimationGestureLeft* = 114; msoAnimationGestureUp* = 115; msoAnimationEmptyTrash* = 116; (* MsoButtonSetType *) msoButtonSetNone* = 0; msoButtonSetOK* = 1; msoButtonSetCancel* = 2; msoButtonSetOkCancel* = 3; msoButtonSetYesNo* = 4; msoButtonSetYesNoCancel* = 5; msoButtonSetBackClose* = 6; msoButtonSetNextClose* = 7; msoButtonSetBackNextClose* = 8; msoButtonSetRetryCancel* = 9; msoButtonSetAbortRetryIgnore* = 10; msoButtonSetSearchClose* = 11; msoButtonSetBackNextSnooze* = 12; msoButtonSetTipsOptionsClose* = 13; msoButtonSetYesAllNoCancel* = 14; (* MsoIconType *) msoIconNone* = 0; msoIconAlert* = 2; msoIconTip* = 3; msoIconAlertInfo* = 4; msoIconAlertWarning* = 5; msoIconAlertQuery* = 6; msoIconAlertCritical* = 7; (* MsoBalloonType *) msoBalloonTypeButtons* = 0; msoBalloonTypeBullets* = 1; msoBalloonTypeNumbers* = 2; (* MsoModeType *) msoModeModal* = 0; msoModeAutoDown* = 1; msoModeModeless* = 2; (* MsoBalloonErrorType *) msoBalloonErrorNone* = 0; msoBalloonErrorOther* = 1; msoBalloonErrorTooBig* = 2; msoBalloonErrorOutOfMemory* = 3; msoBalloonErrorBadPictureRef* = 4; msoBalloonErrorBadReference* = 5; msoBalloonErrorButtonlessModal* = 6; msoBalloonErrorButtonModeless* = 7; msoBalloonErrorBadCharacter* = 8; msoBalloonErrorCOMFailure* = 9; msoBalloonErrorCharNotTopmostForModal* = 10; msoBalloonErrorTooManyControls* = 11; (* MsoWizardActType *) msoWizardActInactive* = 0; msoWizardActActive* = 1; msoWizardActSuspend* = 2; msoWizardActResume* = 3; (* MsoWizardMsgType *) msoWizardMsgLocalStateOn* = 1; msoWizardMsgLocalStateOff* = 2; msoWizardMsgShowHelp* = 3; msoWizardMsgSuspending* = 4; msoWizardMsgResuming* = 5; (* MsoBalloonButtonType *) msoBalloonButtonYesToAll* = -15; msoBalloonButtonOptions* = -14; msoBalloonButtonTips* = -13; msoBalloonButtonClose* = -12; msoBalloonButtonSnooze* = -11; msoBalloonButtonSearch* = -10; msoBalloonButtonIgnore* = -9; msoBalloonButtonAbort* = -8; msoBalloonButtonRetry* = -7; msoBalloonButtonNext* = -6; msoBalloonButtonBack* = -5; msoBalloonButtonNo* = -4; msoBalloonButtonYes* = -3; msoBalloonButtonCancel* = -2; msoBalloonButtonOK* = -1; msoBalloonButtonNull* = 0; (* DocProperties, hidden *) offPropertyTypeNumber* = 1; offPropertyTypeBoolean* = 2; offPropertyTypeDate* = 3; offPropertyTypeString* = 4; offPropertyTypeFloat* = 5; (* MsoDocProperties *) msoPropertyTypeNumber* = 1; msoPropertyTypeBoolean* = 2; msoPropertyTypeDate* = 3; msoPropertyTypeString* = 4; msoPropertyTypeFloat* = 5; (* MsoAppLanguageID *) msoLanguageIDInstall* = 1; msoLanguageIDUI* = 2; msoLanguageIDHelp* = 3; msoLanguageIDExeMode* = 4; msoLanguageIDUIPrevious* = 5; (* MsoFarEastLineBreakLanguageID *) MsoFarEastLineBreakLanguageJapanese* = 1041; MsoFarEastLineBreakLanguageKorean* = 1042; MsoFarEastLineBreakLanguageSimplifiedChinese* = 2052; MsoFarEastLineBreakLanguageTraditionalChinese* = 1028; (* MsoFeatureInstall *) msoFeatureInstallNone* = 0; msoFeatureInstallOnDemand* = 1; msoFeatureInstallOnDemandWithUI* = 2; (* MsoScriptLanguage *) msoScriptLanguageJava* = 1; msoScriptLanguageVisualBasic* = 2; msoScriptLanguageASP* = 3; msoScriptLanguageOther* = 4; (* MsoScriptLocation *) msoScriptLocationInHead* = 1; msoScriptLocationInBody* = 2; (* MsoFileFindOptions *) msoOptionsNew* = 1; msoOptionsAdd* = 2; msoOptionsWithin* = 3; (* MsoFileFindView *) msoViewFileInfo* = 1; msoViewPreview* = 2; msoViewSummaryInfo* = 3; (* MsoFileFindSortBy *) msoFileFindSortbyAuthor* = 1; msoFileFindSortbyDateCreated* = 2; msoFileFindSortbyLastSavedBy* = 3; msoFileFindSortbyDateSaved* = 4; msoFileFindSortbyFileName* = 5; msoFileFindSortbySize* = 6; msoFileFindSortbyTitle* = 7; (* MsoFileFindListBy *) msoListbyName* = 1; msoListbyTitle* = 2; (* MsoLastModified *) msoLastModifiedYesterday* = 1; msoLastModifiedToday* = 2; msoLastModifiedLastWeek* = 3; msoLastModifiedThisWeek* = 4; msoLastModifiedLastMonth* = 5; msoLastModifiedThisMonth* = 6; msoLastModifiedAnyTime* = 7; (* MsoSortBy *) msoSortByFileName* = 1; msoSortBySize* = 2; msoSortByFileType* = 3; msoSortByLastModified* = 4; (* MsoSortOrder *) msoSortOrderAscending* = 1; msoSortOrderDescending* = 2; (* MsoConnector *) msoConnectorAnd* = 1; msoConnectorOr* = 2; (* MsoCondition *) msoConditionFileTypeAllFiles* = 1; msoConditionFileTypeOfficeFiles* = 2; msoConditionFileTypeWordDocuments* = 3; msoConditionFileTypeExcelWorkbooks* = 4; msoConditionFileTypePowerPointPresentations* = 5; msoConditionFileTypeBinders* = 6; msoConditionFileTypeDatabases* = 7; msoConditionFileTypeTemplates* = 8; msoConditionIncludes* = 9; msoConditionIncludesPhrase* = 10; msoConditionBeginsWith* = 11; msoConditionEndsWith* = 12; msoConditionIncludesNearEachOther* = 13; msoConditionIsExactly* = 14; msoConditionIsNot* = 15; msoConditionYesterday* = 16; msoConditionToday* = 17; msoConditionTomorrow* = 18; msoConditionLastWeek* = 19; msoConditionThisWeek* = 20; msoConditionNextWeek* = 21; msoConditionLastMonth* = 22; msoConditionThisMonth* = 23; msoConditionNextMonth* = 24; msoConditionAnytime* = 25; msoConditionAnytimeBetween* = 26; msoConditionOn* = 27; msoConditionOnOrAfter* = 28; msoConditionOnOrBefore* = 29; msoConditionInTheNext* = 30; msoConditionInTheLast* = 31; msoConditionEquals* = 32; msoConditionDoesNotEqual* = 33; msoConditionAnyNumberBetween* = 34; msoConditionAtMost* = 35; msoConditionAtLeast* = 36; msoConditionMoreThan* = 37; msoConditionLessThan* = 38; msoConditionIsYes* = 39; msoConditionIsNo* = 40; (* MsoFileType *) msoFileTypeAllFiles* = 1; msoFileTypeOfficeFiles* = 2; msoFileTypeWordDocuments* = 3; msoFileTypeExcelWorkbooks* = 4; msoFileTypePowerPointPresentations* = 5; msoFileTypeBinders* = 6; msoFileTypeDatabases* = 7; msoFileTypeTemplates* = 8; (* MsoLanguageID *) msoLanguageIDMixed* = -2; msoLanguageIDNone* = 0; msoLanguageIDNoProofing* = 1024; msoLanguageIDAfrikaans* = 1078; msoLanguageIDAlbanian* = 1052; msoLanguageIDArabicAlgeria* = 5121; msoLanguageIDArabicBahrain* = 15361; msoLanguageIDArabicEgypt* = 3073; msoLanguageIDArabicIraq* = 2049; msoLanguageIDArabicJordan* = 11265; msoLanguageIDArabicKuwait* = 13313; msoLanguageIDArabicLebanon* = 12289; msoLanguageIDArabicLibya* = 4097; msoLanguageIDArabicMorocco* = 6145; msoLanguageIDArabicOman* = 8193; msoLanguageIDArabicQatar* = 16385; msoLanguageIDArabic* = 1025; msoLanguageIDArabicSyria* = 10241; msoLanguageIDArabicTunisia* = 7169; msoLanguageIDArabicUAE* = 14337; msoLanguageIDArabicYemen* = 9217; msoLanguageIDArmenian* = 1067; msoLanguageIDAssamese* = 1101; msoLanguageIDAzeriCyrillic* = 2092; msoLanguageIDAzeriLatin* = 1068; msoLanguageIDBasque* = 1069; msoLanguageIDByelorussian* = 1059; msoLanguageIDBengali* = 1093; msoLanguageIDBulgarian* = 1026; msoLanguageIDBurmese* = 1109; msoLanguageIDCatalan* = 1027; msoLanguageIDChineseHongKong* = 3076; msoLanguageIDChineseMacao* = 5124; msoLanguageIDSimplifiedChinese* = 2052; msoLanguageIDChineseSingapore* = 4100; msoLanguageIDTraditionalChinese* = 1028; msoLanguageIDCroatian* = 1050; msoLanguageIDCzech* = 1029; msoLanguageIDDanish* = 1030; msoLanguageIDBelgianDutch* = 2067; msoLanguageIDDutch* = 1043; msoLanguageIDEnglishAUS* = 3081; msoLanguageIDEnglishBelize* = 10249; msoLanguageIDEnglishCanadian* = 4105; msoLanguageIDEnglishCaribbean* = 9225; msoLanguageIDEnglishIreland* = 6153; msoLanguageIDEnglishJamaica* = 8201; msoLanguageIDEnglishNewZealand* = 5129; msoLanguageIDEnglishPhilippines* = 13321; msoLanguageIDEnglishSouthAfrica* = 7177; msoLanguageIDEnglishTrinidad* = 11273; msoLanguageIDEnglishUK* = 2057; msoLanguageIDEnglishUS* = 1033; msoLanguageIDEnglishZimbabwe* = 12297; msoLanguageIDEstonian* = 1061; msoLanguageIDFaeroese* = 1080; msoLanguageIDFarsi* = 1065; msoLanguageIDFinnish* = 1035; msoLanguageIDBelgianFrench* = 2060; msoLanguageIDFrenchCameroon* = 11276; msoLanguageIDFrenchCanadian* = 3084; msoLanguageIDFrenchCotedIvoire* = 12300; msoLanguageIDFrench* = 1036; msoLanguageIDFrenchLuxembourg* = 5132; msoLanguageIDFrenchMali* = 13324; msoLanguageIDFrenchMonaco* = 6156; msoLanguageIDFrenchReunion* = 8204; msoLanguageIDFrenchSenegal* = 10252; msoLanguageIDSwissFrench* = 4108; msoLanguageIDFrenchWestIndies* = 7180; msoLanguageIDFrenchZaire* = 9228; msoLanguageIDFrisianNetherlands* = 1122; msoLanguageIDGaelicIreland* = 2108; msoLanguageIDGaelicScotland* = 1084; msoLanguageIDGalician* = 1110; msoLanguageIDGeorgian* = 1079; msoLanguageIDGermanAustria* = 3079; msoLanguageIDGerman* = 1031; msoLanguageIDGermanLiechtenstein* = 5127; msoLanguageIDGermanLuxembourg* = 4103; msoLanguageIDSwissGerman* = 2055; msoLanguageIDGreek* = 1032; msoLanguageIDGujarati* = 1095; msoLanguageIDHebrew* = 1037; msoLanguageIDHindi* = 1081; msoLanguageIDHungarian* = 1038; msoLanguageIDIcelandic* = 1039; msoLanguageIDIndonesian* = 1057; msoLanguageIDItalian* = 1040; msoLanguageIDSwissItalian* = 2064; msoLanguageIDJapanese* = 1041; msoLanguageIDKannada* = 1099; msoLanguageIDKashmiri* = 1120; msoLanguageIDKazakh* = 1087; msoLanguageIDKhmer* = 1107; msoLanguageIDKirghiz* = 1088; msoLanguageIDKonkani* = 1111; msoLanguageIDKorean* = 1042; msoLanguageIDLao* = 1108; msoLanguageIDLatvian* = 1062; msoLanguageIDLithuanian* = 1063; msoLanguageIDMacedonian* = 1071; msoLanguageIDMalaysian* = 1086; msoLanguageIDMalayBruneiDarussalam* = 2110; msoLanguageIDMalayalam* = 1100; msoLanguageIDMaltese* = 1082; msoLanguageIDManipuri* = 1112; msoLanguageIDMarathi* = 1102; msoLanguageIDMongolian* = 1104; msoLanguageIDNepali* = 1121; msoLanguageIDNorwegianBokmol* = 1044; msoLanguageIDNorwegianNynorsk* = 2068; msoLanguageIDOriya* = 1096; msoLanguageIDPolish* = 1045; msoLanguageIDBrazilianPortuguese* = 1046; msoLanguageIDPortuguese* = 2070; msoLanguageIDPunjabi* = 1094; msoLanguageIDRhaetoRomanic* = 1047; msoLanguageIDRomanianMoldova* = 2072; msoLanguageIDRomanian* = 1048; msoLanguageIDRussianMoldova* = 2073; msoLanguageIDRussian* = 1049; msoLanguageIDSamiLappish* = 1083; msoLanguageIDSanskrit* = 1103; msoLanguageIDSerbianCyrillic* = 3098; msoLanguageIDSerbianLatin* = 2074; msoLanguageIDSesotho* = 1072; msoLanguageIDSindhi* = 1113; msoLanguageIDSlovak* = 1051; msoLanguageIDSlovenian* = 1060; msoLanguageIDSorbian* = 1070; msoLanguageIDSpanishArgentina* = 11274; msoLanguageIDSpanishBolivia* = 16394; msoLanguageIDSpanishChile* = 13322; msoLanguageIDSpanishColombia* = 9226; msoLanguageIDSpanishCostaRica* = 5130; msoLanguageIDSpanishDominicanRepublic* = 7178; msoLanguageIDSpanishEcuador* = 12298; msoLanguageIDSpanishElSalvador* = 17418; msoLanguageIDSpanishGuatemala* = 4106; msoLanguageIDSpanishHonduras* = 18442; msoLanguageIDMexicanSpanish* = 2058; msoLanguageIDSpanishNicaragua* = 19466; msoLanguageIDSpanishPanama* = 6154; msoLanguageIDSpanishParaguay* = 15370; msoLanguageIDSpanishPeru* = 10250; msoLanguageIDSpanishPuertoRico* = 20490; msoLanguageIDSpanishModernSort* = 3082; msoLanguageIDSpanish* = 1034; msoLanguageIDSpanishUruguay* = 14346; msoLanguageIDSpanishVenezuela* = 8202; msoLanguageIDSutu* = 1072; msoLanguageIDSwahili* = 1089; msoLanguageIDSwedishFinland* = 2077; msoLanguageIDSwedish* = 1053; msoLanguageIDTajik* = 1064; msoLanguageIDTamil* = 1097; msoLanguageIDTatar* = 1092; msoLanguageIDTelugu* = 1098; msoLanguageIDThai* = 1054; msoLanguageIDTibetan* = 1105; msoLanguageIDTsonga* = 1073; msoLanguageIDTswana* = 1074; msoLanguageIDTurkish* = 1055; msoLanguageIDTurkmen* = 1090; msoLanguageIDUkrainian* = 1058; msoLanguageIDUrdu* = 1056; msoLanguageIDUzbekCyrillic* = 2115; msoLanguageIDUzbekLatin* = 1091; msoLanguageIDVenda* = 1075; msoLanguageIDVietnamese* = 1066; msoLanguageIDWelsh* = 1106; msoLanguageIDXhosa* = 1076; msoLanguageIDZulu* = 1077; (* MsoScreenSize *) msoScreenSize544x376* = 0; msoScreenSize640x480* = 1; msoScreenSize720x512* = 2; msoScreenSize800x600* = 3; msoScreenSize1024x768* = 4; msoScreenSize1152x882* = 5; msoScreenSize1152x900* = 6; msoScreenSize1280x1024* = 7; msoScreenSize1600x1200* = 8; msoScreenSize1800x1440* = 9; msoScreenSize1920x1200* = 10; (* MsoCharacterSet *) msoCharacterSetArabic* = 1; msoCharacterSetCyrillic* = 2; msoCharacterSetEnglishWesternEuropeanOtherLatinScript* = 3; msoCharacterSetGreek* = 4; msoCharacterSetHebrew* = 5; msoCharacterSetJapanese* = 6; msoCharacterSetKorean* = 7; msoCharacterSetMultilingualUnicode* = 8; msoCharacterSetSimplifiedChinese* = 9; msoCharacterSetThai* = 10; msoCharacterSetTraditionalChinese* = 11; msoCharacterSetVietnamese* = 12; (* MsoEncoding *) msoEncodingThai* = 874; msoEncodingJapaneseShiftJIS* = 932; msoEncodingSimplifiedChineseGBK* = 936; msoEncodingKorean* = 949; msoEncodingTraditionalChineseBig5* = 950; msoEncodingUnicodeLittleEndian* = 1200; msoEncodingUnicodeBigEndian* = 1201; msoEncodingCentralEuropean* = 1250; msoEncodingCyrillic* = 1251; msoEncodingWestern* = 1252; msoEncodingGreek* = 1253; msoEncodingTurkish* = 1254; msoEncodingHebrew* = 1255; msoEncodingArabic* = 1256; msoEncodingBaltic* = 1257; msoEncodingVietnamese* = 1258; msoEncodingAutoDetect* = 50001; msoEncodingJapaneseAutoDetect* = 50932; msoEncodingSimplifiedChineseAutoDetect* = 50936; msoEncodingKoreanAutoDetect* = 50949; msoEncodingTraditionalChineseAutoDetect* = 50950; msoEncodingCyrillicAutoDetect* = 51251; msoEncodingGreekAutoDetect* = 51253; msoEncodingArabicAutoDetect* = 51256; msoEncodingISO88591Latin1* = 28591; msoEncodingISO88592CentralEurope* = 28592; msoEncodingISO88593Latin3* = 28593; msoEncodingISO88594Baltic* = 28594; msoEncodingISO88595Cyrillic* = 28595; msoEncodingISO88596Arabic* = 28596; msoEncodingISO88597Greek* = 28597; msoEncodingISO88598Hebrew* = 28598; msoEncodingISO88599Turkish* = 28599; msoEncodingISO885915Latin9* = 28605; msoEncodingISO2022JPNoHalfwidthKatakana* = 50220; msoEncodingISO2022JPJISX02021984* = 50221; msoEncodingISO2022JPJISX02011989* = 50222; msoEncodingISO2022KR* = 50225; msoEncodingISO2022CNTraditionalChinese* = 50227; msoEncodingISO2022CNSimplifiedChinese* = 50229; msoEncodingMacRoman* = 10000; msoEncodingMacJapanese* = 10001; msoEncodingMacTraditionalChineseBig5* = 10002; msoEncodingMacKorean* = 10003; msoEncodingMacArabic* = 10004; msoEncodingMacHebrew* = 10005; msoEncodingMacGreek1* = 10006; msoEncodingMacCyrillic* = 10007; msoEncodingMacSimplifiedChineseGB2312* = 10008; msoEncodingMacRomania* = 10010; msoEncodingMacUkraine* = 10017; msoEncodingMacLatin2* = 10029; msoEncodingMacIcelandic* = 10079; msoEncodingMacTurkish* = 10081; msoEncodingMacCroatia* = 10082; msoEncodingEBCDICUSCanada* = 37; msoEncodingEBCDICInternational* = 500; msoEncodingEBCDICMultilingualROECELatin2* = 870; msoEncodingEBCDICGreekModern* = 875; msoEncodingEBCDICTurkishLatin5* = 1026; msoEncodingEBCDICGermany* = 20273; msoEncodingEBCDICDenmarkNorway* = 20277; msoEncodingEBCDICFinlandSweden* = 20278; msoEncodingEBCDICItaly* = 20280; msoEncodingEBCDICLatinAmericaSpain* = 20284; msoEncodingEBCDICUnitedKingdom* = 20285; msoEncodingEBCDICJapaneseKatakanaExtended* = 20290; msoEncodingEBCDICFrance* = 20297; msoEncodingEBCDICArabic* = 20420; msoEncodingEBCDICGreek* = 20423; msoEncodingEBCDICHebrew* = 20424; msoEncodingEBCDICKoreanExtended* = 20833; msoEncodingEBCDICThai* = 20838; msoEncodingEBCDICIcelandic* = 20871; msoEncodingEBCDICTurkish* = 20905; msoEncodingEBCDICRussian* = 20880; msoEncodingEBCDICSerbianBulgarian* = 21025; msoEncodingEBCDICJapaneseKatakanaExtendedAndJapanese* = 50930; msoEncodingEBCDICUSCanadaandJapanese* = 50931; msoEncodingEBCDICKoreanExtendedAndKorean* = 50933; msoEncodingEBCDICSimplifiedChineseExtendedAndSimplifiedChinese* = 50935; msoEncodingEBCDICUSCanadaAndTraditionalChinese* = 50937; msoEncodingEBCDICJapaneseLatinExtendedAndJapanese* = 50939; msoEncodingOEMUnitedStates* = 437; msoEncodingOEMGreek437G* = 737; msoEncodingOEMBaltic* = 775; msoEncodingOEMMultilingualLatinI* = 850; msoEncodingOEMMultilingualLatinII* = 852; msoEncodingOEMCyrillic* = 855; msoEncodingOEMTurkish* = 857; msoEncodingOEMPortuguese* = 860; msoEncodingOEMIcelandic* = 861; msoEncodingOEMHebrew* = 862; msoEncodingOEMCanadianFrench* = 863; msoEncodingOEMArabic* = 864; msoEncodingOEMNordic* = 865; msoEncodingOEMCyrillicII* = 866; msoEncodingOEMModernGreek* = 869; msoEncodingEUCJapanese* = 51932; msoEncodingEUCChineseSimplifiedChinese* = 51936; msoEncodingEUCKorean* = 51949; msoEncodingEUCTaiwaneseTraditionalChinese* = 51950; msoEncodingArabicASMO* = 708; msoEncodingArabicTransparentASMO* = 720; msoEncodingKoreanJohab* = 1361; msoEncodingTaiwanCNS* = 20000; msoEncodingTaiwanTCA* = 20001; msoEncodingTaiwanEten* = 20002; msoEncodingTaiwanIBM5550* = 20003; msoEncodingTaiwanTeleText* = 20004; msoEncodingTaiwanWang* = 20005; msoEncodingIA5IRV* = 20105; msoEncodingIA5German* = 20106; msoEncodingIA5Swedish* = 20107; msoEncodingIA5Norwegian* = 20108; msoEncodingUSASCII* = 20127; msoEncodingT61* = 20261; msoEncodingISO6937NonSpacingAccent* = 20269; msoEncodingKOI8R* = 20866; msoEncodingExtAlphaLowercase* = 21027; msoEncodingKOI8U* = 21866; msoEncodingEuropa3* = 29001; msoEncodingHZGBSimplifiedChinese* = 52936; msoEncodingUTF7* = 65000; msoEncodingUTF8* = 65001; (* MsoHTMLProjectOpen *) msoHTMLProjectOpenSourceView* = 1; msoHTMLProjectOpenTextView* = 2; (* MsoHTMLProjectState *) msoHTMLProjectStateDocumentLocked* = 1; msoHTMLProjectStateProjectLocked* = 2; msoHTMLProjectStateDocumentProjectUnlocked* = 3; TYPE MsoLineDashStyle* = INTEGER; MsoLineStyle* = INTEGER; MsoArrowheadStyle* = INTEGER; MsoArrowheadWidth* = INTEGER; MsoArrowheadLength* = INTEGER; MsoFillType* = INTEGER; MsoGradientStyle* = INTEGER; MsoGradientColorType* = INTEGER; MsoTextureType* = INTEGER; MsoPresetTexture* = INTEGER; MsoPatternType* = INTEGER; MsoPresetGradientType* = INTEGER; MsoShadowType* = INTEGER; MsoPresetTextEffect* = INTEGER; MsoPresetTextEffectShape* = INTEGER; MsoTextEffectAlignment* = INTEGER; MsoPresetLightingDirection* = INTEGER; MsoPresetLightingSoftness* = INTEGER; MsoPresetMaterial* = INTEGER; MsoPresetExtrusionDirection* = INTEGER; MsoPresetThreeDFormat* = INTEGER; MsoExtrusionColorType* = INTEGER; MsoAlignCmd* = INTEGER; MsoDistributeCmd* = INTEGER; MsoConnectorType* = INTEGER; MsoHorizontalAnchor* = INTEGER; MsoVerticalAnchor* = INTEGER; MsoOrientation* = INTEGER; MsoZOrderCmd* = INTEGER; MsoSegmentType* = INTEGER; MsoEditingType* = INTEGER; MsoAutoShapeType* = INTEGER; MsoShapeType* = INTEGER; MsoFlipCmd* = INTEGER; MsoTriState* = INTEGER; MsoColorType* = INTEGER; MsoPictureColorType* = INTEGER; MsoCalloutAngleType* = INTEGER; MsoCalloutDropType* = INTEGER; MsoCalloutType* = INTEGER; MsoBlackWhiteMode* = INTEGER; MsoMixedType* = INTEGER; MsoTextOrientation* = INTEGER; MsoScaleFrom* = INTEGER; MsoRGBType* = INTEGER; MsoBarPosition* = INTEGER; MsoBarProtection* = INTEGER; MsoBarType* = INTEGER; MsoControlType* = INTEGER; MsoButtonState* = INTEGER; MsoControlOLEUsage* = INTEGER; MsoButtonStyleHidden* = INTEGER; MsoButtonStyle* = INTEGER; MsoComboStyle* = INTEGER; MsoOLEMenuGroup* = INTEGER; MsoMenuAnimation* = INTEGER; MsoBarRow* = INTEGER; MsoCommandBarButtonHyperlinkType* = INTEGER; MsoHyperlinkType* = INTEGER; MsoExtraInfoMethod* = INTEGER; MsoAnimationType* = INTEGER; MsoButtonSetType* = INTEGER; MsoIconType* = INTEGER; MsoBalloonType* = INTEGER; MsoModeType* = INTEGER; MsoBalloonErrorType* = INTEGER; MsoWizardActType* = INTEGER; MsoWizardMsgType* = INTEGER; MsoBalloonButtonType* = INTEGER; DocProperties* = INTEGER; MsoDocProperties* = INTEGER; MsoAppLanguageID* = INTEGER; MsoFarEastLineBreakLanguageID* = INTEGER; MsoFeatureInstall* = INTEGER; IAccessible* = POINTER TO RECORD (CtlT.Object) END; _IMsoDispObj* = POINTER TO RECORD (CtlT.Object) END; _IMsoOleAccDispObj* = POINTER TO RECORD (CtlT.Object) END; _CommandBars* = POINTER TO RECORD (CtlT.Object) END; CommandBar* = POINTER TO RECORD (CtlT.Object) END; CommandBarControls* = POINTER TO RECORD (CtlT.Object) END; CommandBarControl* = POINTER TO RECORD (CtlT.Object) END; _CommandBarButton* = POINTER TO RECORD (CtlT.Object) END; CommandBarPopup* = POINTER TO RECORD (CtlT.Object) END; _CommandBarComboBox* = POINTER TO RECORD (CtlT.Object) END; _CommandBarActiveX* = POINTER TO RECORD (CtlT.Object) END; Adjustments* = POINTER TO RECORD (CtlT.Object) END; CalloutFormat* = POINTER TO RECORD (CtlT.Object) END; ColorFormat* = POINTER TO RECORD (CtlT.Object) END; ConnectorFormat* = POINTER TO RECORD (CtlT.Object) END; FillFormat* = POINTER TO RECORD (CtlT.Object) END; FreeformBuilder* = POINTER TO RECORD (CtlT.Object) END; GroupShapes* = POINTER TO RECORD (CtlT.Object) END; LineFormat* = POINTER TO RECORD (CtlT.Object) END; ShapeNode* = POINTER TO RECORD (CtlT.Object) END; ShapeNodes* = POINTER TO RECORD (CtlT.Object) END; PictureFormat* = POINTER TO RECORD (CtlT.Object) END; ShadowFormat* = POINTER TO RECORD (CtlT.Object) END; MsoScriptLanguage* = INTEGER; MsoScriptLocation* = INTEGER; Script* = POINTER TO RECORD (CtlT.Object) END; Scripts* = POINTER TO RECORD (CtlT.Object) END; Shape* = POINTER TO RECORD (CtlT.Object) END; ShapeRange* = POINTER TO RECORD (CtlT.Object) END; Shapes* = POINTER TO RECORD (CtlT.Object) END; TextEffectFormat* = POINTER TO RECORD (CtlT.Object) END; TextFrame* = POINTER TO RECORD (CtlT.Object) END; ThreeDFormat* = POINTER TO RECORD (CtlT.Object) END; IMsoDispCagNotifySink* = POINTER TO RECORD (CtlT.Object) END; Balloon* = POINTER TO RECORD (CtlT.Object) END; BalloonCheckboxes* = POINTER TO RECORD (CtlT.Object) END; BalloonCheckbox* = POINTER TO RECORD (CtlT.Object) END; BalloonLabels* = POINTER TO RECORD (CtlT.Object) END; BalloonLabel* = POINTER TO RECORD (CtlT.Object) END; AnswerWizardFiles* = POINTER TO RECORD (CtlT.Object) END; AnswerWizard* = POINTER TO RECORD (CtlT.Object) END; Assistant* = POINTER TO RECORD (CtlT.Object) END; MsoFileFindOptions* = INTEGER; MsoFileFindView* = INTEGER; MsoFileFindSortBy* = INTEGER; MsoFileFindListBy* = INTEGER; IFoundFiles* = POINTER TO RECORD (CtlT.Object) END; IFind* = POINTER TO RECORD (CtlT.Object) END; MsoLastModified* = INTEGER; MsoSortBy* = INTEGER; MsoSortOrder* = INTEGER; MsoConnector* = INTEGER; MsoCondition* = INTEGER; MsoFileType* = INTEGER; FoundFiles* = POINTER TO RECORD (CtlT.Object) END; PropertyTest* = POINTER TO RECORD (CtlT.Object) END; PropertyTests* = POINTER TO RECORD (CtlT.Object) END; FileSearch* = POINTER TO RECORD (CtlT.Object) END; COMAddIn* = POINTER TO RECORD (CtlT.Object) END; COMAddIns* = POINTER TO RECORD (CtlT.Object) END; MsoLanguageID* = INTEGER; LanguageSettings* = POINTER TO RECORD (CtlT.Object) END; ICommandBarsEvents* = POINTER TO RECORD (CtlT.Object) END; _CommandBarsEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; CommandBars* = _CommandBars; ICommandBarComboBoxEvents* = POINTER TO RECORD (CtlT.Object) END; _CommandBarComboBoxEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; CommandBarComboBox* = _CommandBarComboBox; ICommandBarButtonEvents* = POINTER TO RECORD (CtlT.Object) END; _CommandBarButtonEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; CommandBarButton* = _CommandBarButton; MsoScreenSize* = INTEGER; MsoCharacterSet* = INTEGER; MsoEncoding* = INTEGER; WebPageFont* = POINTER TO RECORD (CtlT.Object) END; WebPageFonts* = POINTER TO RECORD (CtlT.Object) END; MsoHTMLProjectOpen* = INTEGER; MsoHTMLProjectState* = INTEGER; HTMLProjectItem* = POINTER TO RECORD (CtlT.Object) END; HTMLProjectItems* = POINTER TO RECORD (CtlT.Object) END; HTMLProject* = POINTER TO RECORD (CtlT.Object) END; MsoDebugOptions* = POINTER TO RECORD (CtlT.Object) END; PROCEDURE ThisIAccessible* (v: CtlT.Any): IAccessible; VAR new: IAccessible; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{618736E0-3C3D-11CF-810C-00AA00389B71}"); RETURN new ELSE RETURN NIL END END ThisIAccessible; PROCEDURE IsIAccessible* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{618736E0-3C3D-11CF-810C-00AA00389B71}") END IsIAccessible; PROCEDURE This_IMsoDispObj* (v: CtlT.Any): _IMsoDispObj; VAR new: _IMsoDispObj; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0300-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_IMsoDispObj; PROCEDURE Is_IMsoDispObj* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0300-0000-0000-C000-000000000046}") END Is_IMsoDispObj; PROCEDURE This_IMsoOleAccDispObj* (v: CtlT.Any): _IMsoOleAccDispObj; VAR new: _IMsoOleAccDispObj; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0301-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_IMsoOleAccDispObj; PROCEDURE Is_IMsoOleAccDispObj* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0301-0000-0000-C000-000000000046}") END Is_IMsoOleAccDispObj; PROCEDURE This_CommandBars* (v: CtlT.Any): _CommandBars; VAR new: _CommandBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0302-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CommandBars; PROCEDURE Is_CommandBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0302-0000-0000-C000-000000000046}") END Is_CommandBars; (* by hand *) PROCEDURE ThisCommandBars* (v: CtlT.Any): CommandBars; VAR new: CommandBars; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0302-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBars; (* by hand *) PROCEDURE IsCommandBars* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0302-0000-0000-C000-000000000046}") END IsCommandBars; PROCEDURE ThisCommandBar* (v: CtlT.Any): CommandBar; VAR new: CommandBar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0304-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBar; PROCEDURE IsCommandBar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0304-0000-0000-C000-000000000046}") END IsCommandBar; PROCEDURE ThisCommandBarControls* (v: CtlT.Any): CommandBarControls; VAR new: CommandBarControls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0306-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBarControls; PROCEDURE IsCommandBarControls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0306-0000-0000-C000-000000000046}") END IsCommandBarControls; PROCEDURE ThisCommandBarControl* (v: CtlT.Any): CommandBarControl; VAR new: CommandBarControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0308-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBarControl; PROCEDURE IsCommandBarControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0308-0000-0000-C000-000000000046}") END IsCommandBarControl; PROCEDURE This_CommandBarButton* (v: CtlT.Any): _CommandBarButton; VAR new: _CommandBarButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CommandBarButton; PROCEDURE Is_CommandBarButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030E-0000-0000-C000-000000000046}") END Is_CommandBarButton; (* by hand *) PROCEDURE ThisCommandBarButton* (v: CtlT.Any): CommandBarButton; VAR new: CommandBarButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBarButton; (* by hand *) PROCEDURE IsCommandBarButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030E-0000-0000-C000-000000000046}") END IsCommandBarButton; PROCEDURE ThisCommandBarPopup* (v: CtlT.Any): CommandBarPopup; VAR new: CommandBarPopup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBarPopup; PROCEDURE IsCommandBarPopup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030A-0000-0000-C000-000000000046}") END IsCommandBarPopup; PROCEDURE This_CommandBarComboBox* (v: CtlT.Any): _CommandBarComboBox; VAR new: _CommandBarComboBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CommandBarComboBox; PROCEDURE Is_CommandBarComboBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030C-0000-0000-C000-000000000046}") END Is_CommandBarComboBox; (* by hand *) PROCEDURE ThisCommandBarComboBox* (v: CtlT.Any): CommandBarComboBox; VAR new: CommandBarComboBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCommandBarComboBox; (* by hand *) PROCEDURE IsCommandBarComboBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030C-0000-0000-C000-000000000046}") END IsCommandBarComboBox; PROCEDURE This_CommandBarActiveX* (v: CtlT.Any): _CommandBarActiveX; VAR new: _CommandBarActiveX; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C030D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CommandBarActiveX; PROCEDURE Is_CommandBarActiveX* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C030D-0000-0000-C000-000000000046}") END Is_CommandBarActiveX; PROCEDURE ThisAdjustments* (v: CtlT.Any): Adjustments; VAR new: Adjustments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0310-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAdjustments; PROCEDURE IsAdjustments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0310-0000-0000-C000-000000000046}") END IsAdjustments; PROCEDURE ThisCalloutFormat* (v: CtlT.Any): CalloutFormat; VAR new: CalloutFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0311-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCalloutFormat; PROCEDURE IsCalloutFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0311-0000-0000-C000-000000000046}") END IsCalloutFormat; PROCEDURE ThisColorFormat* (v: CtlT.Any): ColorFormat; VAR new: ColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0312-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisColorFormat; PROCEDURE IsColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0312-0000-0000-C000-000000000046}") END IsColorFormat; PROCEDURE ThisConnectorFormat* (v: CtlT.Any): ConnectorFormat; VAR new: ConnectorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0313-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisConnectorFormat; PROCEDURE IsConnectorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0313-0000-0000-C000-000000000046}") END IsConnectorFormat; PROCEDURE ThisFillFormat* (v: CtlT.Any): FillFormat; VAR new: FillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0314-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFillFormat; PROCEDURE IsFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0314-0000-0000-C000-000000000046}") END IsFillFormat; PROCEDURE ThisFreeformBuilder* (v: CtlT.Any): FreeformBuilder; VAR new: FreeformBuilder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0315-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFreeformBuilder; PROCEDURE IsFreeformBuilder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0315-0000-0000-C000-000000000046}") END IsFreeformBuilder; PROCEDURE ThisGroupShapes* (v: CtlT.Any): GroupShapes; VAR new: GroupShapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0316-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupShapes; PROCEDURE IsGroupShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0316-0000-0000-C000-000000000046}") END IsGroupShapes; PROCEDURE ThisLineFormat* (v: CtlT.Any): LineFormat; VAR new: LineFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0317-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLineFormat; PROCEDURE IsLineFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0317-0000-0000-C000-000000000046}") END IsLineFormat; PROCEDURE ThisShapeNode* (v: CtlT.Any): ShapeNode; VAR new: ShapeNode; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0318-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNode; PROCEDURE IsShapeNode* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0318-0000-0000-C000-000000000046}") END IsShapeNode; PROCEDURE ThisShapeNodes* (v: CtlT.Any): ShapeNodes; VAR new: ShapeNodes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0319-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNodes; PROCEDURE IsShapeNodes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0319-0000-0000-C000-000000000046}") END IsShapeNodes; PROCEDURE ThisPictureFormat* (v: CtlT.Any): PictureFormat; VAR new: PictureFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPictureFormat; PROCEDURE IsPictureFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031A-0000-0000-C000-000000000046}") END IsPictureFormat; PROCEDURE ThisShadowFormat* (v: CtlT.Any): ShadowFormat; VAR new: ShadowFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShadowFormat; PROCEDURE IsShadowFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031B-0000-0000-C000-000000000046}") END IsShadowFormat; PROCEDURE ThisScript* (v: CtlT.Any): Script; VAR new: Script; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0341-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScript; PROCEDURE IsScript* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0341-0000-0000-C000-000000000046}") END IsScript; PROCEDURE ThisScripts* (v: CtlT.Any): Scripts; VAR new: Scripts; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0340-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisScripts; PROCEDURE IsScripts* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0340-0000-0000-C000-000000000046}") END IsScripts; PROCEDURE ThisShape* (v: CtlT.Any): Shape; VAR new: Shape; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShape; PROCEDURE IsShape* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031C-0000-0000-C000-000000000046}") END IsShape; PROCEDURE ThisShapeRange* (v: CtlT.Any): ShapeRange; VAR new: ShapeRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeRange; PROCEDURE IsShapeRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031D-0000-0000-C000-000000000046}") END IsShapeRange; PROCEDURE ThisShapes* (v: CtlT.Any): Shapes; VAR new: Shapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapes; PROCEDURE IsShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031E-0000-0000-C000-000000000046}") END IsShapes; PROCEDURE ThisTextEffectFormat* (v: CtlT.Any): TextEffectFormat; VAR new: TextEffectFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C031F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextEffectFormat; PROCEDURE IsTextEffectFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C031F-0000-0000-C000-000000000046}") END IsTextEffectFormat; PROCEDURE ThisTextFrame* (v: CtlT.Any): TextFrame; VAR new: TextFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0320-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextFrame; PROCEDURE IsTextFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0320-0000-0000-C000-000000000046}") END IsTextFrame; PROCEDURE ThisThreeDFormat* (v: CtlT.Any): ThreeDFormat; VAR new: ThreeDFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0321-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisThreeDFormat; PROCEDURE IsThreeDFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0321-0000-0000-C000-000000000046}") END IsThreeDFormat; PROCEDURE ThisIMsoDispCagNotifySink* (v: CtlT.Any): IMsoDispCagNotifySink; VAR new: IMsoDispCagNotifySink; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0359-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIMsoDispCagNotifySink; PROCEDURE IsIMsoDispCagNotifySink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0359-0000-0000-C000-000000000046}") END IsIMsoDispCagNotifySink; PROCEDURE ThisBalloon* (v: CtlT.Any): Balloon; VAR new: Balloon; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0324-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBalloon; PROCEDURE IsBalloon* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0324-0000-0000-C000-000000000046}") END IsBalloon; PROCEDURE ThisBalloonCheckboxes* (v: CtlT.Any): BalloonCheckboxes; VAR new: BalloonCheckboxes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0326-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBalloonCheckboxes; PROCEDURE IsBalloonCheckboxes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0326-0000-0000-C000-000000000046}") END IsBalloonCheckboxes; PROCEDURE ThisBalloonCheckbox* (v: CtlT.Any): BalloonCheckbox; VAR new: BalloonCheckbox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0328-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBalloonCheckbox; PROCEDURE IsBalloonCheckbox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0328-0000-0000-C000-000000000046}") END IsBalloonCheckbox; PROCEDURE ThisBalloonLabels* (v: CtlT.Any): BalloonLabels; VAR new: BalloonLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C032E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBalloonLabels; PROCEDURE IsBalloonLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C032E-0000-0000-C000-000000000046}") END IsBalloonLabels; PROCEDURE ThisBalloonLabel* (v: CtlT.Any): BalloonLabel; VAR new: BalloonLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0330-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBalloonLabel; PROCEDURE IsBalloonLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0330-0000-0000-C000-000000000046}") END IsBalloonLabel; PROCEDURE ThisAnswerWizardFiles* (v: CtlT.Any): AnswerWizardFiles; VAR new: AnswerWizardFiles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0361-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAnswerWizardFiles; PROCEDURE IsAnswerWizardFiles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0361-0000-0000-C000-000000000046}") END IsAnswerWizardFiles; PROCEDURE ThisAnswerWizard* (v: CtlT.Any): AnswerWizard; VAR new: AnswerWizard; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0360-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAnswerWizard; PROCEDURE IsAnswerWizard* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0360-0000-0000-C000-000000000046}") END IsAnswerWizard; PROCEDURE ThisAssistant* (v: CtlT.Any): Assistant; VAR new: Assistant; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0322-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAssistant; PROCEDURE IsAssistant* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0322-0000-0000-C000-000000000046}") END IsAssistant; PROCEDURE ThisIFoundFiles* (v: CtlT.Any): IFoundFiles; VAR new: IFoundFiles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0338-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIFoundFiles; PROCEDURE IsIFoundFiles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0338-0000-0000-C000-000000000046}") END IsIFoundFiles; PROCEDURE ThisIFind* (v: CtlT.Any): IFind; VAR new: IFind; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0337-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIFind; PROCEDURE IsIFind* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0337-0000-0000-C000-000000000046}") END IsIFind; PROCEDURE ThisFoundFiles* (v: CtlT.Any): FoundFiles; VAR new: FoundFiles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0331-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFoundFiles; PROCEDURE IsFoundFiles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0331-0000-0000-C000-000000000046}") END IsFoundFiles; PROCEDURE ThisPropertyTest* (v: CtlT.Any): PropertyTest; VAR new: PropertyTest; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0333-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPropertyTest; PROCEDURE IsPropertyTest* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0333-0000-0000-C000-000000000046}") END IsPropertyTest; PROCEDURE ThisPropertyTests* (v: CtlT.Any): PropertyTests; VAR new: PropertyTests; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0334-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPropertyTests; PROCEDURE IsPropertyTests* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0334-0000-0000-C000-000000000046}") END IsPropertyTests; PROCEDURE ThisFileSearch* (v: CtlT.Any): FileSearch; VAR new: FileSearch; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0332-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFileSearch; PROCEDURE IsFileSearch* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0332-0000-0000-C000-000000000046}") END IsFileSearch; PROCEDURE ThisCOMAddIn* (v: CtlT.Any): COMAddIn; VAR new: COMAddIn; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C033A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCOMAddIn; PROCEDURE IsCOMAddIn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C033A-0000-0000-C000-000000000046}") END IsCOMAddIn; PROCEDURE ThisCOMAddIns* (v: CtlT.Any): COMAddIns; VAR new: COMAddIns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0339-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCOMAddIns; PROCEDURE IsCOMAddIns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0339-0000-0000-C000-000000000046}") END IsCOMAddIns; PROCEDURE ThisLanguageSettings* (v: CtlT.Any): LanguageSettings; VAR new: LanguageSettings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0353-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLanguageSettings; PROCEDURE IsLanguageSettings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0353-0000-0000-C000-000000000046}") END IsLanguageSettings; PROCEDURE ThisICommandBarsEvents* (v: CtlT.Any): ICommandBarsEvents; VAR new: ICommandBarsEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{55F88892-7708-11D1-ACEB-006008961DA5}"); RETURN new ELSE RETURN NIL END END ThisICommandBarsEvents; PROCEDURE IsICommandBarsEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{55F88892-7708-11D1-ACEB-006008961DA5}") END IsICommandBarsEvents; PROCEDURE ThisICommandBarComboBoxEvents* (v: CtlT.Any): ICommandBarComboBoxEvents; VAR new: ICommandBarComboBoxEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{55F88896-7708-11D1-ACEB-006008961DA5}"); RETURN new ELSE RETURN NIL END END ThisICommandBarComboBoxEvents; PROCEDURE IsICommandBarComboBoxEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{55F88896-7708-11D1-ACEB-006008961DA5}") END IsICommandBarComboBoxEvents; PROCEDURE ThisICommandBarButtonEvents* (v: CtlT.Any): ICommandBarButtonEvents; VAR new: ICommandBarButtonEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{55F88890-7708-11D1-ACEB-006008961DA5}"); RETURN new ELSE RETURN NIL END END ThisICommandBarButtonEvents; PROCEDURE IsICommandBarButtonEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{55F88890-7708-11D1-ACEB-006008961DA5}") END IsICommandBarButtonEvents; PROCEDURE ThisWebPageFont* (v: CtlT.Any): WebPageFont; VAR new: WebPageFont; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0913-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWebPageFont; PROCEDURE IsWebPageFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0913-0000-0000-C000-000000000046}") END IsWebPageFont; PROCEDURE ThisWebPageFonts* (v: CtlT.Any): WebPageFonts; VAR new: WebPageFonts; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0914-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWebPageFonts; PROCEDURE IsWebPageFonts* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0914-0000-0000-C000-000000000046}") END IsWebPageFonts; PROCEDURE ThisHTMLProjectItem* (v: CtlT.Any): HTMLProjectItem; VAR new: HTMLProjectItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0358-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHTMLProjectItem; PROCEDURE IsHTMLProjectItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0358-0000-0000-C000-000000000046}") END IsHTMLProjectItem; PROCEDURE ThisHTMLProjectItems* (v: CtlT.Any): HTMLProjectItems; VAR new: HTMLProjectItems; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0357-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHTMLProjectItems; PROCEDURE IsHTMLProjectItems* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0357-0000-0000-C000-000000000046}") END IsHTMLProjectItems; PROCEDURE ThisHTMLProject* (v: CtlT.Any): HTMLProject; VAR new: HTMLProject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C0356-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHTMLProject; PROCEDURE IsHTMLProject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C0356-0000-0000-C000-000000000046}") END IsHTMLProject; PROCEDURE ThisMsoDebugOptions* (v: CtlT.Any): MsoDebugOptions; VAR new: MsoDebugOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000C035A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMsoDebugOptions; PROCEDURE IsMsoDebugOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000C035A-0000-0000-C000-000000000046}") END IsMsoDebugOptions; (* ---------- IAccessible, hidden, dual ---------- *) PROCEDURE (this: IAccessible) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: IAccessible) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: IAccessible) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: IAccessible) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: IAccessible) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: IAccessible) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: IAccessible) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: IAccessible) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: IAccessible) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: IAccessible) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: IAccessible) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: IAccessible) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: IAccessible) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: IAccessible) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: IAccessible) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: IAccessible) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: IAccessible) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: IAccessible) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: IAccessible) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: IAccessible) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: IAccessible) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; (* ---------- _IMsoDispObj, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _IMsoDispObj) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: _IMsoDispObj) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; (* ---------- _IMsoOleAccDispObj, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _IMsoOleAccDispObj) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _IMsoOleAccDispObj) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _IMsoOleAccDispObj) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _IMsoOleAccDispObj) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _IMsoOleAccDispObj) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _IMsoOleAccDispObj) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _IMsoOleAccDispObj) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _IMsoOleAccDispObj) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _IMsoOleAccDispObj) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _IMsoOleAccDispObj) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _IMsoOleAccDispObj) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _IMsoOleAccDispObj) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _IMsoOleAccDispObj) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _IMsoOleAccDispObj) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _IMsoOleAccDispObj) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _IMsoOleAccDispObj) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _IMsoOleAccDispObj) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _IMsoOleAccDispObj) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _IMsoOleAccDispObj) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _IMsoOleAccDispObj) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _IMsoOleAccDispObj) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _IMsoOleAccDispObj) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: _IMsoOleAccDispObj) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; (* ---------- _CommandBars, dual, nonextensible ---------- *) PROCEDURE (this: _CommandBars) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: _CommandBars) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: _CommandBars) ActionControl* (): CommandBarControl, NEW; BEGIN RETURN ThisCommandBarControl(CtlC.GetAny(this, 1610809344)) END ActionControl; PROCEDURE (this: _CommandBars) ActiveMenuBar* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610809345)) END ActiveMenuBar; PROCEDURE (this: _CommandBars) Add* ((* optional *) Name: CtlT.Any; Position: CtlT.Any; MenuBar: CtlT.Any; Temporary: CtlT.Any): CommandBar, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[3]); CtlC.AnyVar(Position, arg[2]); CtlC.AnyVar(MenuBar, arg[1]); CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610809346, arg, ret); RETURN ThisCommandBar(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _CommandBars) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809347) END Count; PROCEDURE (this: _CommandBars) DisplayTooltips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809348) END DisplayTooltips; PROCEDURE (this: _CommandBars) PUTDisplayTooltips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809348, p1) END PUTDisplayTooltips; PROCEDURE (this: _CommandBars) DisplayKeysInTooltips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809350) END DisplayKeysInTooltips; PROCEDURE (this: _CommandBars) PUTDisplayKeysInTooltips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809350, p1) END PUTDisplayKeysInTooltips; PROCEDURE (this: _CommandBars) FindControl* ((* optional *) Type: CtlT.Any; Id: CtlT.Any; Tag: CtlT.Any; Visible: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[3]); CtlC.AnyVar(Id, arg[2]); CtlC.AnyVar(Tag, arg[1]); CtlC.AnyVar(Visible, arg[0]); CtlC.CallParMethod(this, 1610809352, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END FindControl; PROCEDURE (this: _CommandBars) Item* (Index: CtlT.Any): CommandBar, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisCommandBar(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _CommandBars) LargeButtons* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809354) END LargeButtons; PROCEDURE (this: _CommandBars) PUTLargeButtons* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809354, p1) END PUTLargeButtons; PROCEDURE (this: _CommandBars) MenuAnimationStyle* (): MsoMenuAnimation, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809356) END MenuAnimationStyle; PROCEDURE (this: _CommandBars) PUTMenuAnimationStyle* (p1: MsoMenuAnimation), NEW; BEGIN CtlC.PutInt(this, 1610809356, p1) END PUTMenuAnimationStyle; PROCEDURE (this: _CommandBars) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: _CommandBars) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809359) END Parent; PROCEDURE (this: _CommandBars) ReleaseFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610809360, NIL); END ReleaseFocus; PROCEDURE (this: _CommandBars) IdsString* (ids: INTEGER; OUT pbstrName: CtlT.Strg): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pbstrName_TEMP: CtlT.Variant; BEGIN CtlC.IntVar(ids, arg[1]); CtlC.RefStrVar(pbstrName_TEMP, arg[0]); CtlC.CallGetMethod(this, 1610809361, arg, ret); pbstrName := CtlC.VarStr(pbstrName_TEMP); RETURN CtlC.VarInt(ret) END IdsString; PROCEDURE (this: _CommandBars) TmcGetName* (tmc: INTEGER; OUT pbstrName: CtlT.Strg): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pbstrName_TEMP: CtlT.Variant; BEGIN CtlC.IntVar(tmc, arg[1]); CtlC.RefStrVar(pbstrName_TEMP, arg[0]); CtlC.CallGetMethod(this, 1610809362, arg, ret); pbstrName := CtlC.VarStr(pbstrName_TEMP); RETURN CtlC.VarInt(ret) END TmcGetName; PROCEDURE (this: _CommandBars) AdaptiveMenus* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809363) END AdaptiveMenus; PROCEDURE (this: _CommandBars) PUTAdaptiveMenus* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809363, p1) END PUTAdaptiveMenus; PROCEDURE (this: _CommandBars) FindControls* ((* optional *) Type: CtlT.Any; Id: CtlT.Any; Tag: CtlT.Any; Visible: CtlT.Any): CommandBarControls, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[3]); CtlC.AnyVar(Id, arg[2]); CtlC.AnyVar(Tag, arg[1]); CtlC.AnyVar(Visible, arg[0]); CtlC.CallParMethod(this, 1610809365, arg, ret); RETURN ThisCommandBarControls(CtlC.VarAny(ret)) END FindControls; PROCEDURE (this: _CommandBars) AddEx* ((* optional *) TbidOrName: CtlT.Any; Position: CtlT.Any; MenuBar: CtlT.Any; Temporary: CtlT.Any; TbtrProtection: CtlT.Any): CommandBar, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(TbidOrName, arg[4]); CtlC.AnyVar(Position, arg[3]); CtlC.AnyVar(MenuBar, arg[2]); CtlC.AnyVar(Temporary, arg[1]); CtlC.AnyVar(TbtrProtection, arg[0]); CtlC.CallParMethod(this, 1610809366, arg, ret); RETURN ThisCommandBar(CtlC.VarAny(ret)) END AddEx; PROCEDURE (this: _CommandBars) DisplayFonts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809367) END DisplayFonts; PROCEDURE (this: _CommandBars) PUTDisplayFonts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809367, p1) END PUTDisplayFonts; (* ---------- CommandBar, dual, nonextensible ---------- *) PROCEDURE (this: CommandBar) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: CommandBar) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: CommandBar) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: CommandBar) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: CommandBar) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: CommandBar) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: CommandBar) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: CommandBar) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: CommandBar) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: CommandBar) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: CommandBar) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: CommandBar) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: CommandBar) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: CommandBar) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: CommandBar) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: CommandBar) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: CommandBar) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: CommandBar) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: CommandBar) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: CommandBar) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: CommandBar) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: CommandBar) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: CommandBar) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: CommandBar) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BuiltIn; PROCEDURE (this: CommandBar) Context* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874881) END Context; PROCEDURE (this: CommandBar) PUTContext* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874881, p1) END PUTContext; PROCEDURE (this: CommandBar) Controls* (): CommandBarControls, NEW; BEGIN RETURN ThisCommandBarControls(CtlC.GetAny(this, 1610874883)) END Controls; PROCEDURE (this: CommandBar) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 1610874884, NIL); END Delete; PROCEDURE (this: CommandBar) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874885) END Enabled; PROCEDURE (this: CommandBar) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874885, p1) END PUTEnabled; PROCEDURE (this: CommandBar) FindControl* ((* optional *) Type: CtlT.Any; Id: CtlT.Any; Tag: CtlT.Any; Visible: CtlT.Any; Recursive: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[4]); CtlC.AnyVar(Id, arg[3]); CtlC.AnyVar(Tag, arg[2]); CtlC.AnyVar(Visible, arg[1]); CtlC.AnyVar(Recursive, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END FindControl; PROCEDURE (this: CommandBar) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874888) END Height; PROCEDURE (this: CommandBar) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874888, p1) END PUTHeight; PROCEDURE (this: CommandBar) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874890) END Index; PROCEDURE (this: CommandBar) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874891) END InstanceId; PROCEDURE (this: CommandBar) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874892) END Left; PROCEDURE (this: CommandBar) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874892, p1) END PUTLeft; PROCEDURE (this: CommandBar) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874894) END Name; PROCEDURE (this: CommandBar) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874894, p1) END PUTName; PROCEDURE (this: CommandBar) NameLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874896) END NameLocal; PROCEDURE (this: CommandBar) PUTNameLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874896, p1) END PUTNameLocal; PROCEDURE (this: CommandBar) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874898) END Parent; PROCEDURE (this: CommandBar) Position* (): MsoBarPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Position; PROCEDURE (this: CommandBar) PUTPosition* (p1: MsoBarPosition), NEW; BEGIN CtlC.PutInt(this, 1610874899, p1) END PUTPosition; PROCEDURE (this: CommandBar) RowIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END RowIndex; PROCEDURE (this: CommandBar) PUTRowIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874901, p1) END PUTRowIndex; PROCEDURE (this: CommandBar) Protection* (): MsoBarProtection, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Protection; PROCEDURE (this: CommandBar) PUTProtection* (p1: MsoBarProtection), NEW; BEGIN CtlC.PutInt(this, 1610874903, p1) END PUTProtection; PROCEDURE (this: CommandBar) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874905, NIL); END Reset; PROCEDURE (this: CommandBar) ShowPopup* ((* optional *) x: CtlT.Any; y: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(x, arg[1]); CtlC.AnyVar(y, arg[0]); CtlC.CallParMethod(this, 1610874906, arg, NIL); END ShowPopup; PROCEDURE (this: CommandBar) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874907) END Top; PROCEDURE (this: CommandBar) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874907, p1) END PUTTop; PROCEDURE (this: CommandBar) Type* (): MsoBarType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874909) END Type; PROCEDURE (this: CommandBar) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874910) END Visible; PROCEDURE (this: CommandBar) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874910, p1) END PUTVisible; PROCEDURE (this: CommandBar) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874912) END Width; PROCEDURE (this: CommandBar) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874912, p1) END PUTWidth; PROCEDURE (this: CommandBar) AdaptiveMenu* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874914) END AdaptiveMenu; PROCEDURE (this: CommandBar) PUTAdaptiveMenu* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874914, p1) END PUTAdaptiveMenu; (* ---------- CommandBarControls, dual, nonextensible ---------- *) PROCEDURE (this: CommandBarControls) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: CommandBarControls) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: CommandBarControls) Add* ((* optional *) Type: CtlT.Any; Id: CtlT.Any; Parameter: CtlT.Any; Before: CtlT.Any; Temporary: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[4]); CtlC.AnyVar(Id, arg[3]); CtlC.AnyVar(Parameter, arg[2]); CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610809344, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Add; PROCEDURE (this: CommandBarControls) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Count; PROCEDURE (this: CommandBarControls) Item* (Index: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CommandBarControls) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: CommandBarControls) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610809348)) END Parent; (* ---------- CommandBarControl, dual ---------- *) PROCEDURE (this: CommandBarControl) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: CommandBarControl) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: CommandBarControl) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: CommandBarControl) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: CommandBarControl) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: CommandBarControl) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: CommandBarControl) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: CommandBarControl) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: CommandBarControl) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: CommandBarControl) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: CommandBarControl) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: CommandBarControl) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: CommandBarControl) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: CommandBarControl) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: CommandBarControl) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: CommandBarControl) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: CommandBarControl) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: CommandBarControl) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: CommandBarControl) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: CommandBarControl) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: CommandBarControl) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: CommandBarControl) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: CommandBarControl) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: CommandBarControl) BeginGroup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BeginGroup; PROCEDURE (this: CommandBarControl) PUTBeginGroup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874880, p1) END PUTBeginGroup; PROCEDURE (this: CommandBarControl) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874882) END BuiltIn; PROCEDURE (this: CommandBarControl) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874883) END Caption; PROCEDURE (this: CommandBarControl) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874883, p1) END PUTCaption; PROCEDURE (this: CommandBarControl) Control* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874885) END Control; PROCEDURE (this: CommandBarControl) Copy* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874886, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: CommandBarControl) Delete* ((* optional *) Temporary: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, NIL); END Delete; PROCEDURE (this: CommandBarControl) DescriptionText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874888) END DescriptionText; PROCEDURE (this: CommandBarControl) PUTDescriptionText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874888, p1) END PUTDescriptionText; PROCEDURE (this: CommandBarControl) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874890) END Enabled; PROCEDURE (this: CommandBarControl) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874890, p1) END PUTEnabled; PROCEDURE (this: CommandBarControl) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610874892, NIL); END Execute; PROCEDURE (this: CommandBarControl) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874893) END Height; PROCEDURE (this: CommandBarControl) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874893, p1) END PUTHeight; PROCEDURE (this: CommandBarControl) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874895) END HelpContextId; PROCEDURE (this: CommandBarControl) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874895, p1) END PUTHelpContextId; PROCEDURE (this: CommandBarControl) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874897) END HelpFile; PROCEDURE (this: CommandBarControl) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874897, p1) END PUTHelpFile; PROCEDURE (this: CommandBarControl) Id* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Id; PROCEDURE (this: CommandBarControl) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874900) END Index; PROCEDURE (this: CommandBarControl) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END InstanceId; PROCEDURE (this: CommandBarControl) Move* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874902, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Move; PROCEDURE (this: CommandBarControl) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Left; PROCEDURE (this: CommandBarControl) OLEUsage* (): MsoControlOLEUsage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874904) END OLEUsage; PROCEDURE (this: CommandBarControl) PUTOLEUsage* (p1: MsoControlOLEUsage), NEW; BEGIN CtlC.PutInt(this, 1610874904, p1) END PUTOLEUsage; PROCEDURE (this: CommandBarControl) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874906) END OnAction; PROCEDURE (this: CommandBarControl) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874906, p1) END PUTOnAction; PROCEDURE (this: CommandBarControl) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610874908)) END Parent; PROCEDURE (this: CommandBarControl) Parameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874909) END Parameter; PROCEDURE (this: CommandBarControl) PUTParameter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874909, p1) END PUTParameter; PROCEDURE (this: CommandBarControl) Priority* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874911) END Priority; PROCEDURE (this: CommandBarControl) PUTPriority* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874911, p1) END PUTPriority; PROCEDURE (this: CommandBarControl) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874913, NIL); END Reset; PROCEDURE (this: CommandBarControl) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610874914, NIL); END SetFocus; PROCEDURE (this: CommandBarControl) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874915) END Tag; PROCEDURE (this: CommandBarControl) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874915, p1) END PUTTag; PROCEDURE (this: CommandBarControl) TooltipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874917) END TooltipText; PROCEDURE (this: CommandBarControl) PUTTooltipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874917, p1) END PUTTooltipText; PROCEDURE (this: CommandBarControl) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874919) END Top; PROCEDURE (this: CommandBarControl) Type* (): MsoControlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874920) END Type; PROCEDURE (this: CommandBarControl) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874921) END Visible; PROCEDURE (this: CommandBarControl) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874921, p1) END PUTVisible; PROCEDURE (this: CommandBarControl) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874923) END Width; PROCEDURE (this: CommandBarControl) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874923, p1) END PUTWidth; PROCEDURE (this: CommandBarControl) IsPriorityDropped* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874925) END IsPriorityDropped; PROCEDURE (this: CommandBarControl) Reserved1* (), NEW; BEGIN CtlC.CallMethod(this, 1610874926, NIL); END Reserved1; PROCEDURE (this: CommandBarControl) Reserved2* (), NEW; BEGIN CtlC.CallMethod(this, 1610874927, NIL); END Reserved2; PROCEDURE (this: CommandBarControl) Reserved3* (), NEW; BEGIN CtlC.CallMethod(this, 1610874928, NIL); END Reserved3; PROCEDURE (this: CommandBarControl) Reserved4* (), NEW; BEGIN CtlC.CallMethod(this, 1610874929, NIL); END Reserved4; PROCEDURE (this: CommandBarControl) Reserved5* (), NEW; BEGIN CtlC.CallMethod(this, 1610874930, NIL); END Reserved5; PROCEDURE (this: CommandBarControl) Reserved6* (), NEW; BEGIN CtlC.CallMethod(this, 1610874931, NIL); END Reserved6; PROCEDURE (this: CommandBarControl) Reserved7* (), NEW; BEGIN CtlC.CallMethod(this, 1610874932, NIL); END Reserved7; (* ---------- _CommandBarButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _CommandBarButton) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _CommandBarButton) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _CommandBarButton) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _CommandBarButton) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _CommandBarButton) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _CommandBarButton) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _CommandBarButton) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _CommandBarButton) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _CommandBarButton) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _CommandBarButton) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _CommandBarButton) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _CommandBarButton) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _CommandBarButton) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _CommandBarButton) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _CommandBarButton) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _CommandBarButton) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _CommandBarButton) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _CommandBarButton) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _CommandBarButton) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _CommandBarButton) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _CommandBarButton) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _CommandBarButton) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: _CommandBarButton) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: _CommandBarButton) BeginGroup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BeginGroup; PROCEDURE (this: _CommandBarButton) PUTBeginGroup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874880, p1) END PUTBeginGroup; PROCEDURE (this: _CommandBarButton) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874882) END BuiltIn; PROCEDURE (this: _CommandBarButton) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874883) END Caption; PROCEDURE (this: _CommandBarButton) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874883, p1) END PUTCaption; PROCEDURE (this: _CommandBarButton) Control* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874885) END Control; PROCEDURE (this: _CommandBarButton) Copy* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874886, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: _CommandBarButton) Delete* ((* optional *) Temporary: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, NIL); END Delete; PROCEDURE (this: _CommandBarButton) DescriptionText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874888) END DescriptionText; PROCEDURE (this: _CommandBarButton) PUTDescriptionText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874888, p1) END PUTDescriptionText; PROCEDURE (this: _CommandBarButton) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874890) END Enabled; PROCEDURE (this: _CommandBarButton) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874890, p1) END PUTEnabled; PROCEDURE (this: _CommandBarButton) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610874892, NIL); END Execute; PROCEDURE (this: _CommandBarButton) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874893) END Height; PROCEDURE (this: _CommandBarButton) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874893, p1) END PUTHeight; PROCEDURE (this: _CommandBarButton) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874895) END HelpContextId; PROCEDURE (this: _CommandBarButton) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874895, p1) END PUTHelpContextId; PROCEDURE (this: _CommandBarButton) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874897) END HelpFile; PROCEDURE (this: _CommandBarButton) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874897, p1) END PUTHelpFile; PROCEDURE (this: _CommandBarButton) Id* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Id; PROCEDURE (this: _CommandBarButton) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874900) END Index; PROCEDURE (this: _CommandBarButton) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END InstanceId; PROCEDURE (this: _CommandBarButton) Move* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874902, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Move; PROCEDURE (this: _CommandBarButton) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Left; PROCEDURE (this: _CommandBarButton) OLEUsage* (): MsoControlOLEUsage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874904) END OLEUsage; PROCEDURE (this: _CommandBarButton) PUTOLEUsage* (p1: MsoControlOLEUsage), NEW; BEGIN CtlC.PutInt(this, 1610874904, p1) END PUTOLEUsage; PROCEDURE (this: _CommandBarButton) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874906) END OnAction; PROCEDURE (this: _CommandBarButton) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874906, p1) END PUTOnAction; PROCEDURE (this: _CommandBarButton) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610874908)) END Parent; PROCEDURE (this: _CommandBarButton) Parameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874909) END Parameter; PROCEDURE (this: _CommandBarButton) PUTParameter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874909, p1) END PUTParameter; PROCEDURE (this: _CommandBarButton) Priority* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874911) END Priority; PROCEDURE (this: _CommandBarButton) PUTPriority* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874911, p1) END PUTPriority; PROCEDURE (this: _CommandBarButton) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874913, NIL); END Reset; PROCEDURE (this: _CommandBarButton) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610874914, NIL); END SetFocus; PROCEDURE (this: _CommandBarButton) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874915) END Tag; PROCEDURE (this: _CommandBarButton) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874915, p1) END PUTTag; PROCEDURE (this: _CommandBarButton) TooltipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874917) END TooltipText; PROCEDURE (this: _CommandBarButton) PUTTooltipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874917, p1) END PUTTooltipText; PROCEDURE (this: _CommandBarButton) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874919) END Top; PROCEDURE (this: _CommandBarButton) Type* (): MsoControlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874920) END Type; PROCEDURE (this: _CommandBarButton) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874921) END Visible; PROCEDURE (this: _CommandBarButton) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874921, p1) END PUTVisible; PROCEDURE (this: _CommandBarButton) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874923) END Width; PROCEDURE (this: _CommandBarButton) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874923, p1) END PUTWidth; PROCEDURE (this: _CommandBarButton) IsPriorityDropped* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874925) END IsPriorityDropped; PROCEDURE (this: _CommandBarButton) Reserved1* (), NEW; BEGIN CtlC.CallMethod(this, 1610874926, NIL); END Reserved1; PROCEDURE (this: _CommandBarButton) Reserved2* (), NEW; BEGIN CtlC.CallMethod(this, 1610874927, NIL); END Reserved2; PROCEDURE (this: _CommandBarButton) Reserved3* (), NEW; BEGIN CtlC.CallMethod(this, 1610874928, NIL); END Reserved3; PROCEDURE (this: _CommandBarButton) Reserved4* (), NEW; BEGIN CtlC.CallMethod(this, 1610874929, NIL); END Reserved4; PROCEDURE (this: _CommandBarButton) Reserved5* (), NEW; BEGIN CtlC.CallMethod(this, 1610874930, NIL); END Reserved5; PROCEDURE (this: _CommandBarButton) Reserved6* (), NEW; BEGIN CtlC.CallMethod(this, 1610874931, NIL); END Reserved6; PROCEDURE (this: _CommandBarButton) Reserved7* (), NEW; BEGIN CtlC.CallMethod(this, 1610874932, NIL); END Reserved7; PROCEDURE (this: _CommandBarButton) BuiltInFace* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610940416) END BuiltInFace; PROCEDURE (this: _CommandBarButton) PUTBuiltInFace* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610940416, p1) END PUTBuiltInFace; PROCEDURE (this: _CommandBarButton) CopyFace* (), NEW; BEGIN CtlC.CallMethod(this, 1610940418, NIL); END CopyFace; PROCEDURE (this: _CommandBarButton) FaceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940419) END FaceId; PROCEDURE (this: _CommandBarButton) PUTFaceId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610940419, p1) END PUTFaceId; PROCEDURE (this: _CommandBarButton) PasteFace* (), NEW; BEGIN CtlC.CallMethod(this, 1610940421, NIL); END PasteFace; PROCEDURE (this: _CommandBarButton) ShortcutText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610940422) END ShortcutText; PROCEDURE (this: _CommandBarButton) PUTShortcutText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610940422, p1) END PUTShortcutText; PROCEDURE (this: _CommandBarButton) State* (): MsoButtonState, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940424) END State; PROCEDURE (this: _CommandBarButton) PUTState* (p1: MsoButtonState), NEW; BEGIN CtlC.PutInt(this, 1610940424, p1) END PUTState; PROCEDURE (this: _CommandBarButton) Style* (): MsoButtonStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940426) END Style; PROCEDURE (this: _CommandBarButton) PUTStyle* (p1: MsoButtonStyle), NEW; BEGIN CtlC.PutInt(this, 1610940426, p1) END PUTStyle; PROCEDURE (this: _CommandBarButton) HyperlinkType* (): MsoCommandBarButtonHyperlinkType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940428) END HyperlinkType; PROCEDURE (this: _CommandBarButton) PUTHyperlinkType* (p1: MsoCommandBarButtonHyperlinkType), NEW; BEGIN CtlC.PutInt(this, 1610940428, p1) END PUTHyperlinkType; (* ---------- CommandBarPopup, dual, nonextensible ---------- *) PROCEDURE (this: CommandBarPopup) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: CommandBarPopup) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: CommandBarPopup) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: CommandBarPopup) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: CommandBarPopup) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: CommandBarPopup) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: CommandBarPopup) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: CommandBarPopup) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: CommandBarPopup) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: CommandBarPopup) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: CommandBarPopup) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: CommandBarPopup) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: CommandBarPopup) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: CommandBarPopup) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: CommandBarPopup) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: CommandBarPopup) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: CommandBarPopup) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: CommandBarPopup) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: CommandBarPopup) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: CommandBarPopup) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: CommandBarPopup) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: CommandBarPopup) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: CommandBarPopup) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: CommandBarPopup) BeginGroup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BeginGroup; PROCEDURE (this: CommandBarPopup) PUTBeginGroup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874880, p1) END PUTBeginGroup; PROCEDURE (this: CommandBarPopup) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874882) END BuiltIn; PROCEDURE (this: CommandBarPopup) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874883) END Caption; PROCEDURE (this: CommandBarPopup) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874883, p1) END PUTCaption; PROCEDURE (this: CommandBarPopup) Control* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874885) END Control; PROCEDURE (this: CommandBarPopup) Copy* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874886, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: CommandBarPopup) Delete* ((* optional *) Temporary: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, NIL); END Delete; PROCEDURE (this: CommandBarPopup) DescriptionText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874888) END DescriptionText; PROCEDURE (this: CommandBarPopup) PUTDescriptionText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874888, p1) END PUTDescriptionText; PROCEDURE (this: CommandBarPopup) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874890) END Enabled; PROCEDURE (this: CommandBarPopup) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874890, p1) END PUTEnabled; PROCEDURE (this: CommandBarPopup) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610874892, NIL); END Execute; PROCEDURE (this: CommandBarPopup) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874893) END Height; PROCEDURE (this: CommandBarPopup) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874893, p1) END PUTHeight; PROCEDURE (this: CommandBarPopup) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874895) END HelpContextId; PROCEDURE (this: CommandBarPopup) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874895, p1) END PUTHelpContextId; PROCEDURE (this: CommandBarPopup) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874897) END HelpFile; PROCEDURE (this: CommandBarPopup) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874897, p1) END PUTHelpFile; PROCEDURE (this: CommandBarPopup) Id* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Id; PROCEDURE (this: CommandBarPopup) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874900) END Index; PROCEDURE (this: CommandBarPopup) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END InstanceId; PROCEDURE (this: CommandBarPopup) Move* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874902, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Move; PROCEDURE (this: CommandBarPopup) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Left; PROCEDURE (this: CommandBarPopup) OLEUsage* (): MsoControlOLEUsage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874904) END OLEUsage; PROCEDURE (this: CommandBarPopup) PUTOLEUsage* (p1: MsoControlOLEUsage), NEW; BEGIN CtlC.PutInt(this, 1610874904, p1) END PUTOLEUsage; PROCEDURE (this: CommandBarPopup) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874906) END OnAction; PROCEDURE (this: CommandBarPopup) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874906, p1) END PUTOnAction; PROCEDURE (this: CommandBarPopup) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610874908)) END Parent; PROCEDURE (this: CommandBarPopup) Parameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874909) END Parameter; PROCEDURE (this: CommandBarPopup) PUTParameter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874909, p1) END PUTParameter; PROCEDURE (this: CommandBarPopup) Priority* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874911) END Priority; PROCEDURE (this: CommandBarPopup) PUTPriority* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874911, p1) END PUTPriority; PROCEDURE (this: CommandBarPopup) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874913, NIL); END Reset; PROCEDURE (this: CommandBarPopup) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610874914, NIL); END SetFocus; PROCEDURE (this: CommandBarPopup) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874915) END Tag; PROCEDURE (this: CommandBarPopup) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874915, p1) END PUTTag; PROCEDURE (this: CommandBarPopup) TooltipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874917) END TooltipText; PROCEDURE (this: CommandBarPopup) PUTTooltipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874917, p1) END PUTTooltipText; PROCEDURE (this: CommandBarPopup) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874919) END Top; PROCEDURE (this: CommandBarPopup) Type* (): MsoControlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874920) END Type; PROCEDURE (this: CommandBarPopup) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874921) END Visible; PROCEDURE (this: CommandBarPopup) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874921, p1) END PUTVisible; PROCEDURE (this: CommandBarPopup) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874923) END Width; PROCEDURE (this: CommandBarPopup) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874923, p1) END PUTWidth; PROCEDURE (this: CommandBarPopup) IsPriorityDropped* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874925) END IsPriorityDropped; PROCEDURE (this: CommandBarPopup) Reserved1* (), NEW; BEGIN CtlC.CallMethod(this, 1610874926, NIL); END Reserved1; PROCEDURE (this: CommandBarPopup) Reserved2* (), NEW; BEGIN CtlC.CallMethod(this, 1610874927, NIL); END Reserved2; PROCEDURE (this: CommandBarPopup) Reserved3* (), NEW; BEGIN CtlC.CallMethod(this, 1610874928, NIL); END Reserved3; PROCEDURE (this: CommandBarPopup) Reserved4* (), NEW; BEGIN CtlC.CallMethod(this, 1610874929, NIL); END Reserved4; PROCEDURE (this: CommandBarPopup) Reserved5* (), NEW; BEGIN CtlC.CallMethod(this, 1610874930, NIL); END Reserved5; PROCEDURE (this: CommandBarPopup) Reserved6* (), NEW; BEGIN CtlC.CallMethod(this, 1610874931, NIL); END Reserved6; PROCEDURE (this: CommandBarPopup) Reserved7* (), NEW; BEGIN CtlC.CallMethod(this, 1610874932, NIL); END Reserved7; PROCEDURE (this: CommandBarPopup) CommandBar* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610940416)) END CommandBar; PROCEDURE (this: CommandBarPopup) Controls* (): CommandBarControls, NEW; BEGIN RETURN ThisCommandBarControls(CtlC.GetAny(this, 1610940417)) END Controls; PROCEDURE (this: CommandBarPopup) OLEMenuGroup* (): MsoOLEMenuGroup, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940418) END OLEMenuGroup; PROCEDURE (this: CommandBarPopup) PUTOLEMenuGroup* (p1: MsoOLEMenuGroup), NEW; BEGIN CtlC.PutInt(this, 1610940418, p1) END PUTOLEMenuGroup; (* ---------- _CommandBarComboBox, dual, nonextensible ---------- *) PROCEDURE (this: _CommandBarComboBox) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _CommandBarComboBox) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _CommandBarComboBox) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _CommandBarComboBox) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _CommandBarComboBox) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _CommandBarComboBox) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _CommandBarComboBox) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _CommandBarComboBox) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _CommandBarComboBox) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _CommandBarComboBox) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _CommandBarComboBox) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _CommandBarComboBox) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _CommandBarComboBox) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _CommandBarComboBox) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _CommandBarComboBox) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _CommandBarComboBox) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _CommandBarComboBox) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _CommandBarComboBox) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _CommandBarComboBox) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _CommandBarComboBox) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _CommandBarComboBox) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _CommandBarComboBox) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: _CommandBarComboBox) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: _CommandBarComboBox) BeginGroup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BeginGroup; PROCEDURE (this: _CommandBarComboBox) PUTBeginGroup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874880, p1) END PUTBeginGroup; PROCEDURE (this: _CommandBarComboBox) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874882) END BuiltIn; PROCEDURE (this: _CommandBarComboBox) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874883) END Caption; PROCEDURE (this: _CommandBarComboBox) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874883, p1) END PUTCaption; PROCEDURE (this: _CommandBarComboBox) Control* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874885) END Control; PROCEDURE (this: _CommandBarComboBox) Copy* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874886, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: _CommandBarComboBox) Delete* ((* optional *) Temporary: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, NIL); END Delete; PROCEDURE (this: _CommandBarComboBox) DescriptionText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874888) END DescriptionText; PROCEDURE (this: _CommandBarComboBox) PUTDescriptionText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874888, p1) END PUTDescriptionText; PROCEDURE (this: _CommandBarComboBox) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874890) END Enabled; PROCEDURE (this: _CommandBarComboBox) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874890, p1) END PUTEnabled; PROCEDURE (this: _CommandBarComboBox) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610874892, NIL); END Execute; PROCEDURE (this: _CommandBarComboBox) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874893) END Height; PROCEDURE (this: _CommandBarComboBox) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874893, p1) END PUTHeight; PROCEDURE (this: _CommandBarComboBox) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874895) END HelpContextId; PROCEDURE (this: _CommandBarComboBox) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874895, p1) END PUTHelpContextId; PROCEDURE (this: _CommandBarComboBox) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874897) END HelpFile; PROCEDURE (this: _CommandBarComboBox) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874897, p1) END PUTHelpFile; PROCEDURE (this: _CommandBarComboBox) Id* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Id; PROCEDURE (this: _CommandBarComboBox) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874900) END Index; PROCEDURE (this: _CommandBarComboBox) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END InstanceId; PROCEDURE (this: _CommandBarComboBox) Move* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874902, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Move; PROCEDURE (this: _CommandBarComboBox) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Left; PROCEDURE (this: _CommandBarComboBox) OLEUsage* (): MsoControlOLEUsage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874904) END OLEUsage; PROCEDURE (this: _CommandBarComboBox) PUTOLEUsage* (p1: MsoControlOLEUsage), NEW; BEGIN CtlC.PutInt(this, 1610874904, p1) END PUTOLEUsage; PROCEDURE (this: _CommandBarComboBox) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874906) END OnAction; PROCEDURE (this: _CommandBarComboBox) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874906, p1) END PUTOnAction; PROCEDURE (this: _CommandBarComboBox) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610874908)) END Parent; PROCEDURE (this: _CommandBarComboBox) Parameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874909) END Parameter; PROCEDURE (this: _CommandBarComboBox) PUTParameter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874909, p1) END PUTParameter; PROCEDURE (this: _CommandBarComboBox) Priority* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874911) END Priority; PROCEDURE (this: _CommandBarComboBox) PUTPriority* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874911, p1) END PUTPriority; PROCEDURE (this: _CommandBarComboBox) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874913, NIL); END Reset; PROCEDURE (this: _CommandBarComboBox) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610874914, NIL); END SetFocus; PROCEDURE (this: _CommandBarComboBox) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874915) END Tag; PROCEDURE (this: _CommandBarComboBox) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874915, p1) END PUTTag; PROCEDURE (this: _CommandBarComboBox) TooltipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874917) END TooltipText; PROCEDURE (this: _CommandBarComboBox) PUTTooltipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874917, p1) END PUTTooltipText; PROCEDURE (this: _CommandBarComboBox) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874919) END Top; PROCEDURE (this: _CommandBarComboBox) Type* (): MsoControlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874920) END Type; PROCEDURE (this: _CommandBarComboBox) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874921) END Visible; PROCEDURE (this: _CommandBarComboBox) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874921, p1) END PUTVisible; PROCEDURE (this: _CommandBarComboBox) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874923) END Width; PROCEDURE (this: _CommandBarComboBox) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874923, p1) END PUTWidth; PROCEDURE (this: _CommandBarComboBox) IsPriorityDropped* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874925) END IsPriorityDropped; PROCEDURE (this: _CommandBarComboBox) Reserved1* (), NEW; BEGIN CtlC.CallMethod(this, 1610874926, NIL); END Reserved1; PROCEDURE (this: _CommandBarComboBox) Reserved2* (), NEW; BEGIN CtlC.CallMethod(this, 1610874927, NIL); END Reserved2; PROCEDURE (this: _CommandBarComboBox) Reserved3* (), NEW; BEGIN CtlC.CallMethod(this, 1610874928, NIL); END Reserved3; PROCEDURE (this: _CommandBarComboBox) Reserved4* (), NEW; BEGIN CtlC.CallMethod(this, 1610874929, NIL); END Reserved4; PROCEDURE (this: _CommandBarComboBox) Reserved5* (), NEW; BEGIN CtlC.CallMethod(this, 1610874930, NIL); END Reserved5; PROCEDURE (this: _CommandBarComboBox) Reserved6* (), NEW; BEGIN CtlC.CallMethod(this, 1610874931, NIL); END Reserved6; PROCEDURE (this: _CommandBarComboBox) Reserved7* (), NEW; BEGIN CtlC.CallMethod(this, 1610874932, NIL); END Reserved7; PROCEDURE (this: _CommandBarComboBox) AddItem* (Text: ARRAY OF CHAR; (* optional *) Index: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 1610940416, arg, NIL); END AddItem; PROCEDURE (this: _CommandBarComboBox) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 1610940417, NIL); END Clear; PROCEDURE (this: _CommandBarComboBox) DropDownLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940418) END DropDownLines; PROCEDURE (this: _CommandBarComboBox) PUTDropDownLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610940418, p1) END PUTDropDownLines; PROCEDURE (this: _CommandBarComboBox) DropDownWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940420) END DropDownWidth; PROCEDURE (this: _CommandBarComboBox) PUTDropDownWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610940420, p1) END PUTDropDownWidth; PROCEDURE (this: _CommandBarComboBox) List* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 1610940422, arg, ret); RETURN CtlC.VarStr(ret) END List; PROCEDURE (this: _CommandBarComboBox) PUTList* (Index: INTEGER; p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, 1610940422, arg, NIL); END PUTList; PROCEDURE (this: _CommandBarComboBox) ListCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940424) END ListCount; PROCEDURE (this: _CommandBarComboBox) ListHeaderCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940425) END ListHeaderCount; PROCEDURE (this: _CommandBarComboBox) PUTListHeaderCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610940425, p1) END PUTListHeaderCount; PROCEDURE (this: _CommandBarComboBox) ListIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940427) END ListIndex; PROCEDURE (this: _CommandBarComboBox) PUTListIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610940427, p1) END PUTListIndex; PROCEDURE (this: _CommandBarComboBox) RemoveItem* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 1610940429, arg, NIL); END RemoveItem; PROCEDURE (this: _CommandBarComboBox) Style* (): MsoComboStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 1610940430) END Style; PROCEDURE (this: _CommandBarComboBox) PUTStyle* (p1: MsoComboStyle), NEW; BEGIN CtlC.PutInt(this, 1610940430, p1) END PUTStyle; PROCEDURE (this: _CommandBarComboBox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610940432) END Text; PROCEDURE (this: _CommandBarComboBox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610940432, p1) END PUTText; (* ---------- _CommandBarActiveX, dual, nonextensible ---------- *) PROCEDURE (this: _CommandBarActiveX) accParent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -5000) END accParent; PROCEDURE (this: _CommandBarActiveX) accChildCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -5001) END accChildCount; PROCEDURE (this: _CommandBarActiveX) accChild* (varChild: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5002, arg, ret); RETURN CtlC.VarObj(ret) END accChild; PROCEDURE (this: _CommandBarActiveX) accName* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5003, arg, ret); RETURN CtlC.VarStr(ret) END accName; PROCEDURE (this: _CommandBarActiveX) accValue* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5004, arg, ret); RETURN CtlC.VarStr(ret) END accValue; PROCEDURE (this: _CommandBarActiveX) accDescription* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5005, arg, ret); RETURN CtlC.VarStr(ret) END accDescription; PROCEDURE (this: _CommandBarActiveX) accRole* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5006, arg, ret); RETURN CtlC.VarAny(ret) END accRole; PROCEDURE (this: _CommandBarActiveX) accState* ((* optional *) varChild: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5007, arg, ret); RETURN CtlC.VarAny(ret) END accState; PROCEDURE (this: _CommandBarActiveX) accHelp* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5008, arg, ret); RETURN CtlC.VarStr(ret) END accHelp; PROCEDURE (this: _CommandBarActiveX) accHelpTopic* (OUT pszHelpFile: CtlT.Strg; (* optional *) varChild: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; pszHelpFile_TEMP: CtlT.Variant; BEGIN CtlC.RefStrVar(pszHelpFile_TEMP, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5009, arg, ret); pszHelpFile := CtlC.VarStr(pszHelpFile_TEMP); RETURN CtlC.VarInt(ret) END accHelpTopic; PROCEDURE (this: _CommandBarActiveX) accKeyboardShortcut* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5010, arg, ret); RETURN CtlC.VarStr(ret) END accKeyboardShortcut; PROCEDURE (this: _CommandBarActiveX) accFocus* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5011) END accFocus; PROCEDURE (this: _CommandBarActiveX) accSelection* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, -5012) END accSelection; PROCEDURE (this: _CommandBarActiveX) accDefaultAction* ((* optional *) varChild: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallGetMethod(this, -5013, arg, ret); RETURN CtlC.VarStr(ret) END accDefaultAction; PROCEDURE (this: _CommandBarActiveX) accSelect* (flagsSelect: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(flagsSelect, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5014, arg, NIL); END accSelect; PROCEDURE (this: _CommandBarActiveX) accLocation* (OUT pxLeft: INTEGER; OUT pyTop: INTEGER; OUT pcxWidth: INTEGER; OUT pcyHeight: INTEGER; (* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(pxLeft, arg[4]); CtlC.RefIntVar(pyTop, arg[3]); CtlC.RefIntVar(pcxWidth, arg[2]); CtlC.RefIntVar(pcyHeight, arg[1]); CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5015, arg, NIL); END accLocation; PROCEDURE (this: _CommandBarActiveX) accNavigate* (navDir: INTEGER; (* optional *) varStart: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(navDir, arg[1]); CtlC.AnyVar(varStart, arg[0]); CtlC.CallParMethod(this, -5016, arg, ret); RETURN CtlC.VarAny(ret) END accNavigate; PROCEDURE (this: _CommandBarActiveX) accHitTest* (xLeft: INTEGER; yTop: INTEGER): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, -5017, arg, ret); RETURN CtlC.VarAny(ret) END accHitTest; PROCEDURE (this: _CommandBarActiveX) accDoDefaultAction* ((* optional *) varChild: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[0]); CtlC.CallParMethod(this, -5018, arg, NIL); END accDoDefaultAction; PROCEDURE (this: _CommandBarActiveX) PUTaccName* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5003, arg, NIL); END PUTaccName; PROCEDURE (this: _CommandBarActiveX) PUTaccValue* (varChild: CtlT.Any; (* optional *) p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(varChild, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, -5004, arg, NIL); END PUTaccValue; PROCEDURE (this: _CommandBarActiveX) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Application; PROCEDURE (this: _CommandBarActiveX) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Creator; PROCEDURE (this: _CommandBarActiveX) BeginGroup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874880) END BeginGroup; PROCEDURE (this: _CommandBarActiveX) PUTBeginGroup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874880, p1) END PUTBeginGroup; PROCEDURE (this: _CommandBarActiveX) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874882) END BuiltIn; PROCEDURE (this: _CommandBarActiveX) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874883) END Caption; PROCEDURE (this: _CommandBarActiveX) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874883, p1) END PUTCaption; PROCEDURE (this: _CommandBarActiveX) Control* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610874885) END Control; PROCEDURE (this: _CommandBarActiveX) Copy* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874886, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: _CommandBarActiveX) Delete* ((* optional *) Temporary: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Temporary, arg[0]); CtlC.CallParMethod(this, 1610874887, arg, NIL); END Delete; PROCEDURE (this: _CommandBarActiveX) DescriptionText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874888) END DescriptionText; PROCEDURE (this: _CommandBarActiveX) PUTDescriptionText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874888, p1) END PUTDescriptionText; PROCEDURE (this: _CommandBarActiveX) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874890) END Enabled; PROCEDURE (this: _CommandBarActiveX) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874890, p1) END PUTEnabled; PROCEDURE (this: _CommandBarActiveX) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610874892, NIL); END Execute; PROCEDURE (this: _CommandBarActiveX) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874893) END Height; PROCEDURE (this: _CommandBarActiveX) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874893, p1) END PUTHeight; PROCEDURE (this: _CommandBarActiveX) HelpContextId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874895) END HelpContextId; PROCEDURE (this: _CommandBarActiveX) PUTHelpContextId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874895, p1) END PUTHelpContextId; PROCEDURE (this: _CommandBarActiveX) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874897) END HelpFile; PROCEDURE (this: _CommandBarActiveX) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874897, p1) END PUTHelpFile; PROCEDURE (this: _CommandBarActiveX) Id* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874899) END Id; PROCEDURE (this: _CommandBarActiveX) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874900) END Index; PROCEDURE (this: _CommandBarActiveX) InstanceId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874901) END InstanceId; PROCEDURE (this: _CommandBarActiveX) Move* ((* optional *) Bar: CtlT.Any; Before: CtlT.Any): CommandBarControl, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Bar, arg[1]); CtlC.AnyVar(Before, arg[0]); CtlC.CallParMethod(this, 1610874902, arg, ret); RETURN ThisCommandBarControl(CtlC.VarAny(ret)) END Move; PROCEDURE (this: _CommandBarActiveX) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874903) END Left; PROCEDURE (this: _CommandBarActiveX) OLEUsage* (): MsoControlOLEUsage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874904) END OLEUsage; PROCEDURE (this: _CommandBarActiveX) PUTOLEUsage* (p1: MsoControlOLEUsage), NEW; BEGIN CtlC.PutInt(this, 1610874904, p1) END PUTOLEUsage; PROCEDURE (this: _CommandBarActiveX) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874906) END OnAction; PROCEDURE (this: _CommandBarActiveX) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874906, p1) END PUTOnAction; PROCEDURE (this: _CommandBarActiveX) Parent* (): CommandBar, NEW; BEGIN RETURN ThisCommandBar(CtlC.GetAny(this, 1610874908)) END Parent; PROCEDURE (this: _CommandBarActiveX) Parameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874909) END Parameter; PROCEDURE (this: _CommandBarActiveX) PUTParameter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874909, p1) END PUTParameter; PROCEDURE (this: _CommandBarActiveX) Priority* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874911) END Priority; PROCEDURE (this: _CommandBarActiveX) PUTPriority* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874911, p1) END PUTPriority; PROCEDURE (this: _CommandBarActiveX) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 1610874913, NIL); END Reset; PROCEDURE (this: _CommandBarActiveX) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 1610874914, NIL); END SetFocus; PROCEDURE (this: _CommandBarActiveX) Tag* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874915) END Tag; PROCEDURE (this: _CommandBarActiveX) PUTTag* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874915, p1) END PUTTag; PROCEDURE (this: _CommandBarActiveX) TooltipText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610874917) END TooltipText; PROCEDURE (this: _CommandBarActiveX) PUTTooltipText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610874917, p1) END PUTTooltipText; PROCEDURE (this: _CommandBarActiveX) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874919) END Top; PROCEDURE (this: _CommandBarActiveX) Type* (): MsoControlType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874920) END Type; PROCEDURE (this: _CommandBarActiveX) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874921) END Visible; PROCEDURE (this: _CommandBarActiveX) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610874921, p1) END PUTVisible; PROCEDURE (this: _CommandBarActiveX) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610874923) END Width; PROCEDURE (this: _CommandBarActiveX) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610874923, p1) END PUTWidth; PROCEDURE (this: _CommandBarActiveX) IsPriorityDropped* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610874925) END IsPriorityDropped; PROCEDURE (this: _CommandBarActiveX) Reserved1* (), NEW; BEGIN CtlC.CallMethod(this, 1610874926, NIL); END Reserved1; PROCEDURE (this: _CommandBarActiveX) Reserved2* (), NEW; BEGIN CtlC.CallMethod(this, 1610874927, NIL); END Reserved2; PROCEDURE (this: _CommandBarActiveX) Reserved3* (), NEW; BEGIN CtlC.CallMethod(this, 1610874928, NIL); END Reserved3; PROCEDURE (this: _CommandBarActiveX) Reserved4* (), NEW; BEGIN CtlC.CallMethod(this, 1610874929, NIL); END Reserved4; PROCEDURE (this: _CommandBarActiveX) Reserved5* (), NEW; BEGIN CtlC.CallMethod(this, 1610874930, NIL); END Reserved5; PROCEDURE (this: _CommandBarActiveX) Reserved6* (), NEW; BEGIN CtlC.CallMethod(this, 1610874931, NIL); END Reserved6; PROCEDURE (this: _CommandBarActiveX) Reserved7* (), NEW; BEGIN CtlC.CallMethod(this, 1610874932, NIL); END Reserved7; PROCEDURE (this: _CommandBarActiveX) ControlCLSID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610940416) END ControlCLSID; PROCEDURE (this: _CommandBarActiveX) PUTControlCLSID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610940416, p1) END PUTControlCLSID; PROCEDURE (this: _CommandBarActiveX) QueryControlInterface* (bstrIid: ARRAY OF CHAR): CtlT.IUnknown, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(bstrIid, arg[0]); CtlC.CallGetMethod(this, 1610940418, arg, ret); RETURN CtlC.VarIntfce(ret) END QueryControlInterface; PROCEDURE (this: _CommandBarActiveX) SetInnerObjectFactory* (pUnk: CtlT.IUnknown), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntfceVar(pUnk, arg[0]); CtlC.CallParMethod(this, 1610940419, arg, NIL); END SetInnerObjectFactory; PROCEDURE (this: _CommandBarActiveX) EnsureControl* (), NEW; BEGIN CtlC.CallMethod(this, 1610940420, NIL); END EnsureControl; PROCEDURE (this: _CommandBarActiveX) PUTInitWith* (p1: CtlT.IUnknown), NEW; BEGIN CtlC.PutIntfce(this, 1610940421, p1) END PUTInitWith; (* ---------- Adjustments, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Adjustments) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Adjustments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Adjustments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Adjustments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Adjustments) Item* (Index: INTEGER): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarSReal(ret) END Item; PROCEDURE (this: Adjustments) PUTItem* (Index: INTEGER; p2: SHORTREAL), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.SRealVar(p2, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUTItem; (* ---------- CalloutFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: CalloutFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: CalloutFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: CalloutFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: CalloutFormat) AutomaticLength* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END AutomaticLength; PROCEDURE (this: CalloutFormat) CustomDrop* (Drop: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Drop, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END CustomDrop; PROCEDURE (this: CalloutFormat) CustomLength* (Length: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Length, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END CustomLength; PROCEDURE (this: CalloutFormat) PresetDrop* (DropType: MsoCalloutDropType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(DropType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetDrop; PROCEDURE (this: CalloutFormat) Accent* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Accent; PROCEDURE (this: CalloutFormat) PUTAccent* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAccent; PROCEDURE (this: CalloutFormat) Angle* (): MsoCalloutAngleType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Angle; PROCEDURE (this: CalloutFormat) PUTAngle* (p1: MsoCalloutAngleType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAngle; PROCEDURE (this: CalloutFormat) AutoAttach* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END AutoAttach; PROCEDURE (this: CalloutFormat) PUTAutoAttach* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTAutoAttach; PROCEDURE (this: CalloutFormat) AutoLength* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END AutoLength; PROCEDURE (this: CalloutFormat) Border* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Border; PROCEDURE (this: CalloutFormat) PUTBorder* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTBorder; PROCEDURE (this: CalloutFormat) Drop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END Drop; PROCEDURE (this: CalloutFormat) DropType* (): MsoCalloutDropType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END DropType; PROCEDURE (this: CalloutFormat) Gap* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END Gap; PROCEDURE (this: CalloutFormat) PUTGap* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTGap; PROCEDURE (this: CalloutFormat) Length* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END Length; PROCEDURE (this: CalloutFormat) Type* (): MsoCalloutType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Type; PROCEDURE (this: CalloutFormat) PUTType* (p1: MsoCalloutType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTType; (* ---------- ColorFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ColorFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ColorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ColorFormat) RGB* (): MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END RGB; PROCEDURE (this: ColorFormat) PUTRGB* (p1: MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTRGB; PROCEDURE (this: ColorFormat) SchemeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END SchemeColor; PROCEDURE (this: ColorFormat) PUTSchemeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTSchemeColor; PROCEDURE (this: ColorFormat) Type* (): MsoColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Type; (* ---------- ConnectorFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ConnectorFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ConnectorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ConnectorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ConnectorFormat) BeginConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END BeginConnect; PROCEDURE (this: ConnectorFormat) BeginDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END BeginDisconnect; PROCEDURE (this: ConnectorFormat) EndConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END EndConnect; PROCEDURE (this: ConnectorFormat) EndDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 13, NIL); END EndDisconnect; PROCEDURE (this: ConnectorFormat) BeginConnected* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END BeginConnected; PROCEDURE (this: ConnectorFormat) BeginConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 101)) END BeginConnectedShape; PROCEDURE (this: ConnectorFormat) BeginConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginConnectionSite; PROCEDURE (this: ConnectorFormat) EndConnected* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END EndConnected; PROCEDURE (this: ConnectorFormat) EndConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 104)) END EndConnectedShape; PROCEDURE (this: ConnectorFormat) EndConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndConnectionSite; PROCEDURE (this: ConnectorFormat) Type* (): MsoConnectorType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Type; PROCEDURE (this: ConnectorFormat) PUTType* (p1: MsoConnectorType), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTType; (* ---------- FillFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FillFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: FillFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: FillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FillFormat) Background* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Background; PROCEDURE (this: FillFormat) OneColorGradient* (Style: MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END OneColorGradient; PROCEDURE (this: FillFormat) Patterned* (Pattern: MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Patterned; PROCEDURE (this: FillFormat) PresetGradient* (Style: MsoGradientStyle; Variant: INTEGER; PresetGradientType: MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetGradient; PROCEDURE (this: FillFormat) PresetTextured* (PresetTexture: MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END PresetTextured; PROCEDURE (this: FillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 15, NIL); END Solid; PROCEDURE (this: FillFormat) TwoColorGradient* (Style: MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END TwoColorGradient; PROCEDURE (this: FillFormat) UserPicture* (PictureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PictureFile, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END UserPicture; PROCEDURE (this: FillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END UserTextured; PROCEDURE (this: FillFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: FillFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: FillFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ForeColor; PROCEDURE (this: FillFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 101, p1) END PUTForeColor; PROCEDURE (this: FillFormat) GradientColorType* (): MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END GradientColorType; PROCEDURE (this: FillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END GradientDegree; PROCEDURE (this: FillFormat) GradientStyle* (): MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END GradientStyle; PROCEDURE (this: FillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END GradientVariant; PROCEDURE (this: FillFormat) Pattern* (): MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Pattern; PROCEDURE (this: FillFormat) PresetGradientType* (): MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetGradientType; PROCEDURE (this: FillFormat) PresetTexture* (): MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTexture; PROCEDURE (this: FillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END TextureName; PROCEDURE (this: FillFormat) TextureType* (): MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END TextureType; PROCEDURE (this: FillFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: FillFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: FillFormat) Type* (): MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Type; PROCEDURE (this: FillFormat) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Visible; PROCEDURE (this: FillFormat) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTVisible; (* ---------- FreeformBuilder, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FreeformBuilder) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: FreeformBuilder) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: FreeformBuilder) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FreeformBuilder) AddNodes* (SegmentType: MsoSegmentType; EditingType: MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END AddNodes; PROCEDURE (this: FreeformBuilder) ConvertToShape* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 11, ret); RETURN ThisShape(CtlC.VarAny(ret)) END ConvertToShape; (* ---------- GroupShapes, hidden, dual, nonextensible ---------- *) PROCEDURE (this: GroupShapes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: GroupShapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: GroupShapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: GroupShapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: GroupShapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: GroupShapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- LineFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: LineFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: LineFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: LineFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: LineFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: LineFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: LineFormat) BeginArrowheadLength* (): MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END BeginArrowheadLength; PROCEDURE (this: LineFormat) PUTBeginArrowheadLength* (p1: MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTBeginArrowheadLength; PROCEDURE (this: LineFormat) BeginArrowheadStyle* (): MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginArrowheadStyle; PROCEDURE (this: LineFormat) PUTBeginArrowheadStyle* (p1: MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBeginArrowheadStyle; PROCEDURE (this: LineFormat) BeginArrowheadWidth* (): MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END BeginArrowheadWidth; PROCEDURE (this: LineFormat) PUTBeginArrowheadWidth* (p1: MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTBeginArrowheadWidth; PROCEDURE (this: LineFormat) DashStyle* (): MsoLineDashStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END DashStyle; PROCEDURE (this: LineFormat) PUTDashStyle* (p1: MsoLineDashStyle), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTDashStyle; PROCEDURE (this: LineFormat) EndArrowheadLength* (): MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndArrowheadLength; PROCEDURE (this: LineFormat) PUTEndArrowheadLength* (p1: MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTEndArrowheadLength; PROCEDURE (this: LineFormat) EndArrowheadStyle* (): MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END EndArrowheadStyle; PROCEDURE (this: LineFormat) PUTEndArrowheadStyle* (p1: MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTEndArrowheadStyle; PROCEDURE (this: LineFormat) EndArrowheadWidth* (): MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END EndArrowheadWidth; PROCEDURE (this: LineFormat) PUTEndArrowheadWidth* (p1: MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTEndArrowheadWidth; PROCEDURE (this: LineFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 108)) END ForeColor; PROCEDURE (this: LineFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 108, p1) END PUTForeColor; PROCEDURE (this: LineFormat) Pattern* (): MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Pattern; PROCEDURE (this: LineFormat) PUTPattern* (p1: MsoPatternType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTPattern; PROCEDURE (this: LineFormat) Style* (): MsoLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END Style; PROCEDURE (this: LineFormat) PUTStyle* (p1: MsoLineStyle), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTStyle; PROCEDURE (this: LineFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: LineFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: LineFormat) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Visible; PROCEDURE (this: LineFormat) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 112, p1) END PUTVisible; PROCEDURE (this: LineFormat) Weight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END Weight; PROCEDURE (this: LineFormat) PUTWeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTWeight; (* ---------- ShapeNode, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNode) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShapeNode) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShapeNode) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNode) EditingType* (): MsoEditingType, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EditingType; PROCEDURE (this: ShapeNode) Points* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Points; PROCEDURE (this: ShapeNode) SegmentType* (): MsoSegmentType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SegmentType; (* ---------- ShapeNodes, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNodes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShapeNodes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShapeNodes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNodes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeNodes) Item* (Index: CtlT.Any): ShapeNode, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShapeNode(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeNodes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeNodes) Delete* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Delete; PROCEDURE (this: ShapeNodes) Insert* (Index: INTEGER; SegmentType: MsoSegmentType; EditingType: MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[8]); CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Insert; PROCEDURE (this: ShapeNodes) SetEditingType* (Index: INTEGER; EditingType: MsoEditingType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(EditingType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetEditingType; PROCEDURE (this: ShapeNodes) SetPosition* (Index: INTEGER; X1: SHORTREAL; Y1: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetPosition; PROCEDURE (this: ShapeNodes) SetSegmentType* (Index: INTEGER; SegmentType: MsoSegmentType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(SegmentType, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END SetSegmentType; (* ---------- PictureFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PictureFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: PictureFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: PictureFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: PictureFormat) IncrementBrightness* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementBrightness; PROCEDURE (this: PictureFormat) IncrementContrast* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementContrast; PROCEDURE (this: PictureFormat) Brightness* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Brightness; PROCEDURE (this: PictureFormat) PUTBrightness* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTBrightness; PROCEDURE (this: PictureFormat) ColorType* (): MsoPictureColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END ColorType; PROCEDURE (this: PictureFormat) PUTColorType* (p1: MsoPictureColorType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTColorType; PROCEDURE (this: PictureFormat) Contrast* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Contrast; PROCEDURE (this: PictureFormat) PUTContrast* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTContrast; PROCEDURE (this: PictureFormat) CropBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END CropBottom; PROCEDURE (this: PictureFormat) PUTCropBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTCropBottom; PROCEDURE (this: PictureFormat) CropLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END CropLeft; PROCEDURE (this: PictureFormat) PUTCropLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTCropLeft; PROCEDURE (this: PictureFormat) CropRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END CropRight; PROCEDURE (this: PictureFormat) PUTCropRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTCropRight; PROCEDURE (this: PictureFormat) CropTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END CropTop; PROCEDURE (this: PictureFormat) PUTCropTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTCropTop; PROCEDURE (this: PictureFormat) TransparencyColor* (): MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END TransparencyColor; PROCEDURE (this: PictureFormat) PUTTransparencyColor* (p1: MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTTransparencyColor; PROCEDURE (this: PictureFormat) TransparentBackground* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END TransparentBackground; PROCEDURE (this: PictureFormat) PUTTransparentBackground* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTTransparentBackground; (* ---------- ShadowFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ShadowFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShadowFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShadowFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShadowFormat) IncrementOffsetX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementOffsetX; PROCEDURE (this: ShadowFormat) IncrementOffsetY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementOffsetY; PROCEDURE (this: ShadowFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END ForeColor; PROCEDURE (this: ShadowFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTForeColor; PROCEDURE (this: ShadowFormat) Obscured* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Obscured; PROCEDURE (this: ShadowFormat) PUTObscured* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTObscured; PROCEDURE (this: ShadowFormat) OffsetX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END OffsetX; PROCEDURE (this: ShadowFormat) PUTOffsetX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTOffsetX; PROCEDURE (this: ShadowFormat) OffsetY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END OffsetY; PROCEDURE (this: ShadowFormat) PUTOffsetY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTOffsetY; PROCEDURE (this: ShadowFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END Transparency; PROCEDURE (this: ShadowFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTTransparency; PROCEDURE (this: ShadowFormat) Type* (): MsoShadowType, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Type; PROCEDURE (this: ShadowFormat) PUTType* (p1: MsoShadowType), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTType; PROCEDURE (this: ShadowFormat) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Visible; PROCEDURE (this: ShadowFormat) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTVisible; (* ---------- Script, dual, nonextensible ---------- *) PROCEDURE (this: Script) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Script) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Script) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: Script) Extended* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Extended; PROCEDURE (this: Script) PUTExtended* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809345, p1) END PUTExtended; PROCEDURE (this: Script) Id* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END Id; PROCEDURE (this: Script) PUTId* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTId; PROCEDURE (this: Script) Language* (): MsoScriptLanguage, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END Language; PROCEDURE (this: Script) PUTLanguage* (p1: MsoScriptLanguage), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTLanguage; PROCEDURE (this: Script) Location* (): MsoScriptLocation, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809351) END Location; PROCEDURE (this: Script) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 1610809352, NIL); END Delete; PROCEDURE (this: Script) Shape* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809353) END Shape; PROCEDURE (this: Script) ScriptText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END ScriptText; PROCEDURE (this: Script) PUTScriptText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTScriptText; (* ---------- Scripts, dual, nonextensible ---------- *) PROCEDURE (this: Scripts) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Scripts) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Scripts) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: Scripts) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809345) END Count; PROCEDURE (this: Scripts) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Scripts) Item* (Index: CtlT.Any): Script, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisScript(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Scripts) Add* (Anchor: CtlT.Object; Location: MsoScriptLocation; Language: MsoScriptLanguage; Id: ARRAY OF CHAR; Extended: ARRAY OF CHAR; ScriptText: ARRAY OF CHAR): Script, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Anchor, arg[5]); CtlC.IntVar(Location, arg[4]); CtlC.IntVar(Language, arg[3]); CtlC.StrVar(Id, arg[2]); CtlC.StrVar(Extended, arg[1]); CtlC.StrVar(ScriptText, arg[0]); CtlC.CallParMethod(this, 1610809348, arg, ret); RETURN ThisScript(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Scripts) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 1610809349, NIL); END Delete; (* ---------- Shape, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Shape) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Shape) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Shape) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shape) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Apply; PROCEDURE (this: Shape) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; PROCEDURE (this: Shape) Duplicate* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 12, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: Shape) Flip* (FlipCmd: MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Flip; PROCEDURE (this: Shape) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END IncrementLeft; PROCEDURE (this: Shape) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END IncrementRotation; PROCEDURE (this: Shape) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementTop; PROCEDURE (this: Shape) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 17, NIL); END PickUp; PROCEDURE (this: Shape) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 18, NIL); END RerouteConnections; PROCEDURE (this: Shape) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: MsoTriState; fScale: MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 19, arg, NIL); END ScaleHeight; PROCEDURE (this: Shape) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: MsoTriState; fScale: MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 20, arg, NIL); END ScaleWidth; PROCEDURE (this: Shape) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 21, arg, NIL); END Select; PROCEDURE (this: Shape) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SetShapesDefaultProperties; PROCEDURE (this: Shape) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 23, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: Shape) ZOrder* (ZOrderCmd: MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ZOrder; PROCEDURE (this: Shape) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: Shape) AutoShapeType* (): MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: Shape) PUTAutoShapeType* (p1: MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: Shape) BlackWhiteMode* (): MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BlackWhiteMode; PROCEDURE (this: Shape) PUTBlackWhiteMode* (p1: MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBlackWhiteMode; PROCEDURE (this: Shape) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: Shape) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: Shape) Connector* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: Shape) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: Shape) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: Shape) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: Shape) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: Shape) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: Shape) HorizontalFlip* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: Shape) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: Shape) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: Shape) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: Shape) LockAspectRatio* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: Shape) PUTLockAspectRatio* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: Shape) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: Shape) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: Shape) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: Shape) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: Shape) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: Shape) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: Shape) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: Shape) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: Shape) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: Shape) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: Shape) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: Shape) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: Shape) Type* (): MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: Shape) VerticalFlip* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: Shape) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: Shape) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: Shape) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: Shape) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: Shape) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: Shape) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: Shape) Script* (): Script, NEW; BEGIN RETURN ThisScript(CtlC.GetAny(this, 130)) END Script; PROCEDURE (this: Shape) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: Shape) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; (* ---------- ShapeRange, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ShapeRange) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ShapeRange) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ShapeRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeRange) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeRange) Align* (AlignCmd: MsoAlignCmd; RelativeTo: MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(AlignCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END Align; PROCEDURE (this: ShapeRange) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Apply; PROCEDURE (this: ShapeRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END Delete; PROCEDURE (this: ShapeRange) Distribute* (DistributeCmd: MsoDistributeCmd; RelativeTo: MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(DistributeCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Distribute; PROCEDURE (this: ShapeRange) Duplicate* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 14, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: ShapeRange) Flip* (FlipCmd: MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END Flip; PROCEDURE (this: ShapeRange) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementLeft; PROCEDURE (this: ShapeRange) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END IncrementRotation; PROCEDURE (this: ShapeRange) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END IncrementTop; PROCEDURE (this: ShapeRange) Group* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 19, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ShapeRange) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 20, NIL); END PickUp; PROCEDURE (this: ShapeRange) Regroup* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 21, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Regroup; PROCEDURE (this: ShapeRange) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END RerouteConnections; PROCEDURE (this: ShapeRange) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: MsoTriState; fScale: MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 23, arg, NIL); END ScaleHeight; PROCEDURE (this: ShapeRange) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: MsoTriState; fScale: MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ScaleWidth; PROCEDURE (this: ShapeRange) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 25, arg, NIL); END Select; PROCEDURE (this: ShapeRange) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 26, NIL); END SetShapesDefaultProperties; PROCEDURE (this: ShapeRange) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 27, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: ShapeRange) ZOrder* (ZOrderCmd: MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 28, arg, NIL); END ZOrder; PROCEDURE (this: ShapeRange) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: ShapeRange) AutoShapeType* (): MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: ShapeRange) PUTAutoShapeType* (p1: MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: ShapeRange) BlackWhiteMode* (): MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BlackWhiteMode; PROCEDURE (this: ShapeRange) PUTBlackWhiteMode* (p1: MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBlackWhiteMode; PROCEDURE (this: ShapeRange) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: ShapeRange) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: ShapeRange) Connector* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: ShapeRange) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: ShapeRange) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: ShapeRange) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: ShapeRange) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: ShapeRange) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: ShapeRange) HorizontalFlip* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: ShapeRange) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: ShapeRange) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: ShapeRange) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: ShapeRange) LockAspectRatio* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: ShapeRange) PUTLockAspectRatio* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: ShapeRange) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: ShapeRange) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: ShapeRange) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: ShapeRange) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: ShapeRange) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: ShapeRange) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: ShapeRange) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: ShapeRange) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: ShapeRange) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: ShapeRange) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: ShapeRange) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: ShapeRange) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: ShapeRange) Type* (): MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: ShapeRange) VerticalFlip* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: ShapeRange) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: ShapeRange) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: ShapeRange) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: ShapeRange) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: ShapeRange) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: ShapeRange) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: ShapeRange) Script* (): Script, NEW; BEGIN RETURN ThisScript(CtlC.GetAny(this, 130)) END Script; PROCEDURE (this: ShapeRange) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: ShapeRange) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; (* ---------- Shapes, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Shapes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Shapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Shapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Shapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Shapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Shapes) AddCallout* (Type: MsoCalloutType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCallout; PROCEDURE (this: Shapes) AddConnector* (Type: MsoConnectorType; BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddConnector; PROCEDURE (this: Shapes) AddCurve* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCurve; PROCEDURE (this: Shapes) AddLabel* (Orientation: MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLabel; PROCEDURE (this: Shapes) AddLine* (BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLine; PROCEDURE (this: Shapes) AddPicture* (FileName: ARRAY OF CHAR; LinkToFile: MsoTriState; SaveWithDocument: MsoTriState; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[6]); CtlC.IntVar(LinkToFile, arg[5]); CtlC.IntVar(SaveWithDocument, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPicture; PROCEDURE (this: Shapes) AddPolyline* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPolyline; PROCEDURE (this: Shapes) AddShape* (Type: MsoAutoShapeType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 17, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddShape; PROCEDURE (this: Shapes) AddTextEffect* (PresetTextEffect: MsoPresetTextEffect; Text: ARRAY OF CHAR; FontName: ARRAY OF CHAR; FontSize: SHORTREAL; FontBold: MsoTriState; FontItalic: MsoTriState; Left: SHORTREAL; Top: SHORTREAL): Shape, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(PresetTextEffect, arg[7]); CtlC.StrVar(Text, arg[6]); CtlC.StrVar(FontName, arg[5]); CtlC.SRealVar(FontSize, arg[4]); CtlC.IntVar(FontBold, arg[3]); CtlC.IntVar(FontItalic, arg[2]); CtlC.SRealVar(Left, arg[1]); CtlC.SRealVar(Top, arg[0]); CtlC.CallParMethod(this, 18, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextEffect; PROCEDURE (this: Shapes) AddTextbox* (Orientation: MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextbox; PROCEDURE (this: Shapes) BuildFreeform* (EditingType: MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL): FreeformBuilder, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(EditingType, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 20, arg, ret); RETURN ThisFreeformBuilder(CtlC.VarAny(ret)) END BuildFreeform; PROCEDURE (this: Shapes) Range* (Index: CtlT.Any): ShapeRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 21, arg, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Shapes) SelectAll* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SelectAll; PROCEDURE (this: Shapes) Background* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 100)) END Background; PROCEDURE (this: Shapes) Default* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 101)) END Default; (* ---------- TextEffectFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: TextEffectFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: TextEffectFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: TextEffectFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextEffectFormat) ToggleVerticalText* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END ToggleVerticalText; PROCEDURE (this: TextEffectFormat) Alignment* (): MsoTextEffectAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Alignment; PROCEDURE (this: TextEffectFormat) PUTAlignment* (p1: MsoTextEffectAlignment), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAlignment; PROCEDURE (this: TextEffectFormat) FontBold* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END FontBold; PROCEDURE (this: TextEffectFormat) PUTFontBold* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTFontBold; PROCEDURE (this: TextEffectFormat) FontItalic* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END FontItalic; PROCEDURE (this: TextEffectFormat) PUTFontItalic* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTFontItalic; PROCEDURE (this: TextEffectFormat) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END FontName; PROCEDURE (this: TextEffectFormat) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTFontName; PROCEDURE (this: TextEffectFormat) FontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END FontSize; PROCEDURE (this: TextEffectFormat) PUTFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTFontSize; PROCEDURE (this: TextEffectFormat) KernedPairs* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END KernedPairs; PROCEDURE (this: TextEffectFormat) PUTKernedPairs* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTKernedPairs; PROCEDURE (this: TextEffectFormat) NormalizedHeight* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END NormalizedHeight; PROCEDURE (this: TextEffectFormat) PUTNormalizedHeight* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTNormalizedHeight; PROCEDURE (this: TextEffectFormat) PresetShape* (): MsoPresetTextEffectShape, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetShape; PROCEDURE (this: TextEffectFormat) PUTPresetShape* (p1: MsoPresetTextEffectShape), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetShape; PROCEDURE (this: TextEffectFormat) PresetTextEffect* (): MsoPresetTextEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTextEffect; PROCEDURE (this: TextEffectFormat) PUTPresetTextEffect* (p1: MsoPresetTextEffect), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTPresetTextEffect; PROCEDURE (this: TextEffectFormat) RotatedChars* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END RotatedChars; PROCEDURE (this: TextEffectFormat) PUTRotatedChars* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTRotatedChars; PROCEDURE (this: TextEffectFormat) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Text; PROCEDURE (this: TextEffectFormat) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTText; PROCEDURE (this: TextEffectFormat) Tracking* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Tracking; PROCEDURE (this: TextEffectFormat) PUTTracking* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTracking; (* ---------- TextFrame, hidden, dual, nonextensible ---------- *) PROCEDURE (this: TextFrame) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: TextFrame) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: TextFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextFrame) MarginBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END MarginBottom; PROCEDURE (this: TextFrame) PUTMarginBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTMarginBottom; PROCEDURE (this: TextFrame) MarginLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 101) END MarginLeft; PROCEDURE (this: TextFrame) PUTMarginLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 101, p1) END PUTMarginLeft; PROCEDURE (this: TextFrame) MarginRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END MarginRight; PROCEDURE (this: TextFrame) PUTMarginRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTMarginRight; PROCEDURE (this: TextFrame) MarginTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END MarginTop; PROCEDURE (this: TextFrame) PUTMarginTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTMarginTop; PROCEDURE (this: TextFrame) Orientation* (): MsoTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Orientation; PROCEDURE (this: TextFrame) PUTOrientation* (p1: MsoTextOrientation), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTOrientation; (* ---------- ThreeDFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ThreeDFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: ThreeDFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: ThreeDFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ThreeDFormat) IncrementRotationX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementRotationX; PROCEDURE (this: ThreeDFormat) IncrementRotationY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementRotationY; PROCEDURE (this: ThreeDFormat) ResetRotation* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END ResetRotation; PROCEDURE (this: ThreeDFormat) SetThreeDFormat* (PresetThreeDFormat: MsoPresetThreeDFormat), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetThreeDFormat, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetThreeDFormat; PROCEDURE (this: ThreeDFormat) SetExtrusionDirection* (PresetExtrusionDirection: MsoPresetExtrusionDirection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetExtrusionDirection, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetExtrusionDirection; PROCEDURE (this: ThreeDFormat) Depth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Depth; PROCEDURE (this: ThreeDFormat) PUTDepth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTDepth; PROCEDURE (this: ThreeDFormat) ExtrusionColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ExtrusionColor; PROCEDURE (this: ThreeDFormat) ExtrusionColorType* (): MsoExtrusionColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END ExtrusionColorType; PROCEDURE (this: ThreeDFormat) PUTExtrusionColorType* (p1: MsoExtrusionColorType), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTExtrusionColorType; PROCEDURE (this: ThreeDFormat) Perspective* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END Perspective; PROCEDURE (this: ThreeDFormat) PUTPerspective* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTPerspective; PROCEDURE (this: ThreeDFormat) PresetExtrusionDirection* (): MsoPresetExtrusionDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PresetExtrusionDirection; PROCEDURE (this: ThreeDFormat) PresetLightingDirection* (): MsoPresetLightingDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END PresetLightingDirection; PROCEDURE (this: ThreeDFormat) PUTPresetLightingDirection* (p1: MsoPresetLightingDirection), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTPresetLightingDirection; PROCEDURE (this: ThreeDFormat) PresetLightingSoftness* (): MsoPresetLightingSoftness, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END PresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PUTPresetLightingSoftness* (p1: MsoPresetLightingSoftness), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTPresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PresetMaterial* (): MsoPresetMaterial, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetMaterial; PROCEDURE (this: ThreeDFormat) PUTPresetMaterial* (p1: MsoPresetMaterial), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetMaterial; PROCEDURE (this: ThreeDFormat) PresetThreeDFormat* (): MsoPresetThreeDFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetThreeDFormat; PROCEDURE (this: ThreeDFormat) RotationX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END RotationX; PROCEDURE (this: ThreeDFormat) PUTRotationX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTRotationX; PROCEDURE (this: ThreeDFormat) RotationY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 110) END RotationY; PROCEDURE (this: ThreeDFormat) PUTRotationY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 110, p1) END PUTRotationY; PROCEDURE (this: ThreeDFormat) Visible* (): MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END Visible; PROCEDURE (this: ThreeDFormat) PUTVisible* (p1: MsoTriState), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTVisible; (* ---------- IMsoDispCagNotifySink, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IMsoDispCagNotifySink) InsertClip* (pClipMoniker: CtlT.IUnknown; pItemMoniker: CtlT.IUnknown), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntfceVar(pClipMoniker, arg[1]); CtlC.IntfceVar(pItemMoniker, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); END InsertClip; PROCEDURE (this: IMsoDispCagNotifySink) WindowIsClosing* (), NEW; BEGIN CtlC.CallMethod(this, 2, NIL); END WindowIsClosing; (* ---------- Balloon, dual, nonextensible ---------- *) PROCEDURE (this: Balloon) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Balloon) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Balloon) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: Balloon) Checkboxes* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809345) END Checkboxes; PROCEDURE (this: Balloon) Labels* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809346) END Labels; PROCEDURE (this: Balloon) PUTBalloonType* (p1: MsoBalloonType), NEW; BEGIN CtlC.PutInt(this, 1610809347, p1) END PUTBalloonType; PROCEDURE (this: Balloon) BalloonType* (): MsoBalloonType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809347) END BalloonType; PROCEDURE (this: Balloon) PUTIcon* (p1: MsoIconType), NEW; BEGIN CtlC.PutInt(this, 1610809349, p1) END PUTIcon; PROCEDURE (this: Balloon) Icon* (): MsoIconType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809349) END Icon; PROCEDURE (this: Balloon) PUTHeading* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809351, p1) END PUTHeading; PROCEDURE (this: Balloon) Heading* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809351) END Heading; PROCEDURE (this: Balloon) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809353, p1) END PUTText; PROCEDURE (this: Balloon) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809353) END Text; PROCEDURE (this: Balloon) PUTMode* (p1: MsoModeType), NEW; BEGIN CtlC.PutInt(this, 1610809355, p1) END PUTMode; PROCEDURE (this: Balloon) Mode* (): MsoModeType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809355) END Mode; PROCEDURE (this: Balloon) PUTAnimation* (p1: MsoAnimationType), NEW; BEGIN CtlC.PutInt(this, 1610809357, p1) END PUTAnimation; PROCEDURE (this: Balloon) Animation* (): MsoAnimationType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809357) END Animation; PROCEDURE (this: Balloon) PUTButton* (p1: MsoButtonSetType), NEW; BEGIN CtlC.PutInt(this, 1610809359, p1) END PUTButton; PROCEDURE (this: Balloon) Button* (): MsoButtonSetType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809359) END Button; PROCEDURE (this: Balloon) PUTCallback* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809361, p1) END PUTCallback; PROCEDURE (this: Balloon) Callback* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809361) END Callback; PROCEDURE (this: Balloon) PUTPrivate* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809363, p1) END PUTPrivate; PROCEDURE (this: Balloon) Private* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809363) END Private; PROCEDURE (this: Balloon) SetAvoidRectangle* (Left: INTEGER; Top: INTEGER; Right: INTEGER; Bottom: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[3]); CtlC.IntVar(Top, arg[2]); CtlC.IntVar(Right, arg[1]); CtlC.IntVar(Bottom, arg[0]); CtlC.CallParMethod(this, 1610809365, arg, NIL); END SetAvoidRectangle; PROCEDURE (this: Balloon) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809366) END Name; PROCEDURE (this: Balloon) Show* (): MsoBalloonButtonType, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610809367, ret); RETURN CtlC.VarInt(ret) END Show; PROCEDURE (this: Balloon) Close* (), NEW; BEGIN CtlC.CallMethod(this, 1610809368, NIL); END Close; (* ---------- BalloonCheckboxes, dual, nonextensible ---------- *) PROCEDURE (this: BalloonCheckboxes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: BalloonCheckboxes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: BalloonCheckboxes) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: BalloonCheckboxes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809345) END Parent; PROCEDURE (this: BalloonCheckboxes) Item* (Index: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: BalloonCheckboxes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809347) END Count; PROCEDURE (this: BalloonCheckboxes) PUTCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809347, p1) END PUTCount; PROCEDURE (this: BalloonCheckboxes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- BalloonCheckbox, dual, nonextensible ---------- *) PROCEDURE (this: BalloonCheckbox) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: BalloonCheckbox) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: BalloonCheckbox) Item* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Item; PROCEDURE (this: BalloonCheckbox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Name; PROCEDURE (this: BalloonCheckbox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809346) END Parent; PROCEDURE (this: BalloonCheckbox) PUTChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809347, p1) END PUTChecked; PROCEDURE (this: BalloonCheckbox) Checked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809347) END Checked; PROCEDURE (this: BalloonCheckbox) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809349, p1) END PUTText; PROCEDURE (this: BalloonCheckbox) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809349) END Text; (* ---------- BalloonLabels, dual, nonextensible ---------- *) PROCEDURE (this: BalloonLabels) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: BalloonLabels) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: BalloonLabels) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809344) END Name; PROCEDURE (this: BalloonLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809345) END Parent; PROCEDURE (this: BalloonLabels) Item* (Index: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: BalloonLabels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809347) END Count; PROCEDURE (this: BalloonLabels) PUTCount* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809347, p1) END PUTCount; PROCEDURE (this: BalloonLabels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- BalloonLabel, dual, nonextensible ---------- *) PROCEDURE (this: BalloonLabel) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: BalloonLabel) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: BalloonLabel) Item* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Item; PROCEDURE (this: BalloonLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809345) END Name; PROCEDURE (this: BalloonLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809346) END Parent; PROCEDURE (this: BalloonLabel) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809347, p1) END PUTText; PROCEDURE (this: BalloonLabel) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809347) END Text; (* ---------- AnswerWizardFiles, dual, nonextensible ---------- *) PROCEDURE (this: AnswerWizardFiles) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: AnswerWizardFiles) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: AnswerWizardFiles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: AnswerWizardFiles) Item* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: AnswerWizardFiles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809346) END Count; PROCEDURE (this: AnswerWizardFiles) Add* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610809347, arg, NIL); END Add; PROCEDURE (this: AnswerWizardFiles) Delete* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610809348, arg, NIL); END Delete; (* ---------- AnswerWizard, dual, nonextensible ---------- *) PROCEDURE (this: AnswerWizard) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: AnswerWizard) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: AnswerWizard) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: AnswerWizard) Files* (): AnswerWizardFiles, NEW; BEGIN RETURN ThisAnswerWizardFiles(CtlC.GetAny(this, 1610809345)) END Files; PROCEDURE (this: AnswerWizard) ClearFileList* (), NEW; BEGIN CtlC.CallMethod(this, 1610809346, NIL); END ClearFileList; PROCEDURE (this: AnswerWizard) ResetFileList* (), NEW; BEGIN CtlC.CallMethod(this, 1610809347, NIL); END ResetFileList; (* ---------- Assistant, dual, nonextensible ---------- *) PROCEDURE (this: Assistant) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: Assistant) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: Assistant) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610809344) END Parent; PROCEDURE (this: Assistant) Move* (xLeft: INTEGER; yTop: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(xLeft, arg[1]); CtlC.IntVar(yTop, arg[0]); CtlC.CallParMethod(this, 1610809345, arg, NIL); END Move; PROCEDURE (this: Assistant) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809346, p1) END PUTTop; PROCEDURE (this: Assistant) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809346) END Top; PROCEDURE (this: Assistant) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610809348, p1) END PUTLeft; PROCEDURE (this: Assistant) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809348) END Left; PROCEDURE (this: Assistant) Help* (), NEW; BEGIN CtlC.CallMethod(this, 1610809350, NIL); END Help; PROCEDURE (this: Assistant) StartWizard* (On: BOOLEAN; Callback: ARRAY OF CHAR; PrivateX: INTEGER; (* optional *) Animation: CtlT.Any; CustomTeaser: CtlT.Any; Top: CtlT.Any; Left: CtlT.Any; Bottom: CtlT.Any; Right: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(On, arg[8]); CtlC.StrVar(Callback, arg[7]); CtlC.IntVar(PrivateX, arg[6]); CtlC.AnyVar(Animation, arg[5]); CtlC.AnyVar(CustomTeaser, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Left, arg[2]); CtlC.AnyVar(Bottom, arg[1]); CtlC.AnyVar(Right, arg[0]); CtlC.CallParMethod(this, 1610809351, arg, ret); RETURN CtlC.VarInt(ret) END StartWizard; PROCEDURE (this: Assistant) EndWizard* (WizardID: INTEGER; varfSuccess: BOOLEAN; (* optional *) Animation: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(WizardID, arg[2]); CtlC.BoolVar(varfSuccess, arg[1]); CtlC.AnyVar(Animation, arg[0]); CtlC.CallParMethod(this, 1610809352, arg, NIL); END EndWizard; PROCEDURE (this: Assistant) ActivateWizard* (WizardID: INTEGER; act: MsoWizardActType; (* optional *) Animation: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(WizardID, arg[2]); CtlC.IntVar(act, arg[1]); CtlC.AnyVar(Animation, arg[0]); CtlC.CallParMethod(this, 1610809353, arg, NIL); END ActivateWizard; PROCEDURE (this: Assistant) ResetTips* (), NEW; BEGIN CtlC.CallMethod(this, 1610809354, NIL); END ResetTips; PROCEDURE (this: Assistant) NewBalloon* (): Balloon, NEW; BEGIN RETURN ThisBalloon(CtlC.GetAny(this, 1610809355)) END NewBalloon; PROCEDURE (this: Assistant) BalloonError* (): MsoBalloonErrorType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809356) END BalloonError; PROCEDURE (this: Assistant) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809357) END Visible; PROCEDURE (this: Assistant) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809357, p1) END PUTVisible; PROCEDURE (this: Assistant) Animation* (): MsoAnimationType, NEW; BEGIN RETURN CtlC.GetInt(this, 1610809359) END Animation; PROCEDURE (this: Assistant) PUTAnimation* (p1: MsoAnimationType), NEW; BEGIN CtlC.PutInt(this, 1610809359, p1) END PUTAnimation; PROCEDURE (this: Assistant) Reduced* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809361) END Reduced; PROCEDURE (this: Assistant) PUTReduced* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809361, p1) END PUTReduced; PROCEDURE (this: Assistant) PUTAssistWithHelp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809363, p1) END PUTAssistWithHelp; PROCEDURE (this: Assistant) AssistWithHelp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809363) END AssistWithHelp; PROCEDURE (this: Assistant) PUTAssistWithWizards* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809365, p1) END PUTAssistWithWizards; PROCEDURE (this: Assistant) AssistWithWizards* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809365) END AssistWithWizards; PROCEDURE (this: Assistant) PUTAssistWithAlerts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809367, p1) END PUTAssistWithAlerts; PROCEDURE (this: Assistant) AssistWithAlerts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809367) END AssistWithAlerts; PROCEDURE (this: Assistant) PUTMoveWhenInTheWay* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809369, p1) END PUTMoveWhenInTheWay; PROCEDURE (this: Assistant) MoveWhenInTheWay* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809369) END MoveWhenInTheWay; PROCEDURE (this: Assistant) PUTSounds* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809371, p1) END PUTSounds; PROCEDURE (this: Assistant) Sounds* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809371) END Sounds; PROCEDURE (this: Assistant) PUTFeatureTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809373, p1) END PUTFeatureTips; PROCEDURE (this: Assistant) FeatureTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809373) END FeatureTips; PROCEDURE (this: Assistant) PUTMouseTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809375, p1) END PUTMouseTips; PROCEDURE (this: Assistant) MouseTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809375) END MouseTips; PROCEDURE (this: Assistant) PUTKeyboardShortcutTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809377, p1) END PUTKeyboardShortcutTips; PROCEDURE (this: Assistant) KeyboardShortcutTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809377) END KeyboardShortcutTips; PROCEDURE (this: Assistant) PUTHighPriorityTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809379, p1) END PUTHighPriorityTips; PROCEDURE (this: Assistant) HighPriorityTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809379) END HighPriorityTips; PROCEDURE (this: Assistant) PUTTipOfDay* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809381, p1) END PUTTipOfDay; PROCEDURE (this: Assistant) TipOfDay* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809381) END TipOfDay; PROCEDURE (this: Assistant) PUTGuessHelp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809383, p1) END PUTGuessHelp; PROCEDURE (this: Assistant) GuessHelp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809383) END GuessHelp; PROCEDURE (this: Assistant) PUTSearchWhenProgramming* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809385, p1) END PUTSearchWhenProgramming; PROCEDURE (this: Assistant) SearchWhenProgramming* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809385) END SearchWhenProgramming; PROCEDURE (this: Assistant) Item* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Item; PROCEDURE (this: Assistant) FileName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809388) END FileName; PROCEDURE (this: Assistant) PUTFileName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610809388, p1) END PUTFileName; PROCEDURE (this: Assistant) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610809390) END Name; PROCEDURE (this: Assistant) On* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610809391) END On; PROCEDURE (this: Assistant) PUTOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610809391, p1) END PUTOn; (* ---------- IFoundFiles, dual, nonextensible ---------- *) PROCEDURE (this: IFoundFiles) Item* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: IFoundFiles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Count; PROCEDURE (this: IFoundFiles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- IFind, dual, nonextensible ---------- *) PROCEDURE (this: IFind) SearchPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END SearchPath; PROCEDURE (this: IFind) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Name; PROCEDURE (this: IFind) SubDir* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743810) END SubDir; PROCEDURE (this: IFind) Title* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743811) END Title; PROCEDURE (this: IFind) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743812) END Author; PROCEDURE (this: IFind) Keywords* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743813) END Keywords; PROCEDURE (this: IFind) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743814) END Subject; PROCEDURE (this: IFind) Options* (): MsoFileFindOptions, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743815) END Options; PROCEDURE (this: IFind) MatchCase* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743816) END MatchCase; PROCEDURE (this: IFind) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743817) END Text; PROCEDURE (this: IFind) PatternMatch* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743818) END PatternMatch; PROCEDURE (this: IFind) DateSavedFrom* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610743819) END DateSavedFrom; PROCEDURE (this: IFind) DateSavedTo* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610743820) END DateSavedTo; PROCEDURE (this: IFind) SavedBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743821) END SavedBy; PROCEDURE (this: IFind) DateCreatedFrom* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610743822) END DateCreatedFrom; PROCEDURE (this: IFind) DateCreatedTo* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610743823) END DateCreatedTo; PROCEDURE (this: IFind) View* (): MsoFileFindView, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743824) END View; PROCEDURE (this: IFind) SortBy* (): MsoFileFindSortBy, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743825) END SortBy; PROCEDURE (this: IFind) ListBy* (): MsoFileFindListBy, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743826) END ListBy; PROCEDURE (this: IFind) SelectedFile* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743827) END SelectedFile; PROCEDURE (this: IFind) Results* (): IFoundFiles, NEW; BEGIN RETURN ThisIFoundFiles(CtlC.GetAny(this, 1610743828)) END Results; PROCEDURE (this: IFind) Show* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 1610743829, ret); RETURN CtlC.VarInt(ret) END Show; PROCEDURE (this: IFind) PUTSearchPath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTSearchPath; PROCEDURE (this: IFind) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743809, p1) END PUTName; PROCEDURE (this: IFind) PUTSubDir* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743810, p1) END PUTSubDir; PROCEDURE (this: IFind) PUTTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743811, p1) END PUTTitle; PROCEDURE (this: IFind) PUTAuthor* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743812, p1) END PUTAuthor; PROCEDURE (this: IFind) PUTKeywords* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743813, p1) END PUTKeywords; PROCEDURE (this: IFind) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743814, p1) END PUTSubject; PROCEDURE (this: IFind) PUTOptions* (p1: MsoFileFindOptions), NEW; BEGIN CtlC.PutInt(this, 1610743815, p1) END PUTOptions; PROCEDURE (this: IFind) PUTMatchCase* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743816, p1) END PUTMatchCase; PROCEDURE (this: IFind) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743817, p1) END PUTText; PROCEDURE (this: IFind) PUTPatternMatch* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743818, p1) END PUTPatternMatch; PROCEDURE (this: IFind) PUTDateSavedFrom* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610743819, p1) END PUTDateSavedFrom; PROCEDURE (this: IFind) PUTDateSavedTo* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610743820, p1) END PUTDateSavedTo; PROCEDURE (this: IFind) PUTSavedBy* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743821, p1) END PUTSavedBy; PROCEDURE (this: IFind) PUTDateCreatedFrom* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610743822, p1) END PUTDateCreatedFrom; PROCEDURE (this: IFind) PUTDateCreatedTo* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610743823, p1) END PUTDateCreatedTo; PROCEDURE (this: IFind) PUTView* (p1: MsoFileFindView), NEW; BEGIN CtlC.PutInt(this, 1610743824, p1) END PUTView; PROCEDURE (this: IFind) PUTSortBy* (p1: MsoFileFindSortBy), NEW; BEGIN CtlC.PutInt(this, 1610743825, p1) END PUTSortBy; PROCEDURE (this: IFind) PUTListBy* (p1: MsoFileFindListBy), NEW; BEGIN CtlC.PutInt(this, 1610743826, p1) END PUTListBy; PROCEDURE (this: IFind) PUTSelectedFile* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610743827, p1) END PUTSelectedFile; PROCEDURE (this: IFind) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 1610743850, NIL); END Execute; PROCEDURE (this: IFind) Load* (bstrQueryName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrQueryName, arg[0]); CtlC.CallParMethod(this, 1610743851, arg, NIL); END Load; PROCEDURE (this: IFind) Save* (bstrQueryName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrQueryName, arg[0]); CtlC.CallParMethod(this, 1610743852, arg, NIL); END Save; PROCEDURE (this: IFind) Delete* (bstrQueryName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(bstrQueryName, arg[0]); CtlC.CallParMethod(this, 1610743853, arg, NIL); END Delete; PROCEDURE (this: IFind) FileType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743854) END FileType; PROCEDURE (this: IFind) PUTFileType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610743854, p1) END PUTFileType; (* ---------- FoundFiles, dual ---------- *) PROCEDURE (this: FoundFiles) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: FoundFiles) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: FoundFiles) Item* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: FoundFiles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Count; PROCEDURE (this: FoundFiles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- PropertyTest, dual, nonextensible ---------- *) PROCEDURE (this: PropertyTest) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: PropertyTest) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: PropertyTest) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: PropertyTest) Condition* (): MsoCondition, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Condition; PROCEDURE (this: PropertyTest) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 3) END Value; PROCEDURE (this: PropertyTest) SecondValue* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 4) END SecondValue; PROCEDURE (this: PropertyTest) Connector* (): MsoConnector, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Connector; (* ---------- PropertyTests, dual ---------- *) PROCEDURE (this: PropertyTests) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: PropertyTests) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: PropertyTests) Item* (Index: INTEGER): PropertyTest, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisPropertyTest(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PropertyTests) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Count; PROCEDURE (this: PropertyTests) Add* (Name: ARRAY OF CHAR; Condition: MsoCondition; Value: CtlT.Any; SecondValue: CtlT.Any; Connector: MsoConnector), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[4]); CtlC.IntVar(Condition, arg[3]); CtlC.AnyVar(Value, arg[2]); CtlC.AnyVar(SecondValue, arg[1]); CtlC.IntVar(Connector, arg[0]); CtlC.CallParMethod(this, 5, arg, NIL); END Add; PROCEDURE (this: PropertyTests) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 6, arg, NIL); END Remove; PROCEDURE (this: PropertyTests) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- FileSearch, dual ---------- *) PROCEDURE (this: FileSearch) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: FileSearch) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: FileSearch) SearchSubFolders* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END SearchSubFolders; PROCEDURE (this: FileSearch) PUTSearchSubFolders* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTSearchSubFolders; PROCEDURE (this: FileSearch) MatchTextExactly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END MatchTextExactly; PROCEDURE (this: FileSearch) PUTMatchTextExactly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTMatchTextExactly; PROCEDURE (this: FileSearch) MatchAllWordForms* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END MatchAllWordForms; PROCEDURE (this: FileSearch) PUTMatchAllWordForms* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTMatchAllWordForms; PROCEDURE (this: FileSearch) FileName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END FileName; PROCEDURE (this: FileSearch) PUTFileName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 4, p1) END PUTFileName; PROCEDURE (this: FileSearch) FileType* (): MsoFileType, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END FileType; PROCEDURE (this: FileSearch) PUTFileType* (p1: MsoFileType), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTFileType; PROCEDURE (this: FileSearch) LastModified* (): MsoLastModified, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END LastModified; PROCEDURE (this: FileSearch) PUTLastModified* (p1: MsoLastModified), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTLastModified; PROCEDURE (this: FileSearch) TextOrProperty* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END TextOrProperty; PROCEDURE (this: FileSearch) PUTTextOrProperty* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTTextOrProperty; PROCEDURE (this: FileSearch) LookIn* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END LookIn; PROCEDURE (this: FileSearch) PUTLookIn* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 8, p1) END PUTLookIn; PROCEDURE (this: FileSearch) Execute* (SortBy: MsoSortBy; SortOrder: MsoSortOrder; AlwaysAccurate: BOOLEAN): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SortBy, arg[2]); CtlC.IntVar(SortOrder, arg[1]); CtlC.BoolVar(AlwaysAccurate, arg[0]); CtlC.CallParMethod(this, 9, arg, ret); RETURN CtlC.VarInt(ret) END Execute; PROCEDURE (this: FileSearch) NewSearch* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END NewSearch; PROCEDURE (this: FileSearch) FoundFiles* (): FoundFiles, NEW; BEGIN RETURN ThisFoundFiles(CtlC.GetAny(this, 11)) END FoundFiles; PROCEDURE (this: FileSearch) PropertyTests* (): PropertyTests, NEW; BEGIN RETURN ThisPropertyTests(CtlC.GetAny(this, 12)) END PropertyTests; (* ---------- COMAddIn, dual, nonextensible ---------- *) PROCEDURE (this: COMAddIn) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: COMAddIn) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: COMAddIn) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Description; PROCEDURE (this: COMAddIn) PUTDescription* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTDescription; PROCEDURE (this: COMAddIn) ProgId* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END ProgId; PROCEDURE (this: COMAddIn) Guid* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Guid; PROCEDURE (this: COMAddIn) Connect* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Connect; PROCEDURE (this: COMAddIn) PUTConnect* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTConnect; PROCEDURE (this: COMAddIn) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 7) END Object; PROCEDURE (this: COMAddIn) PUTObject* (p1: CtlT.Object), NEW; BEGIN CtlC.PutObj(this, 7, p1) END PUTObject; PROCEDURE (this: COMAddIn) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8) END Parent; (* ---------- COMAddIns, dual, nonextensible ---------- *) PROCEDURE (this: COMAddIns) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: COMAddIns) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: COMAddIns) Item* (Index: CtlT.Any): COMAddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisCOMAddIn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: COMAddIns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: COMAddIns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: COMAddIns) Update* (), NEW; BEGIN CtlC.CallMethod(this, 2, NIL); END Update; PROCEDURE (this: COMAddIns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 3) END Parent; PROCEDURE (this: COMAddIns) SetAppModal* (varfModal: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(varfModal, arg[0]); CtlC.CallParMethod(this, 4, arg, NIL); END SetAppModal; (* ---------- LanguageSettings, dual, nonextensible ---------- *) PROCEDURE (this: LanguageSettings) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: LanguageSettings) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: LanguageSettings) LanguageID* (Id: MsoAppLanguageID): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Id, arg[0]); CtlC.CallGetMethod(this, 1, arg, ret); RETURN CtlC.VarInt(ret) END LanguageID; PROCEDURE (this: LanguageSettings) LanguagePreferredForEditing* (lid: MsoLanguageID): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(lid, arg[0]); CtlC.CallGetMethod(this, 2, arg, ret); RETURN CtlC.VarBool(ret) END LanguagePreferredForEditing; (* ---------- ICommandBarsEvents, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ICommandBarsEvents) OnUpdate* (), NEW; BEGIN CtlC.CallMethod(this, 1, NIL); END OnUpdate; (* ---------- _CommandBarsEvents, hidden ---------- *) PROCEDURE (this: _CommandBarsEvents) OnUpdate* (), NEW, ABSTRACT; PROCEDURE (this: _CommandBarsEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1: ASSERT(n = 0, 11); this.OnUpdate() END END Invoke; PROCEDURE (this: _CommandBarsEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000C0352-0000-0000-C000-000000000046}" END GetIID; (* ---------- ICommandBarComboBoxEvents, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ICommandBarComboBoxEvents) Change* (Ctrl: CommandBarComboBox), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Ctrl, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); END Change; (* ---------- _CommandBarComboBoxEvents, hidden ---------- *) PROCEDURE (this: _CommandBarComboBoxEvents) Change* (Ctrl: CommandBarComboBox), NEW, ABSTRACT; PROCEDURE (this: _CommandBarComboBoxEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1: ASSERT(n = 1, 11); this.Change(This_CommandBarComboBox(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: _CommandBarComboBoxEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000C0354-0000-0000-C000-000000000046}" END GetIID; (* ---------- ICommandBarButtonEvents, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ICommandBarButtonEvents) Click* (Ctrl: CommandBarButton; VAR CancelDefault: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; CancelDefault_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Ctrl, arg[1]); CtlC.BoolVar(CancelDefault, CancelDefault_TEMP); CtlC.RefBoolVar(CancelDefault_TEMP, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); CancelDefault := CtlC.VarBool(CancelDefault_TEMP); END Click; (* ---------- _CommandBarButtonEvents, hidden ---------- *) PROCEDURE (this: _CommandBarButtonEvents) Click* (Ctrl: CommandBarButton; VAR CancelDefault: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: _CommandBarButtonEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1: ASSERT(n = 2, 11); this.Click(This_CommandBarButton(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: _CommandBarButtonEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000C0351-0000-0000-C000-000000000046}" END GetIID; (* ---------- WebPageFont, dual, nonextensible ---------- *) PROCEDURE (this: WebPageFont) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: WebPageFont) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: WebPageFont) ProportionalFont* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END ProportionalFont; PROCEDURE (this: WebPageFont) PUTProportionalFont* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTProportionalFont; PROCEDURE (this: WebPageFont) ProportionalFontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 11) END ProportionalFontSize; PROCEDURE (this: WebPageFont) PUTProportionalFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 11, p1) END PUTProportionalFontSize; PROCEDURE (this: WebPageFont) FixedWidthFont* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END FixedWidthFont; PROCEDURE (this: WebPageFont) PUTFixedWidthFont* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12, p1) END PUTFixedWidthFont; PROCEDURE (this: WebPageFont) FixedWidthFontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 13) END FixedWidthFontSize; PROCEDURE (this: WebPageFont) PUTFixedWidthFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 13, p1) END PUTFixedWidthFontSize; (* ---------- WebPageFonts, dual, nonextensible ---------- *) PROCEDURE (this: WebPageFonts) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: WebPageFonts) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: WebPageFonts) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: WebPageFonts) Item* (Index: MsoCharacterSet): WebPageFont, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisWebPageFont(CtlC.VarAny(ret)) END Item; PROCEDURE (this: WebPageFonts) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- HTMLProjectItem, dual, nonextensible ---------- *) PROCEDURE (this: HTMLProjectItem) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: HTMLProjectItem) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: HTMLProjectItem) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: HTMLProjectItem) IsOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END IsOpen; PROCEDURE (this: HTMLProjectItem) LoadFromFile* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 5, arg, NIL); END LoadFromFile; PROCEDURE (this: HTMLProjectItem) Open* (OpenKind: MsoHTMLProjectOpen), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(OpenKind, arg[0]); CtlC.CallParMethod(this, 6, arg, NIL); END Open; PROCEDURE (this: HTMLProjectItem) SaveCopyAs* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 7, arg, NIL); END SaveCopyAs; PROCEDURE (this: HTMLProjectItem) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END Text; PROCEDURE (this: HTMLProjectItem) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 8, p1) END PUTText; PROCEDURE (this: HTMLProjectItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 10) END Parent; (* ---------- HTMLProjectItems, dual, nonextensible ---------- *) PROCEDURE (this: HTMLProjectItems) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: HTMLProjectItems) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: HTMLProjectItems) Item* (Index: CtlT.Any): HTMLProjectItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHTMLProjectItem(CtlC.VarAny(ret)) END Item; PROCEDURE (this: HTMLProjectItems) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: HTMLProjectItems) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HTMLProjectItems) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2) END Parent; (* ---------- HTMLProject, dual, nonextensible ---------- *) PROCEDURE (this: HTMLProject) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: HTMLProject) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: HTMLProject) State* (): MsoHTMLProjectState, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END State; PROCEDURE (this: HTMLProject) RefreshProject* (Refresh: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(Refresh, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); END RefreshProject; PROCEDURE (this: HTMLProject) RefreshDocument* (Refresh: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(Refresh, arg[0]); CtlC.CallParMethod(this, 2, arg, NIL); END RefreshDocument; PROCEDURE (this: HTMLProject) HTMLProjectItems* (): HTMLProjectItems, NEW; BEGIN RETURN ThisHTMLProjectItems(CtlC.GetAny(this, 3)) END HTMLProjectItems; PROCEDURE (this: HTMLProject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 4) END Parent; PROCEDURE (this: HTMLProject) Open* (OpenKind: MsoHTMLProjectOpen), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(OpenKind, arg[0]); CtlC.CallParMethod(this, 5, arg, NIL); END Open; (* ---------- MsoDebugOptions, hidden, dual, nonextensible ---------- *) PROCEDURE (this: MsoDebugOptions) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743808) END Application; PROCEDURE (this: MsoDebugOptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END Creator; PROCEDURE (this: MsoDebugOptions) FeatureReports* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END FeatureReports; PROCEDURE (this: MsoDebugOptions) PUTFeatureReports* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTFeatureReports; PROCEDURE NewCommandBars* (): _CommandBars; BEGIN RETURN This_CommandBars(CtlC.NewObj("{55F88893-7708-11D1-ACEB-006008961DA5}")) END NewCommandBars; PROCEDURE NewCommandBarComboBox* (): _CommandBarComboBox; BEGIN RETURN This_CommandBarComboBox(CtlC.NewObj("{55F88897-7708-11D1-ACEB-006008961DA5}")) END NewCommandBarComboBox; PROCEDURE NewCommandBarButton* (): _CommandBarButton; BEGIN RETURN This_CommandBarButton(CtlC.NewObj("{55F88891-7708-11D1-ACEB-006008961DA5}")) END NewCommandBarButton; END CtlOffice.

Ctl/Mod/Office.odc

MODULE CtlOfficeBinder; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Binder 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\vbabdr8.hlp, id: 30001 *) (* guid: {D0237635-6A9A-101B-B5A0-00AA004A2F7E}, lcid: 0, syskind: win32, version: 9.0 *) IMPORT CtlT, CtlC; CONST (* BindPrintWhat *) bindPrintActiveSection* = 1; bindPrintVisibleSections* = 2; bindPrintSelectedSections* = 3; bindPrintSectionSubset* = 4; (* BindPageSetupPrintWhat *) bindPageSetupVisibleSections* = 2; bindPageSetupSelectedSections* = 3; (* BindPrintNumbering *) bindConsecutivePages* = 1; bindRestartEachSection* = 2; (* BindSaveOption *) bindFailIfFileExists* = 1; bindOverwriteExisting* = 2; bindDisplayDialog* = 3; TYPE BindPrintWhat* = INTEGER; BindPageSetupPrintWhat* = INTEGER; BindPrintNumbering* = INTEGER; BindSaveOption* = INTEGER; _Binder* = POINTER TO RECORD (CtlT.Object) END; Section* = POINTER TO RECORD (CtlT.Object) END; Sections* = POINTER TO RECORD (CtlT.Object) END; PageSetup* = POINTER TO RECORD (CtlT.Object) END; Binder* = _Binder; PROCEDURE This_Binder* (v: CtlT.Any): _Binder; VAR new: _Binder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{D02375D0-6A9A-101B-B5A0-00AA004A2F7E}"); RETURN new ELSE RETURN NIL END END This_Binder; PROCEDURE Is_Binder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{D02375D0-6A9A-101B-B5A0-00AA004A2F7E}") END Is_Binder; PROCEDURE ThisSection* (v: CtlT.Any): Section; VAR new: Section; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{4E3B07C8-7F20-101B-B5BC-00AA004A2F7E}"); RETURN new ELSE RETURN NIL END END ThisSection; PROCEDURE IsSection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{4E3B07C8-7F20-101B-B5BC-00AA004A2F7E}") END IsSection; PROCEDURE ThisSections* (v: CtlT.Any): Sections; VAR new: Sections; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{E842DBF0-849F-101B-B5CB-00AA004A2F7E}"); RETURN new ELSE RETURN NIL END END ThisSections; PROCEDURE IsSections* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{E842DBF0-849F-101B-B5CB-00AA004A2F7E}") END IsSections; PROCEDURE ThisPageSetup* (v: CtlT.Any): PageSetup; VAR new: PageSetup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9F136940-E95C-11CE-9733-00AA00B8CD01}"); RETURN new ELSE RETURN NIL END END ThisPageSetup; PROCEDURE IsPageSetup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9F136940-E95C-11CE-9733-00AA00B8CD01}") END IsPageSetup; (* ---------- _Binder, dual ---------- *) PROCEDURE (this: _Binder) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _Binder) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743809) END Path; PROCEDURE (this: _Binder) ActiveSection* (): Section, NEW; BEGIN RETURN ThisSection(CtlC.GetAny(this, 1610743810)) END ActiveSection; PROCEDURE (this: _Binder) Sections* (): Sections, NEW; BEGIN RETURN ThisSections(CtlC.GetAny(this, 1610743811)) END Sections; PROCEDURE (this: _Binder) Open* (FileName: ARRAY OF CHAR; (* optional *) OpenAsTemplate: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[1]); CtlC.AnyVar(OpenAsTemplate, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, NIL); END Open; PROCEDURE (this: _Binder) Save* (), NEW; BEGIN CtlC.CallMethod(this, 1610743813, NIL); END Save; PROCEDURE (this: _Binder) SaveAs* (FileName: CtlT.Any; SaveOption: BindSaveOption): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[1]); CtlC.IntVar(SaveOption, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, ret); RETURN CtlC.VarBool(ret) END SaveAs; PROCEDURE (this: _Binder) PrintOut* (What: BindPrintWhat; Numbering: BindPrintNumbering; (* optional *) FirstPage: CtlT.Any; Sections: CtlT.Any; FileName: CtlT.Any; PrinterName: CtlT.Any; DriverName: CtlT.Any; NoPrinting: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(What, arg[7]); CtlC.IntVar(Numbering, arg[6]); CtlC.AnyVar(FirstPage, arg[5]); CtlC.AnyVar(Sections, arg[4]); CtlC.AnyVar(FileName, arg[3]); CtlC.AnyVar(PrinterName, arg[2]); CtlC.AnyVar(DriverName, arg[1]); CtlC.AnyVar(NoPrinting, arg[0]); CtlC.CallParMethod(this, 1610743815, arg, NIL); END PrintOut; PROCEDURE (this: _Binder) SelectedSectionNames* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1610743816) END SelectedSectionNames; PROCEDURE (this: _Binder) PUTSelectedSectionNames* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1610743816, p1) END PUTSelectedSectionNames; PROCEDURE (this: _Binder) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743818) END Visible; PROCEDURE (this: _Binder) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743818, p1) END PUTVisible; PROCEDURE (this: _Binder) LeftPane* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743820) END LeftPane; PROCEDURE (this: _Binder) PUTLeftPane* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743820, p1) END PUTLeftPane; PROCEDURE (this: _Binder) BuiltinDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743822) END BuiltinDocumentProperties; PROCEDURE (this: _Binder) CustomDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743823) END CustomDocumentProperties; PROCEDURE (this: _Binder) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1610743824)) END PageSetup; PROCEDURE (this: _Binder) DisplayStatusBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743825) END DisplayStatusBar; PROCEDURE (this: _Binder) PUTDisplayStatusBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743825, p1) END PUTDisplayStatusBar; PROCEDURE (this: _Binder) DisplayAlerts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743827) END DisplayAlerts; PROCEDURE (this: _Binder) PUTDisplayAlerts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743827, p1) END PUTDisplayAlerts; PROCEDURE (this: _Binder) DisplayLeftPaneAndButton* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743829) END DisplayLeftPaneAndButton; PROCEDURE (this: _Binder) PUTDisplayLeftPaneAndButton* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743829, p1) END PUTDisplayLeftPaneAndButton; PROCEDURE (this: _Binder) DefaultFilePath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743831) END DefaultFilePath; PROCEDURE (this: _Binder) PUTDefaultFilePath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743831, p1) END PUTDefaultFilePath; PROCEDURE (this: _Binder) SinglePrintJob* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743833) END SinglePrintJob; PROCEDURE (this: _Binder) PUTSinglePrintJob* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743833, p1) END PUTSinglePrintJob; PROCEDURE (this: _Binder) Close* ((* optional *) SaveChanges: CtlT.Any; FileName: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[1]); CtlC.AnyVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743835, arg, NIL); END Close; PROCEDURE (this: _Binder) ViewOpenMode* (), NEW; BEGIN CtlC.CallMethod(this, 1610743836, NIL); END ViewOpenMode; PROCEDURE (this: _Binder) ExitOpenMode* (), NEW; BEGIN CtlC.CallMethod(this, 1610743837, NIL); END ExitOpenMode; (* ---------- Section, dual ---------- *) PROCEDURE (this: Section) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 1610743808, NIL); END PrintOut; PROCEDURE (this: Section) Parent* (): _Binder, NEW; BEGIN RETURN This_Binder(CtlC.GetAny(this, 1610743809)) END Parent; PROCEDURE (this: Section) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 1610743810, NIL); END Delete; PROCEDURE (this: Section) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Index; PROCEDURE (this: Section) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743812) END Visible; PROCEDURE (this: Section) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743812, p1) END PUTVisible; PROCEDURE (this: Section) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Section) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: Section) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1610743816) END Object; PROCEDURE (this: Section) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 1610743817, NIL); END Activate; PROCEDURE (this: Section) Move* ((* optional *) Before: CtlT.Any; After: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 1610743818, arg, NIL); END Move; PROCEDURE (this: Section) Copy* ((* optional *) Before: CtlT.Any; After: CtlT.Any): Section, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 1610743819, arg, ret); RETURN ThisSection(CtlC.VarAny(ret)) END Copy; PROCEDURE (this: Section) SaveAs* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743820, arg, NIL); END SaveAs; PROCEDURE (this: Section) Type* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743821) END Type; PROCEDURE (this: Section) Update* (), NEW; BEGIN CtlC.CallMethod(this, 1610743822, NIL); END Update; PROCEDURE (this: Section) HasBinderHeaderFooter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743823) END HasBinderHeaderFooter; PROCEDURE (this: Section) PUTHasBinderHeaderFooter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1610743823, p1) END PUTHasBinderHeaderFooter; PROCEDURE (this: Section) SupportsBinderHeaderFooter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743825) END SupportsBinderHeaderFooter; (* ---------- Sections, dual ---------- *) PROCEDURE (this: Sections) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743808) END Count; PROCEDURE (this: Sections) Parent* (): _Binder, NEW; BEGIN RETURN This_Binder(CtlC.GetAny(this, 1610743809)) END Parent; PROCEDURE (this: Sections) Item* (Index: CtlT.Any): Section, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN ThisSection(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Sections) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Sections) Add* ((* optional *) Type: CtlT.Any; FileName: CtlT.Any; Before: CtlT.Any; After: CtlT.Any): Section, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[3]); CtlC.AnyVar(FileName, arg[2]); CtlC.AnyVar(Before, arg[1]); CtlC.AnyVar(After, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, ret); RETURN ThisSection(CtlC.VarAny(ret)) END Add; (* ---------- PageSetup, dual ---------- *) PROCEDURE (this: PageSetup) Parent* (): _Binder, NEW; BEGIN RETURN This_Binder(CtlC.GetAny(this, 1610743808)) END Parent; PROCEDURE (this: PageSetup) PrintWhat* (): BindPageSetupPrintWhat, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743809) END PrintWhat; PROCEDURE (this: PageSetup) PUTPrintWhat* (p1: BindPageSetupPrintWhat), NEW; BEGIN CtlC.PutInt(this, 1610743809, p1) END PUTPrintWhat; PROCEDURE (this: PageSetup) Numbering* (): BindPrintNumbering, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Numbering; PROCEDURE (this: PageSetup) PUTNumbering* (p1: BindPrintNumbering), NEW; BEGIN CtlC.PutInt(this, 1610743811, p1) END PUTNumbering; PROCEDURE (this: PageSetup) FirstPage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743813) END FirstPage; PROCEDURE (this: PageSetup) PUTFirstPage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610743813, p1) END PUTFirstPage; PROCEDURE (this: PageSetup) LeftHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743815) END LeftHeader; PROCEDURE (this: PageSetup) PUTLeftHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743815, p1) END PUTLeftHeader; PROCEDURE (this: PageSetup) CenterHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743817) END CenterHeader; PROCEDURE (this: PageSetup) PUTCenterHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743817, p1) END PUTCenterHeader; PROCEDURE (this: PageSetup) RightHeader* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743819) END RightHeader; PROCEDURE (this: PageSetup) PUTRightHeader* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743819, p1) END PUTRightHeader; PROCEDURE (this: PageSetup) LeftFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743821) END LeftFooter; PROCEDURE (this: PageSetup) PUTLeftFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743821, p1) END PUTLeftFooter; PROCEDURE (this: PageSetup) CenterFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743823) END CenterFooter; PROCEDURE (this: PageSetup) PUTCenterFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743823, p1) END PUTCenterFooter; PROCEDURE (this: PageSetup) RightFooter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743825) END RightFooter; PROCEDURE (this: PageSetup) PUTRightFooter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1610743825, p1) END PUTRightFooter; PROCEDURE NewBinder* (): _Binder; BEGIN RETURN This_Binder(CtlC.NewObj("{59850400-6664-101B-B21C-00AA004BA90B}")) END NewBinder; END CtlOfficeBinder.

Ctl/Mod/OfficeBinder.odc

MODULE CtlOutlook9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Outlook 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\VBAOUTL9.CHM, id: 5247608 *) (* guid: {00062FFF-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 9.0 *) IMPORT CtlT, CtlC, CtlOffice; CONST (* OlActionCopyLike *) olReply* = 0; olReplyAll* = 1; olForward* = 2; olReplyFolder* = 3; olRespond* = 4; (* OlActionReplyStyle *) olOmitOriginalText* = 0; olEmbedOriginalItem* = 1; olIncludeOriginalText* = 2; olIndentOriginalText* = 3; olLinkOriginalItem* = 4; olUserPreference* = 5; olReplyTickOriginalText* = 1000; (* OlActionResponseStyle *) olOpen* = 0; olSend* = 1; olPrompt* = 2; (* OlActionShowOn *) olDontShow* = 0; olMenu* = 1; olMenuAndToolbar* = 2; (* OlAttachmentType *) olByValue* = 1; olByReference* = 4; olEmbeddeditem* = 5; olOLE* = 6; (* OlBusyStatus *) olFree* = 0; olTentative* = 1; olBusy* = 2; olOutOfOffice* = 3; (* OlDaysOfWeek *) olSunday* = 1; olMonday* = 2; olTuesday* = 4; olWednesday* = 8; olThursday* = 16; olFriday* = 32; olSaturday* = 64; (* OlDefaultFolders *) olFolderDeletedItems* = 3; olFolderOutbox* = 4; olFolderSentMail* = 5; olFolderInbox* = 6; olFolderCalendar* = 9; olFolderContacts* = 10; olFolderJournal* = 11; olFolderNotes* = 12; olFolderTasks* = 13; olFolderDrafts* = 16; (* OlDisplayType *) olUser* = 0; olDistList* = 1; olForum* = 2; olAgent* = 3; olOrganization* = 4; olPrivateDistList* = 5; olRemoteUser* = 6; (* OlEditorType *) olEditorText* = 1; olEditorHTML* = 2; olEditorRTF* = 3; olEditorWord* = 4; (* OlFlagStatus *) olNoFlag* = 0; olFlagComplete* = 1; olFlagMarked* = 2; (* OlFolderDisplayMode *) olFolderDisplayNormal* = 0; olFolderDisplayFolderOnly* = 1; olFolderDisplayNoNavigation* = 2; (* OlFormRegistry *) olDefaultRegistry* = 0; olPersonalRegistry* = 2; olFolderRegistry* = 3; olOrganizationRegistry* = 4; (* OlGender *) olUnspecified* = 0; olFemale* = 1; olMale* = 2; (* OlImportance *) olImportanceLow* = 0; olImportanceNormal* = 1; olImportanceHigh* = 2; (* OlInspectorClose *) olSave* = 0; olDiscard* = 1; olPromptForSave* = 2; (* OlItemType *) olMailItem* = 0; olAppointmentItem* = 1; olContactItem* = 2; olTaskItem* = 3; olJournalItem* = 4; olNoteItem* = 5; olPostItem* = 6; olDistributionListItem* = 7; (* OlJournalRecipientType *) olAssociatedContact* = 1; (* OlMailingAddress *) olNone* = 0; olHome* = 1; olBusiness* = 2; olOther* = 3; (* OlMailRecipientType *) olOriginator* = 0; olTo* = 1; olCC* = 2; olBCC* = 3; (* OlMeetingRecipientType *) olOrganizer* = 0; olRequired* = 1; olOptional* = 2; olResource* = 3; (* OlMeetingResponse *) olMeetingTentative* = 2; olMeetingAccepted* = 3; olMeetingDeclined* = 4; (* OlMeetingStatus *) olNonMeeting* = 0; olMeeting* = 1; olMeetingReceived* = 3; olMeetingCanceled* = 5; (* OlNetMeetingType *) olNetMeeting* = 0; olNetShow* = 1; olChat* = 2; (* OlNoteColor *) olBlue* = 0; olGreen* = 1; olPink* = 2; olYellow* = 3; olWhite* = 4; (* OlObjectClass *) olApplication* = 0; olNamespace* = 1; olFolder* = 2; olRecipient* = 4; olAttachment* = 5; olAddressList* = 7; olAddressEntry* = 8; olFolders* = 15; olItems* = 16; olRecipients* = 17; olAttachments* = 18; olAddressLists* = 20; olAddressEntries* = 21; olAppointment* = 26; olMeetingRequest* = 53; olMeetingCancellation* = 54; olMeetingResponseNegative* = 55; olMeetingResponsePositive* = 56; olMeetingResponseTentative* = 57; olRecurrencePattern* = 28; olExceptions* = 29; olException* = 30; olAction* = 32; olActions* = 33; olExplorer* = 34; olInspector* = 35; olPages* = 36; olFormDescription* = 37; olUserProperties* = 38; olUserProperty* = 39; olContact* = 40; olDocument* = 41; olJournal* = 42; olMail* = 43; olNote* = 44; olPost* = 45; olReport* = 46; olRemote* = 47; olTask* = 48; olTaskRequest* = 49; olTaskRequestUpdate* = 50; olTaskRequestAccept* = 51; olTaskRequestDecline* = 52; olExplorers* = 60; olInspectors* = 61; olPanes* = 62; olOutlookBarPane* = 63; olOutlookBarStorage* = 64; olOutlookBarGroups* = 65; olOutlookBarGroup* = 66; olOutlookBarShortcuts* = 67; olOutlookBarShortcut* = 68; olDistributionList* = 69; olPropertyPageSite* = 70; olPropertyPages* = 71; olSyncObject* = 72; olSyncObjects* = 73; olSelection* = 74; olLink* = 75; olLinks* = 76; (* OlOutlookBarViewType *) olLargeIcon* = 0; olSmallIcon* = 1; (* OlPane *) olOutlookBar* = 1; olFolderList* = 2; olPreview* = 3; (* OlRecurrenceState *) olApptNotRecurring* = 0; olApptMaster* = 1; olApptOccurrence* = 2; olApptException* = 3; (* OlRecurrenceType *) olRecursDaily* = 0; olRecursWeekly* = 1; olRecursMonthly* = 2; olRecursMonthNth* = 3; olRecursYearly* = 5; olRecursYearNth* = 6; (* OlRemoteStatus *) olRemoteStatusNone* = 0; olUnMarked* = 1; olMarkedForDownload* = 2; olMarkedForCopy* = 3; olMarkedForDelete* = 4; (* OlResponseStatus *) olResponseNone* = 0; olResponseOrganized* = 1; olResponseTentative* = 2; olResponseAccepted* = 3; olResponseDeclined* = 4; olResponseNotResponded* = 5; (* OlSaveAsType *) olTXT* = 0; olRTF* = 1; olTemplate* = 2; olMSG* = 3; olDoc* = 4; olHTML* = 5; olVCard* = 6; olVCal* = 7; (* OlSensitivity *) olNormal* = 0; olPersonal* = 1; olPrivate* = 2; olConfidential* = 3; (* OlSortOrder *) olSortNone* = 0; olAscending* = 1; olDescending* = 2; (* OlTaskDelegationState *) olTaskNotDelegated* = 0; olTaskDelegationUnknown* = 1; olTaskDelegationAccepted* = 2; olTaskDelegationDeclined* = 3; (* OlTaskOwnership *) olNewTask* = 0; olDelegatedTask* = 1; olOwnTask* = 2; (* OlTaskRecipientType *) olUpdate* = 2; olFinalStatus* = 3; (* OlTaskResponse *) olTaskSimple* = 0; olTaskAssign* = 1; olTaskAccept* = 2; olTaskDecline* = 3; (* OlTaskStatus *) olTaskNotStarted* = 0; olTaskInProgress* = 1; olTaskComplete* = 2; olTaskWaiting* = 3; olTaskDeferred* = 4; (* OlTrackingStatus *) olTrackingNone* = 0; olTrackingDelivered* = 1; olTrackingNotDelivered* = 2; olTrackingNotRead* = 3; olTrackingRecallFailure* = 4; olTrackingRecallSuccess* = 5; olTrackingRead* = 6; olTrackingReplied* = 7; (* OlUserPropertyType *) olText* = 1; olNumber* = 3; olDateTime* = 5; olYesNo* = 6; olDuration* = 7; olKeywords* = 11; olPercent* = 12; olCurrency* = 14; olFormula* = 18; olCombination* = 19; (* OlWindowState *) olMaximized* = 0; olMinimized* = 1; olNormalWindow* = 2; (* OlSyncState *) olSyncStopped* = 0; olSyncStarted* = 1; TYPE OlActionCopyLike* = INTEGER; OlActionReplyStyle* = INTEGER; OlActionResponseStyle* = INTEGER; OlActionShowOn* = INTEGER; OlAttachmentType* = INTEGER; OlBusyStatus* = INTEGER; OlDaysOfWeek* = INTEGER; OlDefaultFolders* = INTEGER; OlDisplayType* = INTEGER; OlEditorType* = INTEGER; OlFlagStatus* = INTEGER; OlFolderDisplayMode* = INTEGER; OlFormRegistry* = INTEGER; OlGender* = INTEGER; OlImportance* = INTEGER; OlInspectorClose* = INTEGER; OlItemType* = INTEGER; OlJournalRecipientType* = INTEGER; OlMailingAddress* = INTEGER; OlMailRecipientType* = INTEGER; OlMeetingRecipientType* = INTEGER; OlMeetingResponse* = INTEGER; OlMeetingStatus* = INTEGER; OlNetMeetingType* = INTEGER; OlNoteColor* = INTEGER; OlObjectClass* = INTEGER; OlOutlookBarViewType* = INTEGER; OlPane* = INTEGER; OlRecurrenceState* = INTEGER; OlRecurrenceType* = INTEGER; OlRemoteStatus* = INTEGER; OlResponseStatus* = INTEGER; OlSaveAsType* = INTEGER; OlSensitivity* = INTEGER; OlSortOrder* = INTEGER; OlTaskDelegationState* = INTEGER; OlTaskOwnership* = INTEGER; OlTaskRecipientType* = INTEGER; OlTaskResponse* = INTEGER; OlTaskStatus* = INTEGER; OlTrackingStatus* = INTEGER; OlUserPropertyType* = INTEGER; OlWindowState* = INTEGER; OlSyncState* = INTEGER; Action* = POINTER TO RECORD (CtlT.Object) END; _Application* = POINTER TO RECORD (CtlT.Object) END; _NameSpace* = POINTER TO RECORD (CtlT.Object) END; Recipient* = POINTER TO RECORD (CtlT.Object) END; AddressEntry* = POINTER TO RECORD (CtlT.Object) END; AddressEntries* = POINTER TO RECORD (CtlT.Object) END; _Folders* = POINTER TO RECORD (CtlT.Object) END; MAPIFolder* = POINTER TO RECORD (CtlT.Object) END; _Items* = POINTER TO RECORD (CtlT.Object) END; _Explorer* = POINTER TO RECORD (CtlT.Object) END; Panes* = POINTER TO RECORD (CtlT.Object) END; Selection* = POINTER TO RECORD (CtlT.Object) END; AddressLists* = POINTER TO RECORD (CtlT.Object) END; AddressList* = POINTER TO RECORD (CtlT.Object) END; SyncObjects* = POINTER TO RECORD (CtlT.Object) END; SyncObject* = _SyncObject; _SyncObject* = POINTER TO RECORD (CtlT.Object) END; SyncObjectEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _Inspector* = POINTER TO RECORD (CtlT.Object) END; _Explorers* = POINTER TO RECORD (CtlT.Object) END; Explorer* = _Explorer; ExplorerEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _Inspectors* = POINTER TO RECORD (CtlT.Object) END; Inspector* = _Inspector; InspectorEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Actions* = POINTER TO RECORD (CtlT.Object) END; ApplicationEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; PropertyPages* = POINTER TO RECORD (CtlT.Object) END; _AppointmentItem* = POINTER TO RECORD (CtlT.Object) END; Attachments* = POINTER TO RECORD (CtlT.Object) END; Attachment* = POINTER TO RECORD (CtlT.Object) END; FormDescription* = POINTER TO RECORD (CtlT.Object) END; UserProperties* = POINTER TO RECORD (CtlT.Object) END; UserProperty* = POINTER TO RECORD (CtlT.Object) END; Recipients* = POINTER TO RECORD (CtlT.Object) END; MailItem* = _MailItem; _MailItem* = POINTER TO RECORD (CtlT.Object) END; Links* = POINTER TO RECORD (CtlT.Object) END; Link* = POINTER TO RECORD (CtlT.Object) END; ItemEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; RecurrencePattern* = POINTER TO RECORD (CtlT.Object) END; Exceptions* = POINTER TO RECORD (CtlT.Object) END; Exception* = POINTER TO RECORD (CtlT.Object) END; AppointmentItem* = _AppointmentItem; MeetingItem* = _MeetingItem; _MeetingItem* = POINTER TO RECORD (CtlT.Object) END; _ContactItem* = POINTER TO RECORD (CtlT.Object) END; _DistListItem* = POINTER TO RECORD (CtlT.Object) END; _DocumentItem* = POINTER TO RECORD (CtlT.Object) END; ExplorersEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; FoldersEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; InspectorsEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; ItemsEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _JournalItem* = POINTER TO RECORD (CtlT.Object) END; NameSpaceEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _NoteItem* = POINTER TO RECORD (CtlT.Object) END; OutlookBarGroup* = POINTER TO RECORD (CtlT.Object) END; _OutlookBarShortcuts* = POINTER TO RECORD (CtlT.Object) END; OutlookBarShortcut* = POINTER TO RECORD (CtlT.Object) END; _OutlookBarGroups* = POINTER TO RECORD (CtlT.Object) END; OutlookBarGroupsEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _OutlookBarPane* = POINTER TO RECORD (CtlT.Object) END; OutlookBarStorage* = POINTER TO RECORD (CtlT.Object) END; OutlookBarPaneEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; OutlookBarShortcutsEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; PropertyPageSite* = POINTER TO RECORD (CtlT.Object) END; Pages* = POINTER TO RECORD (CtlT.Object) END; _PostItem* = POINTER TO RECORD (CtlT.Object) END; _RemoteItem* = POINTER TO RECORD (CtlT.Object) END; _ReportItem* = POINTER TO RECORD (CtlT.Object) END; _TaskItem* = POINTER TO RECORD (CtlT.Object) END; TaskItem* = _TaskItem; _TaskRequestAcceptItem* = POINTER TO RECORD (CtlT.Object) END; _TaskRequestDeclineItem* = POINTER TO RECORD (CtlT.Object) END; _TaskRequestItem* = POINTER TO RECORD (CtlT.Object) END; _TaskRequestUpdateItem* = POINTER TO RECORD (CtlT.Object) END; Application* = _Application; ContactItem* = _ContactItem; DistListItem* = _DistListItem; DocumentItem* = _DocumentItem; Explorers* = _Explorers; Inspectors* = _Inspectors; Folders* = _Folders; Items* = _Items; JournalItem* = _JournalItem; NameSpace* = _NameSpace; NoteItem* = _NoteItem; OutlookBarGroups* = _OutlookBarGroups; OutlookBarPane* = _OutlookBarPane; OutlookBarShortcuts* = _OutlookBarShortcuts; PostItem* = _PostItem; RemoteItem* = _RemoteItem; ReportItem* = _ReportItem; TaskRequestAcceptItem* = _TaskRequestAcceptItem; TaskRequestDeclineItem* = _TaskRequestDeclineItem; TaskRequestItem* = _TaskRequestItem; TaskRequestUpdateItem* = _TaskRequestUpdateItem; _DRecipientControl* = POINTER TO RECORD (CtlT.Object) END; _DRecipientControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _RecipientControl* = _DRecipientControl; _DDocSiteControl* = POINTER TO RECORD (CtlT.Object) END; _DDocSiteControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _DocSiteControl* = _DDocSiteControl; PROCEDURE ThisAction* (v: CtlT.Any): Action; VAR new: Action; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063043-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAction; PROCEDURE IsAction* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063043-0000-0000-C000-000000000046}") END IsAction; PROCEDURE This_Application* (v: CtlT.Any): _Application; VAR new: _Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063001-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Application; PROCEDURE Is_Application* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063001-0000-0000-C000-000000000046}") END Is_Application; PROCEDURE This_NameSpace* (v: CtlT.Any): _NameSpace; VAR new: _NameSpace; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063002-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_NameSpace; PROCEDURE Is_NameSpace* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063002-0000-0000-C000-000000000046}") END Is_NameSpace; PROCEDURE ThisRecipient* (v: CtlT.Any): Recipient; VAR new: Recipient; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063045-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecipient; PROCEDURE IsRecipient* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063045-0000-0000-C000-000000000046}") END IsRecipient; PROCEDURE ThisAddressEntry* (v: CtlT.Any): AddressEntry; VAR new: AddressEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006304B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddressEntry; PROCEDURE IsAddressEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006304B-0000-0000-C000-000000000046}") END IsAddressEntry; PROCEDURE ThisAddressEntries* (v: CtlT.Any): AddressEntries; VAR new: AddressEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006304A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddressEntries; PROCEDURE IsAddressEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006304A-0000-0000-C000-000000000046}") END IsAddressEntries; PROCEDURE This_Folders* (v: CtlT.Any): _Folders; VAR new: _Folders; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063040-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Folders; PROCEDURE Is_Folders* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063040-0000-0000-C000-000000000046}") END Is_Folders; PROCEDURE ThisMAPIFolder* (v: CtlT.Any): MAPIFolder; VAR new: MAPIFolder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063006-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMAPIFolder; PROCEDURE IsMAPIFolder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063006-0000-0000-C000-000000000046}") END IsMAPIFolder; PROCEDURE This_Items* (v: CtlT.Any): _Items; VAR new: _Items; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063041-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Items; PROCEDURE Is_Items* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063041-0000-0000-C000-000000000046}") END Is_Items; PROCEDURE This_Explorer* (v: CtlT.Any): _Explorer; VAR new: _Explorer; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063003-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Explorer; PROCEDURE Is_Explorer* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063003-0000-0000-C000-000000000046}") END Is_Explorer; PROCEDURE ThisPanes* (v: CtlT.Any): Panes; VAR new: Panes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063009-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPanes; PROCEDURE IsPanes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063009-0000-0000-C000-000000000046}") END IsPanes; PROCEDURE ThisSelection* (v: CtlT.Any): Selection; VAR new: Selection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063087-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSelection; PROCEDURE IsSelection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063087-0000-0000-C000-000000000046}") END IsSelection; PROCEDURE ThisAddressLists* (v: CtlT.Any): AddressLists; VAR new: AddressLists; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063048-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddressLists; PROCEDURE IsAddressLists* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063048-0000-0000-C000-000000000046}") END IsAddressLists; PROCEDURE ThisAddressList* (v: CtlT.Any): AddressList; VAR new: AddressList; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063049-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddressList; PROCEDURE IsAddressList* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063049-0000-0000-C000-000000000046}") END IsAddressList; PROCEDURE ThisSyncObjects* (v: CtlT.Any): SyncObjects; VAR new: SyncObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063086-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSyncObjects; PROCEDURE IsSyncObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063086-0000-0000-C000-000000000046}") END IsSyncObjects; PROCEDURE This_SyncObject* (v: CtlT.Any): _SyncObject; VAR new: _SyncObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063083-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_SyncObject; PROCEDURE Is_SyncObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063083-0000-0000-C000-000000000046}") END Is_SyncObject; PROCEDURE This_Inspector* (v: CtlT.Any): _Inspector; VAR new: _Inspector; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063005-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Inspector; PROCEDURE Is_Inspector* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063005-0000-0000-C000-000000000046}") END Is_Inspector; PROCEDURE This_Explorers* (v: CtlT.Any): _Explorers; VAR new: _Explorers; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006300A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Explorers; PROCEDURE Is_Explorers* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006300A-0000-0000-C000-000000000046}") END Is_Explorers; PROCEDURE This_Inspectors* (v: CtlT.Any): _Inspectors; VAR new: _Inspectors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063008-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Inspectors; PROCEDURE Is_Inspectors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063008-0000-0000-C000-000000000046}") END Is_Inspectors; PROCEDURE ThisActions* (v: CtlT.Any): Actions; VAR new: Actions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006303E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisActions; PROCEDURE IsActions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006303E-0000-0000-C000-000000000046}") END IsActions; PROCEDURE ThisPropertyPages* (v: CtlT.Any): PropertyPages; VAR new: PropertyPages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063080-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPropertyPages; PROCEDURE IsPropertyPages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063080-0000-0000-C000-000000000046}") END IsPropertyPages; PROCEDURE This_AppointmentItem* (v: CtlT.Any): _AppointmentItem; VAR new: _AppointmentItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063033-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_AppointmentItem; PROCEDURE Is_AppointmentItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063033-0000-0000-C000-000000000046}") END Is_AppointmentItem; PROCEDURE ThisAttachments* (v: CtlT.Any): Attachments; VAR new: Attachments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006303C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAttachments; PROCEDURE IsAttachments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006303C-0000-0000-C000-000000000046}") END IsAttachments; PROCEDURE ThisAttachment* (v: CtlT.Any): Attachment; VAR new: Attachment; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063007-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAttachment; PROCEDURE IsAttachment* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063007-0000-0000-C000-000000000046}") END IsAttachment; PROCEDURE ThisFormDescription* (v: CtlT.Any): FormDescription; VAR new: FormDescription; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063046-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFormDescription; PROCEDURE IsFormDescription* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063046-0000-0000-C000-000000000046}") END IsFormDescription; PROCEDURE ThisUserProperties* (v: CtlT.Any): UserProperties; VAR new: UserProperties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006303D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisUserProperties; PROCEDURE IsUserProperties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006303D-0000-0000-C000-000000000046}") END IsUserProperties; PROCEDURE ThisUserProperty* (v: CtlT.Any): UserProperty; VAR new: UserProperty; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063042-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisUserProperty; PROCEDURE IsUserProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063042-0000-0000-C000-000000000046}") END IsUserProperty; PROCEDURE ThisRecipients* (v: CtlT.Any): Recipients; VAR new: Recipients; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006303B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecipients; PROCEDURE IsRecipients* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006303B-0000-0000-C000-000000000046}") END IsRecipients; PROCEDURE This_MailItem* (v: CtlT.Any): _MailItem; VAR new: _MailItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063034-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_MailItem; PROCEDURE Is_MailItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063034-0000-0000-C000-000000000046}") END Is_MailItem; PROCEDURE ThisLinks* (v: CtlT.Any): Links; VAR new: Links; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006308A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLinks; PROCEDURE IsLinks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006308A-0000-0000-C000-000000000046}") END IsLinks; PROCEDURE ThisLink* (v: CtlT.Any): Link; VAR new: Link; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063089-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLink; PROCEDURE IsLink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063089-0000-0000-C000-000000000046}") END IsLink; PROCEDURE ThisRecurrencePattern* (v: CtlT.Any): RecurrencePattern; VAR new: RecurrencePattern; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063044-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecurrencePattern; PROCEDURE IsRecurrencePattern* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063044-0000-0000-C000-000000000046}") END IsRecurrencePattern; PROCEDURE ThisExceptions* (v: CtlT.Any): Exceptions; VAR new: Exceptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006304C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisExceptions; PROCEDURE IsExceptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006304C-0000-0000-C000-000000000046}") END IsExceptions; PROCEDURE ThisException* (v: CtlT.Any): Exception; VAR new: Exception; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006304D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisException; PROCEDURE IsException* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006304D-0000-0000-C000-000000000046}") END IsException; PROCEDURE This_MeetingItem* (v: CtlT.Any): _MeetingItem; VAR new: _MeetingItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063062-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_MeetingItem; PROCEDURE Is_MeetingItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063062-0000-0000-C000-000000000046}") END Is_MeetingItem; PROCEDURE This_ContactItem* (v: CtlT.Any): _ContactItem; VAR new: _ContactItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063021-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_ContactItem; PROCEDURE Is_ContactItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063021-0000-0000-C000-000000000046}") END Is_ContactItem; PROCEDURE This_DistListItem* (v: CtlT.Any): _DistListItem; VAR new: _DistListItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063081-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_DistListItem; PROCEDURE Is_DistListItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063081-0000-0000-C000-000000000046}") END Is_DistListItem; PROCEDURE This_DocumentItem* (v: CtlT.Any): _DocumentItem; VAR new: _DocumentItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063020-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_DocumentItem; PROCEDURE Is_DocumentItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063020-0000-0000-C000-000000000046}") END Is_DocumentItem; PROCEDURE This_JournalItem* (v: CtlT.Any): _JournalItem; VAR new: _JournalItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063022-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_JournalItem; PROCEDURE Is_JournalItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063022-0000-0000-C000-000000000046}") END Is_JournalItem; PROCEDURE This_NoteItem* (v: CtlT.Any): _NoteItem; VAR new: _NoteItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063025-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_NoteItem; PROCEDURE Is_NoteItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063025-0000-0000-C000-000000000046}") END Is_NoteItem; PROCEDURE ThisOutlookBarGroup* (v: CtlT.Any): OutlookBarGroup; VAR new: OutlookBarGroup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063073-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOutlookBarGroup; PROCEDURE IsOutlookBarGroup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063073-0000-0000-C000-000000000046}") END IsOutlookBarGroup; PROCEDURE This_OutlookBarShortcuts* (v: CtlT.Any): _OutlookBarShortcuts; VAR new: _OutlookBarShortcuts; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063074-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_OutlookBarShortcuts; PROCEDURE Is_OutlookBarShortcuts* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063074-0000-0000-C000-000000000046}") END Is_OutlookBarShortcuts; PROCEDURE ThisOutlookBarShortcut* (v: CtlT.Any): OutlookBarShortcut; VAR new: OutlookBarShortcut; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063075-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOutlookBarShortcut; PROCEDURE IsOutlookBarShortcut* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063075-0000-0000-C000-000000000046}") END IsOutlookBarShortcut; PROCEDURE This_OutlookBarGroups* (v: CtlT.Any): _OutlookBarGroups; VAR new: _OutlookBarGroups; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063072-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_OutlookBarGroups; PROCEDURE Is_OutlookBarGroups* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063072-0000-0000-C000-000000000046}") END Is_OutlookBarGroups; PROCEDURE This_OutlookBarPane* (v: CtlT.Any): _OutlookBarPane; VAR new: _OutlookBarPane; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063070-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_OutlookBarPane; PROCEDURE Is_OutlookBarPane* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063070-0000-0000-C000-000000000046}") END Is_OutlookBarPane; PROCEDURE ThisOutlookBarStorage* (v: CtlT.Any): OutlookBarStorage; VAR new: OutlookBarStorage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063071-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOutlookBarStorage; PROCEDURE IsOutlookBarStorage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063071-0000-0000-C000-000000000046}") END IsOutlookBarStorage; PROCEDURE ThisPropertyPageSite* (v: CtlT.Any): PropertyPageSite; VAR new: PropertyPageSite; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006307F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPropertyPageSite; PROCEDURE IsPropertyPageSite* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006307F-0000-0000-C000-000000000046}") END IsPropertyPageSite; PROCEDURE ThisPages* (v: CtlT.Any): Pages; VAR new: Pages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006303F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPages; PROCEDURE IsPages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006303F-0000-0000-C000-000000000046}") END IsPages; PROCEDURE This_PostItem* (v: CtlT.Any): _PostItem; VAR new: _PostItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063024-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_PostItem; PROCEDURE Is_PostItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063024-0000-0000-C000-000000000046}") END Is_PostItem; PROCEDURE This_RemoteItem* (v: CtlT.Any): _RemoteItem; VAR new: _RemoteItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063023-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_RemoteItem; PROCEDURE Is_RemoteItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063023-0000-0000-C000-000000000046}") END Is_RemoteItem; PROCEDURE This_ReportItem* (v: CtlT.Any): _ReportItem; VAR new: _ReportItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063026-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_ReportItem; PROCEDURE Is_ReportItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063026-0000-0000-C000-000000000046}") END Is_ReportItem; PROCEDURE This_TaskItem* (v: CtlT.Any): _TaskItem; VAR new: _TaskItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063035-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_TaskItem; PROCEDURE Is_TaskItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063035-0000-0000-C000-000000000046}") END Is_TaskItem; PROCEDURE This_TaskRequestAcceptItem* (v: CtlT.Any): _TaskRequestAcceptItem; VAR new: _TaskRequestAcceptItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063038-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_TaskRequestAcceptItem; PROCEDURE Is_TaskRequestAcceptItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063038-0000-0000-C000-000000000046}") END Is_TaskRequestAcceptItem; PROCEDURE This_TaskRequestDeclineItem* (v: CtlT.Any): _TaskRequestDeclineItem; VAR new: _TaskRequestDeclineItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063039-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_TaskRequestDeclineItem; PROCEDURE Is_TaskRequestDeclineItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063039-0000-0000-C000-000000000046}") END Is_TaskRequestDeclineItem; PROCEDURE This_TaskRequestItem* (v: CtlT.Any): _TaskRequestItem; VAR new: _TaskRequestItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063036-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_TaskRequestItem; PROCEDURE Is_TaskRequestItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063036-0000-0000-C000-000000000046}") END Is_TaskRequestItem; PROCEDURE This_TaskRequestUpdateItem* (v: CtlT.Any): _TaskRequestUpdateItem; VAR new: _TaskRequestUpdateItem; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00063037-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_TaskRequestUpdateItem; PROCEDURE Is_TaskRequestUpdateItem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00063037-0000-0000-C000-000000000046}") END Is_TaskRequestUpdateItem; PROCEDURE This_DRecipientControl* (v: CtlT.Any): _DRecipientControl; VAR new: _DRecipientControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006F025-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_DRecipientControl; PROCEDURE Is_DRecipientControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006F025-0000-0000-C000-000000000046}") END Is_DRecipientControl; PROCEDURE This_DDocSiteControl* (v: CtlT.Any): _DDocSiteControl; VAR new: _DDocSiteControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0006F026-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_DDocSiteControl; PROCEDURE Is_DDocSiteControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0006F026-0000-0000-C000-000000000046}") END Is_DDocSiteControl; (* ---------- Action, dual ---------- *) PROCEDURE (this: Action) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Action) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Action) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Action) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Action) CopyLike* (): OlActionCopyLike, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END CopyLike; PROCEDURE (this: Action) PUTCopyLike* (p1: OlActionCopyLike), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTCopyLike; PROCEDURE (this: Action) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END Enabled; PROCEDURE (this: Action) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTEnabled; PROCEDURE (this: Action) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: Action) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: Action) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: Action) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTName; PROCEDURE (this: Action) Prefix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61) END Prefix; PROCEDURE (this: Action) PUTPrefix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61, p1) END PUTPrefix; PROCEDURE (this: Action) ReplyStyle* (): OlActionReplyStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END ReplyStyle; PROCEDURE (this: Action) PUTReplyStyle* (p1: OlActionReplyStyle), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTReplyStyle; PROCEDURE (this: Action) ResponseStyle* (): OlActionResponseStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END ResponseStyle; PROCEDURE (this: Action) PUTResponseStyle* (p1: OlActionResponseStyle), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTResponseStyle; PROCEDURE (this: Action) ShowOn* (): OlActionShowOn, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END ShowOn; PROCEDURE (this: Action) PUTShowOn* (p1: OlActionShowOn), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTShowOn; PROCEDURE (this: Action) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 108, NIL); END Delete; PROCEDURE (this: Action) Execute* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 106, ret); RETURN CtlC.VarObj(ret) END Execute; (* ---------- _Application, dual ---------- *) PROCEDURE (this: _Application) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Application) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Application) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Application) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Application) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 276)) END Assistant; PROCEDURE (this: _Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: _Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 278) END Version; PROCEDURE (this: _Application) ActiveExplorer* (): _Explorer, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 273, ret); RETURN This_Explorer(CtlC.VarAny(ret)) END ActiveExplorer; PROCEDURE (this: _Application) ActiveInspector* (): _Inspector, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 274, ret); RETURN This_Inspector(CtlC.VarAny(ret)) END ActiveInspector; PROCEDURE (this: _Application) CreateItem* (ItemType: OlItemType): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ItemType, arg[0]); CtlC.CallParMethod(this, 266, arg, ret); RETURN CtlC.VarObj(ret) END CreateItem; PROCEDURE (this: _Application) CreateItemFromTemplate* (TemplatePath: ARRAY OF CHAR; (* optional *) InFolder: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(TemplatePath, arg[1]); CtlC.AnyVar(InFolder, arg[0]); CtlC.CallParMethod(this, 267, arg, ret); RETURN CtlC.VarObj(ret) END CreateItemFromTemplate; PROCEDURE (this: _Application) CreateObject* (ObjectName: ARRAY OF CHAR): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 277, arg, ret); RETURN CtlC.VarObj(ret) END CreateObject; PROCEDURE (this: _Application) GetNamespace* (Type: ARRAY OF CHAR): _NameSpace, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Type, arg[0]); CtlC.CallParMethod(this, 272, arg, ret); RETURN This_NameSpace(CtlC.VarAny(ret)) END GetNamespace; PROCEDURE (this: _Application) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 275, NIL); END Quit; PROCEDURE (this: _Application) COMAddIns* (): CtlOffice.COMAddIns, NEW; BEGIN RETURN CtlOffice.ThisCOMAddIns(CtlC.GetAny(this, 280)) END COMAddIns; PROCEDURE (this: _Application) Explorers* (): _Explorers, NEW; BEGIN RETURN This_Explorers(CtlC.GetAny(this, 281)) END Explorers; PROCEDURE (this: _Application) Inspectors* (): _Inspectors, NEW; BEGIN RETURN This_Inspectors(CtlC.GetAny(this, 282)) END Inspectors; PROCEDURE (this: _Application) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 283)) END LanguageSettings; PROCEDURE (this: _Application) ProductCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 284) END ProductCode; PROCEDURE (this: _Application) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 285)) END AnswerWizard; PROCEDURE (this: _Application) FeatureInstall* (): CtlOffice.MsoFeatureInstall, NEW; BEGIN RETURN CtlC.GetInt(this, 286) END FeatureInstall; PROCEDURE (this: _Application) PUTFeatureInstall* (p1: CtlOffice.MsoFeatureInstall), NEW; BEGIN CtlC.PutInt(this, 286, p1) END PUTFeatureInstall; PROCEDURE (this: _Application) ActiveWindow* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 287, ret); RETURN CtlC.VarObj(ret) END ActiveWindow; (* ---------- _NameSpace, dual ---------- *) PROCEDURE (this: _NameSpace) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _NameSpace) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _NameSpace) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _NameSpace) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _NameSpace) CurrentUser* (): Recipient, NEW; BEGIN RETURN ThisRecipient(CtlC.GetAny(this, 8449)) END CurrentUser; PROCEDURE (this: _NameSpace) Folders* (): _Folders, NEW; BEGIN RETURN This_Folders(CtlC.GetAny(this, 8451)) END Folders; PROCEDURE (this: _NameSpace) Type* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8452) END Type; PROCEDURE (this: _NameSpace) AddressLists* (): AddressLists, NEW; BEGIN RETURN ThisAddressLists(CtlC.GetAny(this, 8461)) END AddressLists; PROCEDURE (this: _NameSpace) CreateRecipient* (RecipientName: ARRAY OF CHAR): Recipient, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(RecipientName, arg[0]); CtlC.CallParMethod(this, 8458, arg, ret); RETURN ThisRecipient(CtlC.VarAny(ret)) END CreateRecipient; PROCEDURE (this: _NameSpace) GetDefaultFolder* (FolderType: OlDefaultFolders): MAPIFolder, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(FolderType, arg[0]); CtlC.CallParMethod(this, 8459, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetDefaultFolder; PROCEDURE (this: _NameSpace) GetFolderFromID* (EntryIDFolder: ARRAY OF CHAR; (* optional *) EntryIDStore: CtlT.Any): MAPIFolder, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(EntryIDFolder, arg[1]); CtlC.AnyVar(EntryIDStore, arg[0]); CtlC.CallParMethod(this, 8456, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetFolderFromID; PROCEDURE (this: _NameSpace) GetItemFromID* (EntryIDItem: ARRAY OF CHAR; (* optional *) EntryIDStore: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(EntryIDItem, arg[1]); CtlC.AnyVar(EntryIDStore, arg[0]); CtlC.CallParMethod(this, 8457, arg, ret); RETURN CtlC.VarObj(ret) END GetItemFromID; PROCEDURE (this: _NameSpace) GetRecipientFromID* (EntryID: ARRAY OF CHAR): Recipient, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(EntryID, arg[0]); CtlC.CallParMethod(this, 8455, arg, ret); RETURN ThisRecipient(CtlC.VarAny(ret)) END GetRecipientFromID; PROCEDURE (this: _NameSpace) GetSharedDefaultFolder* (recipient: Recipient; FolderType: OlDefaultFolders): MAPIFolder, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(recipient, arg[1]); CtlC.IntVar(FolderType, arg[0]); CtlC.CallParMethod(this, 8460, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetSharedDefaultFolder; PROCEDURE (this: _NameSpace) Logoff* (), NEW; BEGIN CtlC.CallMethod(this, 8454, NIL); END Logoff; PROCEDURE (this: _NameSpace) Logon* ((* optional *) Profile: CtlT.Any; Password: CtlT.Any; ShowDialog: CtlT.Any; NewSession: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Profile, arg[3]); CtlC.AnyVar(Password, arg[2]); CtlC.AnyVar(ShowDialog, arg[1]); CtlC.AnyVar(NewSession, arg[0]); CtlC.CallParMethod(this, 8453, arg, NIL); END Logon; PROCEDURE (this: _NameSpace) PickFolder* (): MAPIFolder, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 8462, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END PickFolder; PROCEDURE (this: _NameSpace) RefreshRemoteHeaders* (), NEW; BEGIN CtlC.CallMethod(this, 8471, NIL); END RefreshRemoteHeaders; PROCEDURE (this: _NameSpace) SyncObjects* (): SyncObjects, NEW; BEGIN RETURN ThisSyncObjects(CtlC.GetAny(this, 8472)) END SyncObjects; PROCEDURE (this: _NameSpace) AddStore* (Store: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Store, arg[0]); CtlC.CallParMethod(this, 8473, arg, NIL); END AddStore; PROCEDURE (this: _NameSpace) RemoveStore* (Folder: MAPIFolder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Folder, arg[0]); CtlC.CallParMethod(this, 8474, arg, NIL); END RemoveStore; (* ---------- Recipient, dual ---------- *) PROCEDURE (this: Recipient) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Recipient) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Recipient) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Recipient) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 109) END Parent; PROCEDURE (this: Recipient) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12291) END Address; PROCEDURE (this: Recipient) AddressEntry* (): AddressEntry, NEW; BEGIN RETURN ThisAddressEntry(CtlC.GetAny(this, 121)) END AddressEntry; PROCEDURE (this: Recipient) PUTREFAddressEntry* (p1: AddressEntry), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 121, arg, NIL); END PUTREFAddressEntry; PROCEDURE (this: Recipient) AutoResponse* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END AutoResponse; PROCEDURE (this: Recipient) PUTAutoResponse* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTAutoResponse; PROCEDURE (this: Recipient) DisplayType* (): OlDisplayType, NEW; BEGIN RETURN CtlC.GetInt(this, 14592) END DisplayType; PROCEDURE (this: Recipient) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: Recipient) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 91) END Index; PROCEDURE (this: Recipient) MeetingResponseStatus* (): OlResponseStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END MeetingResponseStatus; PROCEDURE (this: Recipient) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: Recipient) Resolved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 100) END Resolved; PROCEDURE (this: Recipient) TrackingStatus* (): OlTrackingStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END TrackingStatus; PROCEDURE (this: Recipient) PUTTrackingStatus* (p1: OlTrackingStatus), NEW; BEGIN CtlC.PutInt(this, 118, p1) END PUTTrackingStatus; PROCEDURE (this: Recipient) TrackingStatusTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 119) END TrackingStatusTime; PROCEDURE (this: Recipient) PUTTrackingStatusTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 119, p1) END PUTTrackingStatusTime; PROCEDURE (this: Recipient) Type* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3093) END Type; PROCEDURE (this: Recipient) PUTType* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3093, p1) END PUTType; PROCEDURE (this: Recipient) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 110, NIL); END Delete; PROCEDURE (this: Recipient) FreeBusy* (Start: CtlT.OleDate; MinPerChar: INTEGER; (* optional *) CompleteFormat: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.DateVar(Start, arg[2]); CtlC.IntVar(MinPerChar, arg[1]); CtlC.AnyVar(CompleteFormat, arg[0]); CtlC.CallParMethod(this, 111, arg, ret); RETURN CtlC.VarStr(ret) END FreeBusy; PROCEDURE (this: Recipient) Resolve* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 113, ret); RETURN CtlC.VarBool(ret) END Resolve; (* ---------- AddressEntry, dual ---------- *) PROCEDURE (this: AddressEntry) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: AddressEntry) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: AddressEntry) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: AddressEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: AddressEntry) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12291) END Address; PROCEDURE (this: AddressEntry) PUTAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12291, p1) END PUTAddress; PROCEDURE (this: AddressEntry) DisplayType* (): OlDisplayType, NEW; BEGIN RETURN CtlC.GetInt(this, 14592) END DisplayType; PROCEDURE (this: AddressEntry) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END ID; PROCEDURE (this: AddressEntry) Manager* (): AddressEntry, NEW; BEGIN RETURN ThisAddressEntry(CtlC.GetAny(this, 771)) END Manager; PROCEDURE (this: AddressEntry) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: AddressEntry) PUTMAPIOBJECT* (p1: CtlT.IUnknown), NEW; BEGIN CtlC.PutIntfce(this, 61696, p1) END PUTMAPIOBJECT; PROCEDURE (this: AddressEntry) Members* (): AddressEntries, NEW; BEGIN RETURN ThisAddressEntries(CtlC.GetAny(this, 772)) END Members; PROCEDURE (this: AddressEntry) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: AddressEntry) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTName; PROCEDURE (this: AddressEntry) Type* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12290) END Type; PROCEDURE (this: AddressEntry) PUTType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12290, p1) END PUTType; PROCEDURE (this: AddressEntry) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 770, NIL); END Delete; PROCEDURE (this: AddressEntry) Details* ((* optional *) HWnd: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(HWnd, arg[0]); CtlC.CallParMethod(this, 769, arg, NIL); END Details; PROCEDURE (this: AddressEntry) GetFreeBusy* (Start: CtlT.OleDate; MinPerChar: INTEGER; (* optional *) CompleteFormat: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.DateVar(Start, arg[2]); CtlC.IntVar(MinPerChar, arg[1]); CtlC.AnyVar(CompleteFormat, arg[0]); CtlC.CallParMethod(this, 774, arg, ret); RETURN CtlC.VarStr(ret) END GetFreeBusy; PROCEDURE (this: AddressEntry) Update* ((* optional *) MakePermanent: CtlT.Any; Refresh: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(MakePermanent, arg[1]); CtlC.AnyVar(Refresh, arg[0]); CtlC.CallParMethod(this, 768, arg, NIL); END Update; PROCEDURE (this: AddressEntry) UpdateFreeBusy* (), NEW; BEGIN CtlC.CallMethod(this, 775, NIL); END UpdateFreeBusy; (* ---------- AddressEntries, dual ---------- *) PROCEDURE (this: AddressEntries) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: AddressEntries) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: AddressEntries) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: AddressEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: AddressEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: AddressEntries) Item* (Index: CtlT.Any): AddressEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AddressEntries) RawTable* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 90) END RawTable; PROCEDURE (this: AddressEntries) Add* (Type: ARRAY OF CHAR; (* optional *) Name: CtlT.Any; Address: CtlT.Any): AddressEntry, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Type, arg[2]); CtlC.AnyVar(Name, arg[1]); CtlC.AnyVar(Address, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AddressEntries) GetFirst* (): AddressEntry, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 86, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END GetFirst; PROCEDURE (this: AddressEntries) GetLast* (): AddressEntry, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 88, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END GetLast; PROCEDURE (this: AddressEntries) GetNext* (): AddressEntry, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 87, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END GetNext; PROCEDURE (this: AddressEntries) GetPrevious* (): AddressEntry, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 89, ret); RETURN ThisAddressEntry(CtlC.VarAny(ret)) END GetPrevious; PROCEDURE (this: AddressEntries) Sort* ((* optional *) Property: CtlT.Any; Order: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Property, arg[1]); CtlC.AnyVar(Order, arg[0]); CtlC.CallParMethod(this, 97, arg, NIL); END Sort; (* ---------- _Folders, dual ---------- *) PROCEDURE (this: _Folders) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Folders) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Folders) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Folders) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Folders) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _Folders) Item* (Index: CtlT.Any): MAPIFolder, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Folders) RawTable* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 90) END RawTable; PROCEDURE (this: _Folders) Add* (Name: ARRAY OF CHAR; (* optional *) Type: CtlT.Any): MAPIFolder, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _Folders) GetFirst* (): MAPIFolder, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 86, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetFirst; PROCEDURE (this: _Folders) GetLast* (): MAPIFolder, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 88, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetLast; PROCEDURE (this: _Folders) GetNext* (): MAPIFolder, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 87, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetNext; PROCEDURE (this: _Folders) GetPrevious* (): MAPIFolder, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 89, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END GetPrevious; PROCEDURE (this: _Folders) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- MAPIFolder, dual ---------- *) PROCEDURE (this: MAPIFolder) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: MAPIFolder) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: MAPIFolder) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: MAPIFolder) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: MAPIFolder) DefaultItemType* (): OlItemType, NEW; BEGIN RETURN CtlC.GetInt(this, 12550) END DefaultItemType; PROCEDURE (this: MAPIFolder) DefaultMessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12551) END DefaultMessageClass; PROCEDURE (this: MAPIFolder) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12292) END Description; PROCEDURE (this: MAPIFolder) PUTDescription* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12292, p1) END PUTDescription; PROCEDURE (this: MAPIFolder) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: MAPIFolder) Folders* (): _Folders, NEW; BEGIN RETURN This_Folders(CtlC.GetAny(this, 8451)) END Folders; PROCEDURE (this: MAPIFolder) Items* (): _Items, NEW; BEGIN RETURN This_Items(CtlC.GetAny(this, 12544)) END Items; PROCEDURE (this: MAPIFolder) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: MAPIFolder) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTName; PROCEDURE (this: MAPIFolder) StoreID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12552) END StoreID; PROCEDURE (this: MAPIFolder) UnReadItemCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13827) END UnReadItemCount; PROCEDURE (this: MAPIFolder) CopyTo* (DestinationFolder: MAPIFolder): MAPIFolder, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestinationFolder, arg[0]); CtlC.CallParMethod(this, 61490, arg, ret); RETURN ThisMAPIFolder(CtlC.VarAny(ret)) END CopyTo; PROCEDURE (this: MAPIFolder) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61509, NIL); END Delete; PROCEDURE (this: MAPIFolder) Display* (), NEW; BEGIN CtlC.CallMethod(this, 12548, NIL); END Display; PROCEDURE (this: MAPIFolder) GetExplorer* ((* optional *) DisplayMode: CtlT.Any): _Explorer, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(DisplayMode, arg[0]); CtlC.CallParMethod(this, 12545, arg, ret); RETURN This_Explorer(CtlC.VarAny(ret)) END GetExplorer; PROCEDURE (this: MAPIFolder) MoveTo* (DestinationFolder: MAPIFolder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(DestinationFolder, arg[0]); CtlC.CallParMethod(this, 61492, arg, NIL); END MoveTo; PROCEDURE (this: MAPIFolder) UserPermissions* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 12561) END UserPermissions; PROCEDURE (this: MAPIFolder) WebViewOn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12562) END WebViewOn; PROCEDURE (this: MAPIFolder) PUTWebViewOn* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12562, p1) END PUTWebViewOn; PROCEDURE (this: MAPIFolder) WebViewURL* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12563) END WebViewURL; PROCEDURE (this: MAPIFolder) PUTWebViewURL* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12563, p1) END PUTWebViewURL; PROCEDURE (this: MAPIFolder) WebViewAllowNavigation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12564) END WebViewAllowNavigation; PROCEDURE (this: MAPIFolder) PUTWebViewAllowNavigation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12564, p1) END PUTWebViewAllowNavigation; PROCEDURE (this: MAPIFolder) AddToPFFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 12565, NIL); END AddToPFFavorites; (* ---------- _Items, dual ---------- *) PROCEDURE (this: _Items) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Items) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Items) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Items) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Items) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _Items) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: _Items) RawTable* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 90) END RawTable; PROCEDURE (this: _Items) IncludeRecurrences* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 206) END IncludeRecurrences; PROCEDURE (this: _Items) PUTIncludeRecurrences* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 206, p1) END PUTIncludeRecurrences; PROCEDURE (this: _Items) Add* ((* optional *) Type: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN CtlC.VarObj(ret) END Add; PROCEDURE (this: _Items) Find* (Filter: ARRAY OF CHAR): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filter, arg[0]); CtlC.CallParMethod(this, 98, arg, ret); RETURN CtlC.VarObj(ret) END Find; PROCEDURE (this: _Items) FindNext* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 99, ret); RETURN CtlC.VarObj(ret) END FindNext; PROCEDURE (this: _Items) GetFirst* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 86, ret); RETURN CtlC.VarObj(ret) END GetFirst; PROCEDURE (this: _Items) GetLast* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 88, ret); RETURN CtlC.VarObj(ret) END GetLast; PROCEDURE (this: _Items) GetNext* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 87, ret); RETURN CtlC.VarObj(ret) END GetNext; PROCEDURE (this: _Items) GetPrevious* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 89, ret); RETURN CtlC.VarObj(ret) END GetPrevious; PROCEDURE (this: _Items) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; PROCEDURE (this: _Items) ResetColumns* (), NEW; BEGIN CtlC.CallMethod(this, 93, NIL); END ResetColumns; PROCEDURE (this: _Items) Restrict* (Filter: ARRAY OF CHAR): _Items, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Filter, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN This_Items(CtlC.VarAny(ret)) END Restrict; PROCEDURE (this: _Items) SetColumns* (Columns: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Columns, arg[0]); CtlC.CallParMethod(this, 92, arg, NIL); END SetColumns; PROCEDURE (this: _Items) Sort* (Property: ARRAY OF CHAR; (* optional *) Descending: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Property, arg[1]); CtlC.AnyVar(Descending, arg[0]); CtlC.CallParMethod(this, 97, arg, NIL); END Sort; (* ---------- _Explorer, dual ---------- *) PROCEDURE (this: _Explorer) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Explorer) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Explorer) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Explorer) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Explorer) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 8448)) END CommandBars; PROCEDURE (this: _Explorer) CurrentFolder* (): MAPIFolder, NEW; BEGIN RETURN ThisMAPIFolder(CtlC.GetAny(this, 8449)) END CurrentFolder; PROCEDURE (this: _Explorer) PUTREFCurrentFolder* (p1: MAPIFolder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 8449, arg, NIL); END PUTREFCurrentFolder; PROCEDURE (this: _Explorer) Close* (), NEW; BEGIN CtlC.CallMethod(this, 8451, NIL); END Close; PROCEDURE (this: _Explorer) Display* (), NEW; BEGIN CtlC.CallMethod(this, 8452, NIL); END Display; PROCEDURE (this: _Explorer) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8465) END Caption; PROCEDURE (this: _Explorer) CurrentView* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 8704) END CurrentView; PROCEDURE (this: _Explorer) PUTCurrentView* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 8704, p1) END PUTCurrentView; PROCEDURE (this: _Explorer) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8468) END Height; PROCEDURE (this: _Explorer) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8468, p1) END PUTHeight; PROCEDURE (this: _Explorer) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8469) END Left; PROCEDURE (this: _Explorer) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8469, p1) END PUTLeft; PROCEDURE (this: _Explorer) Panes* (): Panes, NEW; BEGIN RETURN ThisPanes(CtlC.GetAny(this, 8705)) END Panes; PROCEDURE (this: _Explorer) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 8706)) END Selection; PROCEDURE (this: _Explorer) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8470) END Top; PROCEDURE (this: _Explorer) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8470, p1) END PUTTop; PROCEDURE (this: _Explorer) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8471) END Width; PROCEDURE (this: _Explorer) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8471, p1) END PUTWidth; PROCEDURE (this: _Explorer) WindowState* (): OlWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 8466) END WindowState; PROCEDURE (this: _Explorer) PUTWindowState* (p1: OlWindowState), NEW; BEGIN CtlC.PutInt(this, 8466, p1) END PUTWindowState; PROCEDURE (this: _Explorer) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 8467, NIL); END Activate; PROCEDURE (this: _Explorer) IsPaneVisible* (Pane: OlPane): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Pane, arg[0]); CtlC.CallParMethod(this, 8707, arg, ret); RETURN CtlC.VarBool(ret) END IsPaneVisible; PROCEDURE (this: _Explorer) ShowPane* (Pane: OlPane; Visible: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Pane, arg[1]); CtlC.BoolVar(Visible, arg[0]); CtlC.CallParMethod(this, 8708, arg, NIL); END ShowPane; PROCEDURE (this: _Explorer) Views* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 12553) END Views; (* ---------- Panes, dual ---------- *) PROCEDURE (this: Panes) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Panes) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Panes) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Panes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Panes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Panes) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN CtlC.VarObj(ret) END Item; (* ---------- Selection, dual ---------- *) PROCEDURE (this: Selection) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Selection) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Selection) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Selection) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Selection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Selection) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN CtlC.VarObj(ret) END Item; (* ---------- AddressLists, dual ---------- *) PROCEDURE (this: AddressLists) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: AddressLists) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: AddressLists) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: AddressLists) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: AddressLists) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: AddressLists) Item* (Index: CtlT.Any): AddressList, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisAddressList(CtlC.VarAny(ret)) END Item; (* ---------- AddressList, dual ---------- *) PROCEDURE (this: AddressList) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: AddressList) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: AddressList) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: AddressList) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: AddressList) AddressEntries* (): AddressEntries, NEW; BEGIN RETURN ThisAddressEntries(CtlC.GetAny(this, 256)) END AddressEntries; PROCEDURE (this: AddressList) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END ID; PROCEDURE (this: AddressList) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 91) END Index; PROCEDURE (this: AddressList) IsReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61463) END IsReadOnly; PROCEDURE (this: AddressList) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; (* ---------- SyncObjects, dual ---------- *) PROCEDURE (this: SyncObjects) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: SyncObjects) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: SyncObjects) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: SyncObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: SyncObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: SyncObjects) Item* (Index: CtlT.Any): SyncObject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN This_SyncObject(CtlC.VarAny(ret)) END Item; (* ---------- _SyncObject, dual ---------- *) PROCEDURE (this: _SyncObject) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _SyncObject) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _SyncObject) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _SyncObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _SyncObject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8448) END Name; PROCEDURE (this: _SyncObject) Start* (), NEW; BEGIN CtlC.CallMethod(this, 8449, NIL); END Start; PROCEDURE (this: _SyncObject) Stop* (), NEW; BEGIN CtlC.CallMethod(this, 8450, NIL); END Stop; (* ---------- SyncObjectEvents ---------- *) PROCEDURE (this: SyncObjectEvents) SyncStart* (), NEW, ABSTRACT; PROCEDURE (this: SyncObjectEvents) Progress* (State: OlSyncState; Description: ARRAY OF CHAR; Value: INTEGER; Max: INTEGER), NEW, ABSTRACT; PROCEDURE (this: SyncObjectEvents) OnError* (Code: INTEGER; Description: ARRAY OF CHAR), NEW, ABSTRACT; PROCEDURE (this: SyncObjectEvents) SyncEnd* (), NEW, ABSTRACT; PROCEDURE (this: SyncObjectEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 0, 11); this.SyncStart() | 61442: ASSERT(n = 4, 11); this.Progress(CtlC.VarInt(par[3]), CtlC.VarStr(par[2]), CtlC.VarInt(par[1]), CtlC.VarInt(par[0])) | 61443: ASSERT(n = 2, 11); this.OnError(CtlC.VarInt(par[1]), CtlC.VarStr(par[0])) | 61444: ASSERT(n = 0, 11); this.SyncEnd() END END Invoke; PROCEDURE (this: SyncObjectEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00063085-0000-0000-C000-000000000046}" END GetIID; (* ---------- _Inspector, dual ---------- *) PROCEDURE (this: _Inspector) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Inspector) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Inspector) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Inspector) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Inspector) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 8448)) END CommandBars; PROCEDURE (this: _Inspector) CurrentItem* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8450) END CurrentItem; PROCEDURE (this: _Inspector) EditorType* (): OlEditorType, NEW; BEGIN RETURN CtlC.GetInt(this, 8464) END EditorType; PROCEDURE (this: _Inspector) ModifiedFormPages* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8454) END ModifiedFormPages; PROCEDURE (this: _Inspector) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 8451, arg, NIL); END Close; PROCEDURE (this: _Inspector) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 8452, arg, NIL); END Display; PROCEDURE (this: _Inspector) HideFormPage* (PageName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PageName, arg[0]); CtlC.CallParMethod(this, 8456, arg, NIL); END HideFormPage; PROCEDURE (this: _Inspector) IsWordMail* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 8453, ret); RETURN CtlC.VarBool(ret) END IsWordMail; PROCEDURE (this: _Inspector) SetCurrentFormPage* (PageName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PageName, arg[0]); CtlC.CallParMethod(this, 8460, arg, NIL); END SetCurrentFormPage; PROCEDURE (this: _Inspector) ShowFormPage* (PageName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PageName, arg[0]); CtlC.CallParMethod(this, 8457, arg, NIL); END ShowFormPage; PROCEDURE (this: _Inspector) HTMLEditor* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8462) END HTMLEditor; PROCEDURE (this: _Inspector) WordEditor* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8463) END WordEditor; PROCEDURE (this: _Inspector) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8465) END Caption; PROCEDURE (this: _Inspector) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8468) END Height; PROCEDURE (this: _Inspector) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8468, p1) END PUTHeight; PROCEDURE (this: _Inspector) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8469) END Left; PROCEDURE (this: _Inspector) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8469, p1) END PUTLeft; PROCEDURE (this: _Inspector) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8470) END Top; PROCEDURE (this: _Inspector) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8470, p1) END PUTTop; PROCEDURE (this: _Inspector) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8471) END Width; PROCEDURE (this: _Inspector) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8471, p1) END PUTWidth; PROCEDURE (this: _Inspector) WindowState* (): OlWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 8466) END WindowState; PROCEDURE (this: _Inspector) PUTWindowState* (p1: OlWindowState), NEW; BEGIN CtlC.PutInt(this, 8466, p1) END PUTWindowState; PROCEDURE (this: _Inspector) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 8467, NIL); END Activate; (* ---------- _Explorers, dual ---------- *) PROCEDURE (this: _Explorers) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Explorers) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Explorers) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Explorers) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Explorers) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _Explorers) Item* (Index: CtlT.Any): Explorer, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN This_Explorer(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Explorers) Add* (Folder: CtlT.Any; DisplayMode: OlFolderDisplayMode): _Explorer, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Folder, arg[1]); CtlC.IntVar(DisplayMode, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN This_Explorer(CtlC.VarAny(ret)) END Add; (* ---------- ExplorerEvents ---------- *) PROCEDURE (this: ExplorerEvents) Activate* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) FolderSwitch* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) BeforeFolderSwitch* (NewFolder: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) ViewSwitch* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) BeforeViewSwitch* (NewView: CtlT.Any; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) Deactivate* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) SelectionChange* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) Close* (), NEW, ABSTRACT; PROCEDURE (this: ExplorerEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 0, 11); this.Activate() | 61442: ASSERT(n = 0, 11); this.FolderSwitch() | 61443: ASSERT(n = 2, 11); this.BeforeFolderSwitch(CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61444: ASSERT(n = 0, 11); this.ViewSwitch() | 61445: ASSERT(n = 2, 11); this.BeforeViewSwitch(CtlC.VarAny(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61446: ASSERT(n = 0, 11); this.Deactivate() | 61447: ASSERT(n = 0, 11); this.SelectionChange() | 61448: ASSERT(n = 0, 11); this.Close() END END Invoke; PROCEDURE (this: ExplorerEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006304F-0000-0000-C000-000000000046}" END GetIID; (* ---------- _Inspectors, dual ---------- *) PROCEDURE (this: _Inspectors) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _Inspectors) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _Inspectors) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _Inspectors) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _Inspectors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _Inspectors) Item* (Index: CtlT.Any): Inspector, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN This_Inspector(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Inspectors) Add* (Item: CtlT.Object): _Inspector, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Item, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN This_Inspector(CtlC.VarAny(ret)) END Add; (* ---------- InspectorEvents ---------- *) PROCEDURE (this: InspectorEvents) Activate* (), NEW, ABSTRACT; PROCEDURE (this: InspectorEvents) Deactivate* (), NEW, ABSTRACT; PROCEDURE (this: InspectorEvents) Close* (), NEW, ABSTRACT; PROCEDURE (this: InspectorEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 0, 11); this.Activate() | 61446: ASSERT(n = 0, 11); this.Deactivate() | 61448: ASSERT(n = 0, 11); this.Close() END END Invoke; PROCEDURE (this: InspectorEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006307D-0000-0000-C000-000000000046}" END GetIID; (* ---------- Actions, dual ---------- *) PROCEDURE (this: Actions) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Actions) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Actions) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Actions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Actions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Actions) Item* (Index: CtlT.Any): Action, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisAction(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Actions) Add* (): Action, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 100, ret); RETURN ThisAction(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Actions) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 82, arg, NIL); END Remove; (* ---------- ApplicationEvents ---------- *) PROCEDURE (this: ApplicationEvents) ItemSend* (Item: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) NewMail* (), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) Reminder* (Item: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) OptionsPagesAdd* (Pages: PropertyPages), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) Startup* (), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) Quit* (), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61442: ASSERT(n = 2, 11); this.ItemSend(CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61443: ASSERT(n = 0, 11); this.NewMail() | 61444: ASSERT(n = 1, 11); this.Reminder(CtlC.VarObj(par[0])) | 61445: ASSERT(n = 1, 11); this.OptionsPagesAdd(ThisPropertyPages(CtlC.VarAny(par[0]))) | 61446: ASSERT(n = 0, 11); this.Startup() | 61447: ASSERT(n = 0, 11); this.Quit() END END Invoke; PROCEDURE (this: ApplicationEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006304E-0000-0000-C000-000000000046}" END GetIID; (* ---------- PropertyPages, dual ---------- *) PROCEDURE (this: PropertyPages) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: PropertyPages) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: PropertyPages) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: PropertyPages) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: PropertyPages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: PropertyPages) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: PropertyPages) Add* (Page: CtlT.Any; Title: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Page, arg[1]); CtlC.StrVar(Title, arg[0]); CtlC.CallParMethod(this, 95, arg, NIL); END Add; PROCEDURE (this: PropertyPages) Remove* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- _AppointmentItem, dual ---------- *) PROCEDURE (this: _AppointmentItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _AppointmentItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _AppointmentItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _AppointmentItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _AppointmentItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _AppointmentItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _AppointmentItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _AppointmentItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _AppointmentItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _AppointmentItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _AppointmentItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _AppointmentItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _AppointmentItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _AppointmentItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _AppointmentItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _AppointmentItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _AppointmentItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _AppointmentItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _AppointmentItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _AppointmentItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _AppointmentItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _AppointmentItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _AppointmentItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _AppointmentItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _AppointmentItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _AppointmentItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _AppointmentItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _AppointmentItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _AppointmentItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _AppointmentItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _AppointmentItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _AppointmentItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _AppointmentItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _AppointmentItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _AppointmentItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _AppointmentItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _AppointmentItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _AppointmentItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _AppointmentItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _AppointmentItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _AppointmentItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _AppointmentItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _AppointmentItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _AppointmentItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _AppointmentItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _AppointmentItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _AppointmentItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _AppointmentItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _AppointmentItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _AppointmentItem) AllDayEvent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33301) END AllDayEvent; PROCEDURE (this: _AppointmentItem) PUTAllDayEvent* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33301, p1) END PUTAllDayEvent; PROCEDURE (this: _AppointmentItem) BusyStatus* (): OlBusyStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 33285) END BusyStatus; PROCEDURE (this: _AppointmentItem) PUTBusyStatus* (p1: OlBusyStatus), NEW; BEGIN CtlC.PutInt(this, 33285, p1) END PUTBusyStatus; PROCEDURE (this: _AppointmentItem) Duration* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 33299) END Duration; PROCEDURE (this: _AppointmentItem) PUTDuration* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 33299, p1) END PUTDuration; PROCEDURE (this: _AppointmentItem) End* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33294) END End; PROCEDURE (this: _AppointmentItem) PUTEnd* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33294, p1) END PUTEnd; PROCEDURE (this: _AppointmentItem) IsOnlineMeeting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33344) END IsOnlineMeeting; PROCEDURE (this: _AppointmentItem) PUTIsOnlineMeeting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33344, p1) END PUTIsOnlineMeeting; PROCEDURE (this: _AppointmentItem) IsRecurring* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33315) END IsRecurring; PROCEDURE (this: _AppointmentItem) Location* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33288) END Location; PROCEDURE (this: _AppointmentItem) PUTLocation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33288, p1) END PUTLocation; PROCEDURE (this: _AppointmentItem) MeetingStatus* (): OlMeetingStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 33303) END MeetingStatus; PROCEDURE (this: _AppointmentItem) PUTMeetingStatus* (p1: OlMeetingStatus), NEW; BEGIN CtlC.PutInt(this, 33303, p1) END PUTMeetingStatus; PROCEDURE (this: _AppointmentItem) NetMeetingAutoStart* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33348) END NetMeetingAutoStart; PROCEDURE (this: _AppointmentItem) PUTNetMeetingAutoStart* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33348, p1) END PUTNetMeetingAutoStart; PROCEDURE (this: _AppointmentItem) NetMeetingOrganizerAlias* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33347) END NetMeetingOrganizerAlias; PROCEDURE (this: _AppointmentItem) PUTNetMeetingOrganizerAlias* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33347, p1) END PUTNetMeetingOrganizerAlias; PROCEDURE (this: _AppointmentItem) NetMeetingServer* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33346) END NetMeetingServer; PROCEDURE (this: _AppointmentItem) PUTNetMeetingServer* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33346, p1) END PUTNetMeetingServer; PROCEDURE (this: _AppointmentItem) NetMeetingType* (): OlNetMeetingType, NEW; BEGIN RETURN CtlC.GetInt(this, 33345) END NetMeetingType; PROCEDURE (this: _AppointmentItem) PUTNetMeetingType* (p1: OlNetMeetingType), NEW; BEGIN CtlC.PutInt(this, 33345, p1) END PUTNetMeetingType; PROCEDURE (this: _AppointmentItem) OptionalAttendees* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3587) END OptionalAttendees; PROCEDURE (this: _AppointmentItem) PUTOptionalAttendees* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3587, p1) END PUTOptionalAttendees; PROCEDURE (this: _AppointmentItem) Organizer* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END Organizer; PROCEDURE (this: _AppointmentItem) Recipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 63508)) END Recipients; PROCEDURE (this: _AppointmentItem) RecurrenceState* (): OlRecurrenceState, NEW; BEGIN RETURN CtlC.GetInt(this, 62789) END RecurrenceState; PROCEDURE (this: _AppointmentItem) ReminderMinutesBeforeStart* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34049) END ReminderMinutesBeforeStart; PROCEDURE (this: _AppointmentItem) PUTReminderMinutesBeforeStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 34049, p1) END PUTReminderMinutesBeforeStart; PROCEDURE (this: _AppointmentItem) ReminderOverrideDefault* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34076) END ReminderOverrideDefault; PROCEDURE (this: _AppointmentItem) PUTReminderOverrideDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34076, p1) END PUTReminderOverrideDefault; PROCEDURE (this: _AppointmentItem) ReminderPlaySound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34078) END ReminderPlaySound; PROCEDURE (this: _AppointmentItem) PUTReminderPlaySound* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34078, p1) END PUTReminderPlaySound; PROCEDURE (this: _AppointmentItem) ReminderSet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34051) END ReminderSet; PROCEDURE (this: _AppointmentItem) PUTReminderSet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34051, p1) END PUTReminderSet; PROCEDURE (this: _AppointmentItem) ReminderSoundFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34079) END ReminderSoundFile; PROCEDURE (this: _AppointmentItem) PUTReminderSoundFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34079, p1) END PUTReminderSoundFile; PROCEDURE (this: _AppointmentItem) ReplyTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33312) END ReplyTime; PROCEDURE (this: _AppointmentItem) PUTReplyTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33312, p1) END PUTReplyTime; PROCEDURE (this: _AppointmentItem) RequiredAttendees* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3588) END RequiredAttendees; PROCEDURE (this: _AppointmentItem) PUTRequiredAttendees* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3588, p1) END PUTRequiredAttendees; PROCEDURE (this: _AppointmentItem) Resources* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3586) END Resources; PROCEDURE (this: _AppointmentItem) PUTResources* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3586, p1) END PUTResources; PROCEDURE (this: _AppointmentItem) ResponseRequested* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 99) END ResponseRequested; PROCEDURE (this: _AppointmentItem) PUTResponseRequested* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 99, p1) END PUTResponseRequested; PROCEDURE (this: _AppointmentItem) ResponseStatus* (): OlResponseStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 33304) END ResponseStatus; PROCEDURE (this: _AppointmentItem) Start* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33293) END Start; PROCEDURE (this: _AppointmentItem) PUTStart* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33293, p1) END PUTStart; PROCEDURE (this: _AppointmentItem) ClearRecurrencePattern* (), NEW; BEGIN CtlC.CallMethod(this, 61605, NIL); END ClearRecurrencePattern; PROCEDURE (this: _AppointmentItem) ForwardAsVcal* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 62791, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END ForwardAsVcal; PROCEDURE (this: _AppointmentItem) GetRecurrencePattern* (): RecurrencePattern, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61604, ret); RETURN ThisRecurrencePattern(CtlC.VarAny(ret)) END GetRecurrencePattern; PROCEDURE (this: _AppointmentItem) Respond* (Response: OlMeetingResponse; (* optional *) fNoUI: CtlT.Any; fAdditionalTextDialog: CtlT.Any): MeetingItem, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Response, arg[2]); CtlC.AnyVar(fNoUI, arg[1]); CtlC.AnyVar(fAdditionalTextDialog, arg[0]); CtlC.CallParMethod(this, 62722, arg, ret); RETURN This_MeetingItem(CtlC.VarAny(ret)) END Respond; PROCEDURE (this: _AppointmentItem) Send* (), NEW; BEGIN CtlC.CallMethod(this, 61557, NIL); END Send; PROCEDURE (this: _AppointmentItem) NetMeetingDocPathName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33351) END NetMeetingDocPathName; PROCEDURE (this: _AppointmentItem) PUTNetMeetingDocPathName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33351, p1) END PUTNetMeetingDocPathName; PROCEDURE (this: _AppointmentItem) NetShowURL* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33352) END NetShowURL; PROCEDURE (this: _AppointmentItem) PUTNetShowURL* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33352, p1) END PUTNetShowURL; PROCEDURE (this: _AppointmentItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; PROCEDURE (this: _AppointmentItem) ConferenceServerAllowExternal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33350) END ConferenceServerAllowExternal; PROCEDURE (this: _AppointmentItem) PUTConferenceServerAllowExternal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33350, p1) END PUTConferenceServerAllowExternal; PROCEDURE (this: _AppointmentItem) ConferenceServerPassword* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33353) END ConferenceServerPassword; PROCEDURE (this: _AppointmentItem) PUTConferenceServerPassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33353, p1) END PUTConferenceServerPassword; (* ---------- Attachments, dual ---------- *) PROCEDURE (this: Attachments) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Attachments) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Attachments) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Attachments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Attachments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Attachments) Item* (Index: CtlT.Any): Attachment, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisAttachment(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Attachments) Add* (Source: CtlT.Any; (* optional *) Type: CtlT.Any; Position: CtlT.Any; DisplayName: CtlT.Any): Attachment, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Source, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Position, arg[1]); CtlC.AnyVar(DisplayName, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisAttachment(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Attachments) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- Attachment, dual ---------- *) PROCEDURE (this: Attachment) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Attachment) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Attachment) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Attachment) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 113) END Parent; PROCEDURE (this: Attachment) DisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END DisplayName; PROCEDURE (this: Attachment) PUTDisplayName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTDisplayName; PROCEDURE (this: Attachment) FileName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14084) END FileName; PROCEDURE (this: Attachment) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 91) END Index; PROCEDURE (this: Attachment) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: Attachment) PathName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14088) END PathName; PROCEDURE (this: Attachment) Position* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 114) END Position; PROCEDURE (this: Attachment) PUTPosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 114, p1) END PUTPosition; PROCEDURE (this: Attachment) Type* (): OlAttachmentType, NEW; BEGIN RETURN CtlC.GetInt(this, 14085) END Type; PROCEDURE (this: Attachment) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END Delete; PROCEDURE (this: Attachment) SaveAsFile* (Path: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END SaveAsFile; (* ---------- FormDescription, dual ---------- *) PROCEDURE (this: FormDescription) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: FormDescription) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: FormDescription) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: FormDescription) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: FormDescription) Category* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 13060) END Category; PROCEDURE (this: FormDescription) PUTCategory* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 13060, p1) END PUTCategory; PROCEDURE (this: FormDescription) CategorySub* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 13061) END CategorySub; PROCEDURE (this: FormDescription) PUTCategorySub* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 13061, p1) END PUTCategorySub; PROCEDURE (this: FormDescription) Comment* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12292) END Comment; PROCEDURE (this: FormDescription) PUTComment* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12292, p1) END PUTComment; PROCEDURE (this: FormDescription) ContactName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 13059) END ContactName; PROCEDURE (this: FormDescription) PUTContactName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 13059, p1) END PUTContactName; PROCEDURE (this: FormDescription) DisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END DisplayName; PROCEDURE (this: FormDescription) PUTDisplayName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTDisplayName; PROCEDURE (this: FormDescription) Hidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13063) END Hidden; PROCEDURE (this: FormDescription) PUTHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13063, p1) END PUTHidden; PROCEDURE (this: FormDescription) Icon* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4093) END Icon; PROCEDURE (this: FormDescription) PUTIcon* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 4093, p1) END PUTIcon; PROCEDURE (this: FormDescription) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 102) END Locked; PROCEDURE (this: FormDescription) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 102, p1) END PUTLocked; PROCEDURE (this: FormDescription) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: FormDescription) MiniIcon* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4092) END MiniIcon; PROCEDURE (this: FormDescription) PUTMiniIcon* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 4092, p1) END PUTMiniIcon; PROCEDURE (this: FormDescription) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61469) END Name; PROCEDURE (this: FormDescription) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61469, p1) END PUTName; PROCEDURE (this: FormDescription) Number* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END Number; PROCEDURE (this: FormDescription) PUTNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTNumber; PROCEDURE (this: FormDescription) OneOff* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 101) END OneOff; PROCEDURE (this: FormDescription) PUTOneOff* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 101, p1) END PUTOneOff; PROCEDURE (this: FormDescription) Password* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END Password; PROCEDURE (this: FormDescription) PUTPassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTPassword; PROCEDURE (this: FormDescription) ScriptText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END ScriptText; PROCEDURE (this: FormDescription) Template* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END Template; PROCEDURE (this: FormDescription) PUTTemplate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTTemplate; PROCEDURE (this: FormDescription) UseWordMail* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 105) END UseWordMail; PROCEDURE (this: FormDescription) PUTUseWordMail* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 105, p1) END PUTUseWordMail; PROCEDURE (this: FormDescription) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 13057) END Version; PROCEDURE (this: FormDescription) PUTVersion* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 13057, p1) END PUTVersion; PROCEDURE (this: FormDescription) PublishForm* (Registry: OlFormRegistry; (* optional *) Folder: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Registry, arg[1]); CtlC.AnyVar(Folder, arg[0]); CtlC.CallParMethod(this, 107, arg, NIL); END PublishForm; (* ---------- UserProperties, dual ---------- *) PROCEDURE (this: UserProperties) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: UserProperties) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: UserProperties) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: UserProperties) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: UserProperties) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: UserProperties) Item* (Index: CtlT.Any): UserProperty, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisUserProperty(CtlC.VarAny(ret)) END Item; PROCEDURE (this: UserProperties) Add* (Name: ARRAY OF CHAR; Type: OlUserPropertyType; (* optional *) AddToFolderFields: CtlT.Any; DisplayFormat: CtlT.Any): UserProperty, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(AddToFolderFields, arg[1]); CtlC.AnyVar(DisplayFormat, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisUserProperty(CtlC.VarAny(ret)) END Add; PROCEDURE (this: UserProperties) Find* (Name: ARRAY OF CHAR; (* optional *) Custom: CtlT.Any): UserProperty, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Custom, arg[0]); CtlC.CallParMethod(this, 103, arg, ret); RETURN ThisUserProperty(CtlC.VarAny(ret)) END Find; PROCEDURE (this: UserProperties) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 82, arg, NIL); END Remove; (* ---------- UserProperty, dual ---------- *) PROCEDURE (this: UserProperty) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: UserProperty) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: UserProperty) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: UserProperty) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: UserProperty) Formula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END Formula; PROCEDURE (this: UserProperty) PUTFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTFormula; PROCEDURE (this: UserProperty) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END Name; PROCEDURE (this: UserProperty) Type* (): OlUserPropertyType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Type; PROCEDURE (this: UserProperty) ValidationFormula* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END ValidationFormula; PROCEDURE (this: UserProperty) PUTValidationFormula* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTValidationFormula; PROCEDURE (this: UserProperty) ValidationText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END ValidationText; PROCEDURE (this: UserProperty) PUTValidationText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTValidationText; PROCEDURE (this: UserProperty) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: UserProperty) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: UserProperty) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 108, NIL); END Delete; (* ---------- Recipients, dual ---------- *) PROCEDURE (this: Recipients) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Recipients) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Recipients) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Recipients) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Recipients) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Recipients) Item* (Index: CtlT.Any): Recipient, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisRecipient(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Recipients) Add* (Name: ARRAY OF CHAR): Recipient, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 111, arg, ret); RETURN ThisRecipient(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Recipients) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; PROCEDURE (this: Recipients) ResolveAll* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 126, ret); RETURN CtlC.VarBool(ret) END ResolveAll; (* ---------- _MailItem, dual ---------- *) PROCEDURE (this: _MailItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _MailItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _MailItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _MailItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _MailItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _MailItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _MailItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _MailItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _MailItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _MailItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _MailItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _MailItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _MailItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _MailItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _MailItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _MailItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _MailItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _MailItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _MailItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _MailItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _MailItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _MailItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _MailItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _MailItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _MailItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _MailItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _MailItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _MailItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _MailItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _MailItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _MailItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _MailItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _MailItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _MailItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _MailItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _MailItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _MailItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _MailItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _MailItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _MailItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _MailItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _MailItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _MailItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _MailItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _MailItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _MailItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _MailItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _MailItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _MailItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _MailItem) AlternateRecipientAllowed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END AlternateRecipientAllowed; PROCEDURE (this: _MailItem) PUTAlternateRecipientAllowed* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTAlternateRecipientAllowed; PROCEDURE (this: _MailItem) AutoForwarded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END AutoForwarded; PROCEDURE (this: _MailItem) PUTAutoForwarded* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTAutoForwarded; PROCEDURE (this: _MailItem) BCC* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3586) END BCC; PROCEDURE (this: _MailItem) PUTBCC* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3586, p1) END PUTBCC; PROCEDURE (this: _MailItem) CC* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3587) END CC; PROCEDURE (this: _MailItem) PUTCC* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3587, p1) END PUTCC; PROCEDURE (this: _MailItem) DeferredDeliveryTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 15) END DeferredDeliveryTime; PROCEDURE (this: _MailItem) PUTDeferredDeliveryTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 15, p1) END PUTDeferredDeliveryTime; PROCEDURE (this: _MailItem) DeleteAfterSubmit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3585) END DeleteAfterSubmit; PROCEDURE (this: _MailItem) PUTDeleteAfterSubmit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3585, p1) END PUTDeleteAfterSubmit; PROCEDURE (this: _MailItem) ExpiryTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 21) END ExpiryTime; PROCEDURE (this: _MailItem) PUTExpiryTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 21, p1) END PUTExpiryTime; PROCEDURE (this: _MailItem) FlagDueBy* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 48) END FlagDueBy; PROCEDURE (this: _MailItem) PUTFlagDueBy* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 48, p1) END PUTFlagDueBy; PROCEDURE (this: _MailItem) FlagRequest* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34096) END FlagRequest; PROCEDURE (this: _MailItem) PUTFlagRequest* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34096, p1) END PUTFlagRequest; PROCEDURE (this: _MailItem) FlagStatus* (): OlFlagStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 4240) END FlagStatus; PROCEDURE (this: _MailItem) PUTFlagStatus* (p1: OlFlagStatus), NEW; BEGIN CtlC.PutInt(this, 4240, p1) END PUTFlagStatus; PROCEDURE (this: _MailItem) HTMLBody* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 62468) END HTMLBody; PROCEDURE (this: _MailItem) PUTHTMLBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 62468, p1) END PUTHTMLBody; PROCEDURE (this: _MailItem) OriginatorDeliveryReportRequested* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END OriginatorDeliveryReportRequested; PROCEDURE (this: _MailItem) PUTOriginatorDeliveryReportRequested* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 35, p1) END PUTOriginatorDeliveryReportRequested; PROCEDURE (this: _MailItem) ReadReceiptRequested* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 41) END ReadReceiptRequested; PROCEDURE (this: _MailItem) PUTReadReceiptRequested* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 41, p1) END PUTReadReceiptRequested; PROCEDURE (this: _MailItem) ReceivedByEntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 63) END ReceivedByEntryID; PROCEDURE (this: _MailItem) ReceivedByName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 64) END ReceivedByName; PROCEDURE (this: _MailItem) ReceivedOnBehalfOfEntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 67) END ReceivedOnBehalfOfEntryID; PROCEDURE (this: _MailItem) ReceivedOnBehalfOfName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 68) END ReceivedOnBehalfOfName; PROCEDURE (this: _MailItem) ReceivedTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 3590) END ReceivedTime; PROCEDURE (this: _MailItem) RecipientReassignmentProhibited* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 43) END RecipientReassignmentProhibited; PROCEDURE (this: _MailItem) PUTRecipientReassignmentProhibited* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 43, p1) END PUTRecipientReassignmentProhibited; PROCEDURE (this: _MailItem) Recipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 63508)) END Recipients; PROCEDURE (this: _MailItem) ReminderOverrideDefault* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34076) END ReminderOverrideDefault; PROCEDURE (this: _MailItem) PUTReminderOverrideDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34076, p1) END PUTReminderOverrideDefault; PROCEDURE (this: _MailItem) ReminderPlaySound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34078) END ReminderPlaySound; PROCEDURE (this: _MailItem) PUTReminderPlaySound* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34078, p1) END PUTReminderPlaySound; PROCEDURE (this: _MailItem) ReminderSet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34051) END ReminderSet; PROCEDURE (this: _MailItem) PUTReminderSet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34051, p1) END PUTReminderSet; PROCEDURE (this: _MailItem) ReminderSoundFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34079) END ReminderSoundFile; PROCEDURE (this: _MailItem) PUTReminderSoundFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34079, p1) END PUTReminderSoundFile; PROCEDURE (this: _MailItem) ReminderTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 34050) END ReminderTime; PROCEDURE (this: _MailItem) PUTReminderTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 34050, p1) END PUTReminderTime; PROCEDURE (this: _MailItem) RemoteStatus* (): OlRemoteStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 34065) END RemoteStatus; PROCEDURE (this: _MailItem) PUTRemoteStatus* (p1: OlRemoteStatus), NEW; BEGIN CtlC.PutInt(this, 34065, p1) END PUTRemoteStatus; PROCEDURE (this: _MailItem) ReplyRecipientNames* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 80) END ReplyRecipientNames; PROCEDURE (this: _MailItem) ReplyRecipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 61459)) END ReplyRecipients; PROCEDURE (this: _MailItem) SaveSentMessageFolder* (): MAPIFolder, NEW; BEGIN RETURN ThisMAPIFolder(CtlC.GetAny(this, 62465)) END SaveSentMessageFolder; PROCEDURE (this: _MailItem) PUTREFSaveSentMessageFolder* (p1: MAPIFolder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 62465, arg, NIL); END PUTREFSaveSentMessageFolder; PROCEDURE (this: _MailItem) SenderName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3098) END SenderName; PROCEDURE (this: _MailItem) Sent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62466) END Sent; PROCEDURE (this: _MailItem) SentOn* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 57) END SentOn; PROCEDURE (this: _MailItem) SentOnBehalfOfName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END SentOnBehalfOfName; PROCEDURE (this: _MailItem) PUTSentOnBehalfOfName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 66, p1) END PUTSentOnBehalfOfName; PROCEDURE (this: _MailItem) Submitted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62467) END Submitted; PROCEDURE (this: _MailItem) To* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3588) END To; PROCEDURE (this: _MailItem) PUTTo* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3588, p1) END PUTTo; PROCEDURE (this: _MailItem) VotingOptions* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61467) END VotingOptions; PROCEDURE (this: _MailItem) PUTVotingOptions* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 61467, p1) END PUTVotingOptions; PROCEDURE (this: _MailItem) VotingResponse* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34084) END VotingResponse; PROCEDURE (this: _MailItem) PUTVotingResponse* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34084, p1) END PUTVotingResponse; PROCEDURE (this: _MailItem) ClearConversationIndex* (), NEW; BEGIN CtlC.CallMethod(this, 63522, NIL); END ClearConversationIndex; PROCEDURE (this: _MailItem) Forward* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63507, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Forward; PROCEDURE (this: _MailItem) Reply* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63504, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Reply; PROCEDURE (this: _MailItem) ReplyAll* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63505, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END ReplyAll; PROCEDURE (this: _MailItem) Send* (), NEW; BEGIN CtlC.CallMethod(this, 61557, NIL); END Send; PROCEDURE (this: _MailItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- Links, dual ---------- *) PROCEDURE (this: Links) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Links) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Links) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Links) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Links) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Links) Item* (Index: CtlT.Any): Link, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisLink(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Links) Add* (Item: CtlT.Object): Link, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Item, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN ThisLink(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Links) Remove* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- Link, dual ---------- *) PROCEDURE (this: Link) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Link) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Link) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Link) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 109) END Parent; PROCEDURE (this: Link) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END Name; PROCEDURE (this: Link) Type* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 8449) END Type; PROCEDURE (this: Link) Item* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8450) END Item; (* ---------- ItemEvents ---------- *) PROCEDURE (this: ItemEvents) Open* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) CustomAction* (Action: CtlT.Object; Response: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) CustomPropertyChange* (Name: ARRAY OF CHAR), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Forward* (Forward: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Close* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) PropertyChange* (Name: ARRAY OF CHAR), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Read* (), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Reply* (Response: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) ReplyAll* (Response: CtlT.Object; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Send* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Write* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) BeforeCheckNames* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) AttachmentAdd* (attachment: Attachment), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) AttachmentRead* (attachment: Attachment), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) BeforeAttachmentSave* (attachment: Attachment; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ItemEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61443: ASSERT(n = 1, 11); this.Open(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61446: ASSERT(n = 3, 11); this.CustomAction(CtlC.VarObj(par[2]), CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61448: ASSERT(n = 1, 11); this.CustomPropertyChange(CtlC.VarStr(par[0])) | 62568: ASSERT(n = 2, 11); this.Forward(CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61444: ASSERT(n = 1, 11); this.Close(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61449: ASSERT(n = 1, 11); this.PropertyChange(CtlC.VarStr(par[0])) | 61441: ASSERT(n = 0, 11); this.Read() | 62566: ASSERT(n = 2, 11); this.Reply(CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 62567: ASSERT(n = 2, 11); this.ReplyAll(CtlC.VarObj(par[1]), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61445: ASSERT(n = 1, 11); this.Send(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61442: ASSERT(n = 1, 11); this.Write(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61450: ASSERT(n = 1, 11); this.BeforeCheckNames(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61451: ASSERT(n = 1, 11); this.AttachmentAdd(ThisAttachment(CtlC.VarAny(par[0]))) | 61452: ASSERT(n = 1, 11); this.AttachmentRead(ThisAttachment(CtlC.VarAny(par[0]))) | 61453: ASSERT(n = 2, 11); this.BeforeAttachmentSave(ThisAttachment(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: ItemEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006303A-0000-0000-C000-000000000046}" END GetIID; (* ---------- RecurrencePattern, dual ---------- *) PROCEDURE (this: RecurrencePattern) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: RecurrencePattern) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: RecurrencePattern) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: RecurrencePattern) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: RecurrencePattern) DayOfMonth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4096) END DayOfMonth; PROCEDURE (this: RecurrencePattern) PUTDayOfMonth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4096, p1) END PUTDayOfMonth; PROCEDURE (this: RecurrencePattern) DayOfWeekMask* (): OlDaysOfWeek, NEW; BEGIN RETURN CtlC.GetInt(this, 4097) END DayOfWeekMask; PROCEDURE (this: RecurrencePattern) PUTDayOfWeekMask* (p1: OlDaysOfWeek), NEW; BEGIN CtlC.PutInt(this, 4097, p1) END PUTDayOfWeekMask; PROCEDURE (this: RecurrencePattern) Duration* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4109) END Duration; PROCEDURE (this: RecurrencePattern) PUTDuration* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4109, p1) END PUTDuration; PROCEDURE (this: RecurrencePattern) EndTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 4108) END EndTime; PROCEDURE (this: RecurrencePattern) PUTEndTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 4108, p1) END PUTEndTime; PROCEDURE (this: RecurrencePattern) Exceptions* (): Exceptions, NEW; BEGIN RETURN ThisExceptions(CtlC.GetAny(this, 4110)) END Exceptions; PROCEDURE (this: RecurrencePattern) Instance* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4099) END Instance; PROCEDURE (this: RecurrencePattern) PUTInstance* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4099, p1) END PUTInstance; PROCEDURE (this: RecurrencePattern) Interval* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4100) END Interval; PROCEDURE (this: RecurrencePattern) PUTInterval* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4100, p1) END PUTInterval; PROCEDURE (this: RecurrencePattern) MonthOfYear* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4102) END MonthOfYear; PROCEDURE (this: RecurrencePattern) PUTMonthOfYear* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4102, p1) END PUTMonthOfYear; PROCEDURE (this: RecurrencePattern) NoEndDate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4107) END NoEndDate; PROCEDURE (this: RecurrencePattern) PUTNoEndDate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4107, p1) END PUTNoEndDate; PROCEDURE (this: RecurrencePattern) Occurrences* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4101) END Occurrences; PROCEDURE (this: RecurrencePattern) PUTOccurrences* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4101, p1) END PUTOccurrences; PROCEDURE (this: RecurrencePattern) PatternEndDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 4098) END PatternEndDate; PROCEDURE (this: RecurrencePattern) PUTPatternEndDate* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 4098, p1) END PUTPatternEndDate; PROCEDURE (this: RecurrencePattern) PatternStartDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 4104) END PatternStartDate; PROCEDURE (this: RecurrencePattern) PUTPatternStartDate* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 4104, p1) END PUTPatternStartDate; PROCEDURE (this: RecurrencePattern) RecurrenceType* (): OlRecurrenceType, NEW; BEGIN RETURN CtlC.GetInt(this, 4103) END RecurrenceType; PROCEDURE (this: RecurrencePattern) PUTRecurrenceType* (p1: OlRecurrenceType), NEW; BEGIN CtlC.PutInt(this, 4103, p1) END PUTRecurrenceType; PROCEDURE (this: RecurrencePattern) Regenerate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4106) END Regenerate; PROCEDURE (this: RecurrencePattern) PUTRegenerate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4106, p1) END PUTRegenerate; PROCEDURE (this: RecurrencePattern) StartTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 4105) END StartTime; PROCEDURE (this: RecurrencePattern) PUTStartTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 4105, p1) END PUTStartTime; PROCEDURE (this: RecurrencePattern) GetOccurrence* (StartDate: CtlT.OleDate): AppointmentItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.DateVar(StartDate, arg[0]); CtlC.CallParMethod(this, 4111, arg, ret); RETURN This_AppointmentItem(CtlC.VarAny(ret)) END GetOccurrence; (* ---------- Exceptions, dual ---------- *) PROCEDURE (this: Exceptions) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Exceptions) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Exceptions) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Exceptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Exceptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Exceptions) Item* (Index: CtlT.Any): Exception, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisException(CtlC.VarAny(ret)) END Item; (* ---------- Exception, dual ---------- *) PROCEDURE (this: Exception) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Exception) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Exception) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Exception) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Exception) AppointmentItem* (): AppointmentItem, NEW; BEGIN RETURN This_AppointmentItem(CtlC.GetAny(this, 8193)) END AppointmentItem; PROCEDURE (this: Exception) Deleted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8194) END Deleted; PROCEDURE (this: Exception) OriginalDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 8192) END OriginalDate; (* ---------- _MeetingItem, dual ---------- *) PROCEDURE (this: _MeetingItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _MeetingItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _MeetingItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _MeetingItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _MeetingItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _MeetingItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _MeetingItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _MeetingItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _MeetingItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _MeetingItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _MeetingItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _MeetingItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _MeetingItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _MeetingItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _MeetingItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _MeetingItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _MeetingItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _MeetingItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _MeetingItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _MeetingItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _MeetingItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _MeetingItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _MeetingItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _MeetingItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _MeetingItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _MeetingItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _MeetingItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _MeetingItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _MeetingItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _MeetingItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _MeetingItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _MeetingItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _MeetingItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _MeetingItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _MeetingItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _MeetingItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _MeetingItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _MeetingItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _MeetingItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _MeetingItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _MeetingItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _MeetingItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _MeetingItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _MeetingItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _MeetingItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _MeetingItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _MeetingItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _MeetingItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _MeetingItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _MeetingItem) AutoForwarded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END AutoForwarded; PROCEDURE (this: _MeetingItem) PUTAutoForwarded* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTAutoForwarded; PROCEDURE (this: _MeetingItem) DeferredDeliveryTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 15) END DeferredDeliveryTime; PROCEDURE (this: _MeetingItem) PUTDeferredDeliveryTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 15, p1) END PUTDeferredDeliveryTime; PROCEDURE (this: _MeetingItem) DeleteAfterSubmit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3585) END DeleteAfterSubmit; PROCEDURE (this: _MeetingItem) PUTDeleteAfterSubmit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3585, p1) END PUTDeleteAfterSubmit; PROCEDURE (this: _MeetingItem) ExpiryTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 21) END ExpiryTime; PROCEDURE (this: _MeetingItem) PUTExpiryTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 21, p1) END PUTExpiryTime; PROCEDURE (this: _MeetingItem) FlagDueBy* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 48) END FlagDueBy; PROCEDURE (this: _MeetingItem) PUTFlagDueBy* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 48, p1) END PUTFlagDueBy; PROCEDURE (this: _MeetingItem) FlagRequest* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34096) END FlagRequest; PROCEDURE (this: _MeetingItem) PUTFlagRequest* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34096, p1) END PUTFlagRequest; PROCEDURE (this: _MeetingItem) FlagStatus* (): OlFlagStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 4240) END FlagStatus; PROCEDURE (this: _MeetingItem) PUTFlagStatus* (p1: OlFlagStatus), NEW; BEGIN CtlC.PutInt(this, 4240, p1) END PUTFlagStatus; PROCEDURE (this: _MeetingItem) OriginatorDeliveryReportRequested* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END OriginatorDeliveryReportRequested; PROCEDURE (this: _MeetingItem) PUTOriginatorDeliveryReportRequested* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 35, p1) END PUTOriginatorDeliveryReportRequested; PROCEDURE (this: _MeetingItem) ReceivedTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 3590) END ReceivedTime; PROCEDURE (this: _MeetingItem) PUTReceivedTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 3590, p1) END PUTReceivedTime; PROCEDURE (this: _MeetingItem) Recipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 63508)) END Recipients; PROCEDURE (this: _MeetingItem) ReminderSet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34051) END ReminderSet; PROCEDURE (this: _MeetingItem) PUTReminderSet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34051, p1) END PUTReminderSet; PROCEDURE (this: _MeetingItem) ReminderTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 34050) END ReminderTime; PROCEDURE (this: _MeetingItem) PUTReminderTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 34050, p1) END PUTReminderTime; PROCEDURE (this: _MeetingItem) ReplyRecipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 61459)) END ReplyRecipients; PROCEDURE (this: _MeetingItem) SaveSentMessageFolder* (): MAPIFolder, NEW; BEGIN RETURN ThisMAPIFolder(CtlC.GetAny(this, 62465)) END SaveSentMessageFolder; PROCEDURE (this: _MeetingItem) PUTREFSaveSentMessageFolder* (p1: MAPIFolder), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 62465, arg, NIL); END PUTREFSaveSentMessageFolder; PROCEDURE (this: _MeetingItem) SenderName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3098) END SenderName; PROCEDURE (this: _MeetingItem) Sent* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62466) END Sent; PROCEDURE (this: _MeetingItem) SentOn* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 57) END SentOn; PROCEDURE (this: _MeetingItem) Submitted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62467) END Submitted; PROCEDURE (this: _MeetingItem) Forward* (): MeetingItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63507, ret); RETURN This_MeetingItem(CtlC.VarAny(ret)) END Forward; PROCEDURE (this: _MeetingItem) GetAssociatedAppointment* (AddToCalendar: BOOLEAN): AppointmentItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(AddToCalendar, arg[0]); CtlC.CallParMethod(this, 63328, arg, ret); RETURN This_AppointmentItem(CtlC.VarAny(ret)) END GetAssociatedAppointment; PROCEDURE (this: _MeetingItem) Reply* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63504, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Reply; PROCEDURE (this: _MeetingItem) ReplyAll* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63505, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END ReplyAll; PROCEDURE (this: _MeetingItem) Send* (), NEW; BEGIN CtlC.CallMethod(this, 61557, NIL); END Send; PROCEDURE (this: _MeetingItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _ContactItem, dual ---------- *) PROCEDURE (this: _ContactItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _ContactItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _ContactItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _ContactItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _ContactItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _ContactItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _ContactItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _ContactItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _ContactItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _ContactItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _ContactItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _ContactItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _ContactItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _ContactItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _ContactItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _ContactItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _ContactItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _ContactItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _ContactItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _ContactItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _ContactItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _ContactItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _ContactItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _ContactItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _ContactItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _ContactItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _ContactItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _ContactItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _ContactItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _ContactItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _ContactItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _ContactItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _ContactItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _ContactItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _ContactItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _ContactItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _ContactItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _ContactItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _ContactItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _ContactItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _ContactItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _ContactItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _ContactItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _ContactItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _ContactItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _ContactItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _ContactItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _ContactItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _ContactItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _ContactItem) Account* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14848) END Account; PROCEDURE (this: _ContactItem) PUTAccount* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14848, p1) END PUTAccount; PROCEDURE (this: _ContactItem) Anniversary* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 14913) END Anniversary; PROCEDURE (this: _ContactItem) PUTAnniversary* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 14913, p1) END PUTAnniversary; PROCEDURE (this: _ContactItem) AssistantName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14896) END AssistantName; PROCEDURE (this: _ContactItem) PUTAssistantName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14896, p1) END PUTAssistantName; PROCEDURE (this: _ContactItem) AssistantTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14894) END AssistantTelephoneNumber; PROCEDURE (this: _ContactItem) PUTAssistantTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14894, p1) END PUTAssistantTelephoneNumber; PROCEDURE (this: _ContactItem) Birthday* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 14914) END Birthday; PROCEDURE (this: _ContactItem) PUTBirthday* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 14914, p1) END PUTBirthday; PROCEDURE (this: _ContactItem) Business2TelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14875) END Business2TelephoneNumber; PROCEDURE (this: _ContactItem) PUTBusiness2TelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14875, p1) END PUTBusiness2TelephoneNumber; PROCEDURE (this: _ContactItem) BusinessAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32795) END BusinessAddress; PROCEDURE (this: _ContactItem) PUTBusinessAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32795, p1) END PUTBusinessAddress; PROCEDURE (this: _ContactItem) BusinessAddressCity* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32838) END BusinessAddressCity; PROCEDURE (this: _ContactItem) PUTBusinessAddressCity* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32838, p1) END PUTBusinessAddressCity; PROCEDURE (this: _ContactItem) BusinessAddressCountry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32841) END BusinessAddressCountry; PROCEDURE (this: _ContactItem) PUTBusinessAddressCountry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32841, p1) END PUTBusinessAddressCountry; PROCEDURE (this: _ContactItem) BusinessAddressPostalCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32840) END BusinessAddressPostalCode; PROCEDURE (this: _ContactItem) PUTBusinessAddressPostalCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32840, p1) END PUTBusinessAddressPostalCode; PROCEDURE (this: _ContactItem) BusinessAddressPostOfficeBox* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32842) END BusinessAddressPostOfficeBox; PROCEDURE (this: _ContactItem) PUTBusinessAddressPostOfficeBox* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32842, p1) END PUTBusinessAddressPostOfficeBox; PROCEDURE (this: _ContactItem) BusinessAddressState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32839) END BusinessAddressState; PROCEDURE (this: _ContactItem) PUTBusinessAddressState* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32839, p1) END PUTBusinessAddressState; PROCEDURE (this: _ContactItem) BusinessAddressStreet* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32837) END BusinessAddressStreet; PROCEDURE (this: _ContactItem) PUTBusinessAddressStreet* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32837, p1) END PUTBusinessAddressStreet; PROCEDURE (this: _ContactItem) BusinessFaxNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14884) END BusinessFaxNumber; PROCEDURE (this: _ContactItem) PUTBusinessFaxNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14884, p1) END PUTBusinessFaxNumber; PROCEDURE (this: _ContactItem) BusinessHomePage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14929) END BusinessHomePage; PROCEDURE (this: _ContactItem) PUTBusinessHomePage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14929, p1) END PUTBusinessHomePage; PROCEDURE (this: _ContactItem) BusinessTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14856) END BusinessTelephoneNumber; PROCEDURE (this: _ContactItem) PUTBusinessTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14856, p1) END PUTBusinessTelephoneNumber; PROCEDURE (this: _ContactItem) CallbackTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14850) END CallbackTelephoneNumber; PROCEDURE (this: _ContactItem) PUTCallbackTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14850, p1) END PUTCallbackTelephoneNumber; PROCEDURE (this: _ContactItem) CarTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14878) END CarTelephoneNumber; PROCEDURE (this: _ContactItem) PUTCarTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14878, p1) END PUTCarTelephoneNumber; PROCEDURE (this: _ContactItem) Children* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32780) END Children; PROCEDURE (this: _ContactItem) PUTChildren* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32780, p1) END PUTChildren; PROCEDURE (this: _ContactItem) CompanyAndFullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32792) END CompanyAndFullName; PROCEDURE (this: _ContactItem) CompanyLastFirstNoSpace* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32818) END CompanyLastFirstNoSpace; PROCEDURE (this: _ContactItem) CompanyLastFirstSpaceOnly* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32819) END CompanyLastFirstSpaceOnly; PROCEDURE (this: _ContactItem) CompanyMainTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14935) END CompanyMainTelephoneNumber; PROCEDURE (this: _ContactItem) PUTCompanyMainTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14935, p1) END PUTCompanyMainTelephoneNumber; PROCEDURE (this: _ContactItem) CompanyName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14870) END CompanyName; PROCEDURE (this: _ContactItem) PUTCompanyName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14870, p1) END PUTCompanyName; PROCEDURE (this: _ContactItem) ComputerNetworkName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14921) END ComputerNetworkName; PROCEDURE (this: _ContactItem) PUTComputerNetworkName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14921, p1) END PUTComputerNetworkName; PROCEDURE (this: _ContactItem) CustomerID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14922) END CustomerID; PROCEDURE (this: _ContactItem) PUTCustomerID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14922, p1) END PUTCustomerID; PROCEDURE (this: _ContactItem) Department* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14872) END Department; PROCEDURE (this: _ContactItem) PUTDepartment* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14872, p1) END PUTDepartment; PROCEDURE (this: _ContactItem) Email1Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32899) END Email1Address; PROCEDURE (this: _ContactItem) PUTEmail1Address* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32899, p1) END PUTEmail1Address; PROCEDURE (this: _ContactItem) Email1AddressType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32898) END Email1AddressType; PROCEDURE (this: _ContactItem) PUTEmail1AddressType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32898, p1) END PUTEmail1AddressType; PROCEDURE (this: _ContactItem) Email1DisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32896) END Email1DisplayName; PROCEDURE (this: _ContactItem) Email1EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32901) END Email1EntryID; PROCEDURE (this: _ContactItem) Email2Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32915) END Email2Address; PROCEDURE (this: _ContactItem) PUTEmail2Address* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32915, p1) END PUTEmail2Address; PROCEDURE (this: _ContactItem) Email2AddressType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32914) END Email2AddressType; PROCEDURE (this: _ContactItem) PUTEmail2AddressType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32914, p1) END PUTEmail2AddressType; PROCEDURE (this: _ContactItem) Email2DisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32912) END Email2DisplayName; PROCEDURE (this: _ContactItem) Email2EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32917) END Email2EntryID; PROCEDURE (this: _ContactItem) Email3Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32931) END Email3Address; PROCEDURE (this: _ContactItem) PUTEmail3Address* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32931, p1) END PUTEmail3Address; PROCEDURE (this: _ContactItem) Email3AddressType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32930) END Email3AddressType; PROCEDURE (this: _ContactItem) PUTEmail3AddressType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32930, p1) END PUTEmail3AddressType; PROCEDURE (this: _ContactItem) Email3DisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32928) END Email3DisplayName; PROCEDURE (this: _ContactItem) Email3EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32933) END Email3EntryID; PROCEDURE (this: _ContactItem) FileAs* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32773) END FileAs; PROCEDURE (this: _ContactItem) PUTFileAs* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32773, p1) END PUTFileAs; PROCEDURE (this: _ContactItem) FirstName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14854) END FirstName; PROCEDURE (this: _ContactItem) PUTFirstName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14854, p1) END PUTFirstName; PROCEDURE (this: _ContactItem) FTPSite* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14924) END FTPSite; PROCEDURE (this: _ContactItem) PUTFTPSite* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14924, p1) END PUTFTPSite; PROCEDURE (this: _ContactItem) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12289) END FullName; PROCEDURE (this: _ContactItem) PUTFullName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 12289, p1) END PUTFullName; PROCEDURE (this: _ContactItem) FullNameAndCompany* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32793) END FullNameAndCompany; PROCEDURE (this: _ContactItem) Gender* (): OlGender, NEW; BEGIN RETURN CtlC.GetInt(this, 14925) END Gender; PROCEDURE (this: _ContactItem) PUTGender* (p1: OlGender), NEW; BEGIN CtlC.PutInt(this, 14925, p1) END PUTGender; PROCEDURE (this: _ContactItem) GovernmentIDNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14855) END GovernmentIDNumber; PROCEDURE (this: _ContactItem) PUTGovernmentIDNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14855, p1) END PUTGovernmentIDNumber; PROCEDURE (this: _ContactItem) Hobby* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14915) END Hobby; PROCEDURE (this: _ContactItem) PUTHobby* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14915, p1) END PUTHobby; PROCEDURE (this: _ContactItem) Home2TelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14895) END Home2TelephoneNumber; PROCEDURE (this: _ContactItem) PUTHome2TelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14895, p1) END PUTHome2TelephoneNumber; PROCEDURE (this: _ContactItem) HomeAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32794) END HomeAddress; PROCEDURE (this: _ContactItem) PUTHomeAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32794, p1) END PUTHomeAddress; PROCEDURE (this: _ContactItem) HomeAddressCity* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14937) END HomeAddressCity; PROCEDURE (this: _ContactItem) PUTHomeAddressCity* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14937, p1) END PUTHomeAddressCity; PROCEDURE (this: _ContactItem) HomeAddressCountry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14938) END HomeAddressCountry; PROCEDURE (this: _ContactItem) PUTHomeAddressCountry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14938, p1) END PUTHomeAddressCountry; PROCEDURE (this: _ContactItem) HomeAddressPostalCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14939) END HomeAddressPostalCode; PROCEDURE (this: _ContactItem) PUTHomeAddressPostalCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14939, p1) END PUTHomeAddressPostalCode; PROCEDURE (this: _ContactItem) HomeAddressPostOfficeBox* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14942) END HomeAddressPostOfficeBox; PROCEDURE (this: _ContactItem) PUTHomeAddressPostOfficeBox* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14942, p1) END PUTHomeAddressPostOfficeBox; PROCEDURE (this: _ContactItem) HomeAddressState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14940) END HomeAddressState; PROCEDURE (this: _ContactItem) PUTHomeAddressState* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14940, p1) END PUTHomeAddressState; PROCEDURE (this: _ContactItem) HomeAddressStreet* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14941) END HomeAddressStreet; PROCEDURE (this: _ContactItem) PUTHomeAddressStreet* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14941, p1) END PUTHomeAddressStreet; PROCEDURE (this: _ContactItem) HomeFaxNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14885) END HomeFaxNumber; PROCEDURE (this: _ContactItem) PUTHomeFaxNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14885, p1) END PUTHomeFaxNumber; PROCEDURE (this: _ContactItem) HomeTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14857) END HomeTelephoneNumber; PROCEDURE (this: _ContactItem) PUTHomeTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14857, p1) END PUTHomeTelephoneNumber; PROCEDURE (this: _ContactItem) Initials* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14858) END Initials; PROCEDURE (this: _ContactItem) PUTInitials* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14858, p1) END PUTInitials; PROCEDURE (this: _ContactItem) InternetFreeBusyAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32984) END InternetFreeBusyAddress; PROCEDURE (this: _ContactItem) PUTInternetFreeBusyAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32984, p1) END PUTInternetFreeBusyAddress; PROCEDURE (this: _ContactItem) ISDNNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14893) END ISDNNumber; PROCEDURE (this: _ContactItem) PUTISDNNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14893, p1) END PUTISDNNumber; PROCEDURE (this: _ContactItem) JobTitle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14871) END JobTitle; PROCEDURE (this: _ContactItem) PUTJobTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14871, p1) END PUTJobTitle; PROCEDURE (this: _ContactItem) Journal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 32805) END Journal; PROCEDURE (this: _ContactItem) PUTJournal* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 32805, p1) END PUTJournal; PROCEDURE (this: _ContactItem) Language* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14860) END Language; PROCEDURE (this: _ContactItem) PUTLanguage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14860, p1) END PUTLanguage; PROCEDURE (this: _ContactItem) LastFirstAndSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32822) END LastFirstAndSuffix; PROCEDURE (this: _ContactItem) LastFirstNoSpace* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32816) END LastFirstNoSpace; PROCEDURE (this: _ContactItem) LastFirstNoSpaceCompany* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32820) END LastFirstNoSpaceCompany; PROCEDURE (this: _ContactItem) LastFirstSpaceOnly* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32817) END LastFirstSpaceOnly; PROCEDURE (this: _ContactItem) LastFirstSpaceOnlyCompany* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32821) END LastFirstSpaceOnlyCompany; PROCEDURE (this: _ContactItem) LastName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14865) END LastName; PROCEDURE (this: _ContactItem) PUTLastName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14865, p1) END PUTLastName; PROCEDURE (this: _ContactItem) LastNameAndFirstName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32791) END LastNameAndFirstName; PROCEDURE (this: _ContactItem) MailingAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14869) END MailingAddress; PROCEDURE (this: _ContactItem) PUTMailingAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14869, p1) END PUTMailingAddress; PROCEDURE (this: _ContactItem) MailingAddressCity* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14887) END MailingAddressCity; PROCEDURE (this: _ContactItem) PUTMailingAddressCity* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14887, p1) END PUTMailingAddressCity; PROCEDURE (this: _ContactItem) MailingAddressCountry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14886) END MailingAddressCountry; PROCEDURE (this: _ContactItem) PUTMailingAddressCountry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14886, p1) END PUTMailingAddressCountry; PROCEDURE (this: _ContactItem) MailingAddressPostalCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14890) END MailingAddressPostalCode; PROCEDURE (this: _ContactItem) PUTMailingAddressPostalCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14890, p1) END PUTMailingAddressPostalCode; PROCEDURE (this: _ContactItem) MailingAddressPostOfficeBox* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14891) END MailingAddressPostOfficeBox; PROCEDURE (this: _ContactItem) PUTMailingAddressPostOfficeBox* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14891, p1) END PUTMailingAddressPostOfficeBox; PROCEDURE (this: _ContactItem) MailingAddressState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14888) END MailingAddressState; PROCEDURE (this: _ContactItem) PUTMailingAddressState* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14888, p1) END PUTMailingAddressState; PROCEDURE (this: _ContactItem) MailingAddressStreet* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14889) END MailingAddressStreet; PROCEDURE (this: _ContactItem) PUTMailingAddressStreet* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14889, p1) END PUTMailingAddressStreet; PROCEDURE (this: _ContactItem) ManagerName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14926) END ManagerName; PROCEDURE (this: _ContactItem) PUTManagerName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14926, p1) END PUTManagerName; PROCEDURE (this: _ContactItem) MiddleName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14916) END MiddleName; PROCEDURE (this: _ContactItem) PUTMiddleName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14916, p1) END PUTMiddleName; PROCEDURE (this: _ContactItem) MobileTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14876) END MobileTelephoneNumber; PROCEDURE (this: _ContactItem) PUTMobileTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14876, p1) END PUTMobileTelephoneNumber; PROCEDURE (this: _ContactItem) NetMeetingAlias* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32863) END NetMeetingAlias; PROCEDURE (this: _ContactItem) PUTNetMeetingAlias* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32863, p1) END PUTNetMeetingAlias; PROCEDURE (this: _ContactItem) NetMeetingServer* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32864) END NetMeetingServer; PROCEDURE (this: _ContactItem) PUTNetMeetingServer* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32864, p1) END PUTNetMeetingServer; PROCEDURE (this: _ContactItem) NickName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14927) END NickName; PROCEDURE (this: _ContactItem) PUTNickName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14927, p1) END PUTNickName; PROCEDURE (this: _ContactItem) OfficeLocation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14873) END OfficeLocation; PROCEDURE (this: _ContactItem) PUTOfficeLocation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14873, p1) END PUTOfficeLocation; PROCEDURE (this: _ContactItem) OrganizationalIDNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14864) END OrganizationalIDNumber; PROCEDURE (this: _ContactItem) PUTOrganizationalIDNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14864, p1) END PUTOrganizationalIDNumber; PROCEDURE (this: _ContactItem) OtherAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32796) END OtherAddress; PROCEDURE (this: _ContactItem) PUTOtherAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32796, p1) END PUTOtherAddress; PROCEDURE (this: _ContactItem) OtherAddressCity* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14943) END OtherAddressCity; PROCEDURE (this: _ContactItem) PUTOtherAddressCity* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14943, p1) END PUTOtherAddressCity; PROCEDURE (this: _ContactItem) OtherAddressCountry* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14944) END OtherAddressCountry; PROCEDURE (this: _ContactItem) PUTOtherAddressCountry* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14944, p1) END PUTOtherAddressCountry; PROCEDURE (this: _ContactItem) OtherAddressPostalCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14945) END OtherAddressPostalCode; PROCEDURE (this: _ContactItem) PUTOtherAddressPostalCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14945, p1) END PUTOtherAddressPostalCode; PROCEDURE (this: _ContactItem) OtherAddressPostOfficeBox* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14948) END OtherAddressPostOfficeBox; PROCEDURE (this: _ContactItem) PUTOtherAddressPostOfficeBox* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14948, p1) END PUTOtherAddressPostOfficeBox; PROCEDURE (this: _ContactItem) OtherAddressState* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14946) END OtherAddressState; PROCEDURE (this: _ContactItem) PUTOtherAddressState* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14946, p1) END PUTOtherAddressState; PROCEDURE (this: _ContactItem) OtherAddressStreet* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14947) END OtherAddressStreet; PROCEDURE (this: _ContactItem) PUTOtherAddressStreet* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14947, p1) END PUTOtherAddressStreet; PROCEDURE (this: _ContactItem) OtherFaxNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14883) END OtherFaxNumber; PROCEDURE (this: _ContactItem) PUTOtherFaxNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14883, p1) END PUTOtherFaxNumber; PROCEDURE (this: _ContactItem) OtherTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14879) END OtherTelephoneNumber; PROCEDURE (this: _ContactItem) PUTOtherTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14879, p1) END PUTOtherTelephoneNumber; PROCEDURE (this: _ContactItem) PagerNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14881) END PagerNumber; PROCEDURE (this: _ContactItem) PUTPagerNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14881, p1) END PUTPagerNumber; PROCEDURE (this: _ContactItem) PersonalHomePage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14928) END PersonalHomePage; PROCEDURE (this: _ContactItem) PUTPersonalHomePage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14928, p1) END PUTPersonalHomePage; PROCEDURE (this: _ContactItem) PrimaryTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14874) END PrimaryTelephoneNumber; PROCEDURE (this: _ContactItem) PUTPrimaryTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14874, p1) END PUTPrimaryTelephoneNumber; PROCEDURE (this: _ContactItem) Profession* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14918) END Profession; PROCEDURE (this: _ContactItem) PUTProfession* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14918, p1) END PUTProfession; PROCEDURE (this: _ContactItem) RadioTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14877) END RadioTelephoneNumber; PROCEDURE (this: _ContactItem) PUTRadioTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14877, p1) END PUTRadioTelephoneNumber; PROCEDURE (this: _ContactItem) ReferredBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14919) END ReferredBy; PROCEDURE (this: _ContactItem) PUTReferredBy* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14919, p1) END PUTReferredBy; PROCEDURE (this: _ContactItem) SelectedMailingAddress* (): OlMailingAddress, NEW; BEGIN RETURN CtlC.GetInt(this, 32802) END SelectedMailingAddress; PROCEDURE (this: _ContactItem) PUTSelectedMailingAddress* (p1: OlMailingAddress), NEW; BEGIN CtlC.PutInt(this, 32802, p1) END PUTSelectedMailingAddress; PROCEDURE (this: _ContactItem) Spouse* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14920) END Spouse; PROCEDURE (this: _ContactItem) PUTSpouse* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14920, p1) END PUTSpouse; PROCEDURE (this: _ContactItem) Suffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14853) END Suffix; PROCEDURE (this: _ContactItem) PUTSuffix* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14853, p1) END PUTSuffix; PROCEDURE (this: _ContactItem) TelexNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14892) END TelexNumber; PROCEDURE (this: _ContactItem) PUTTelexNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14892, p1) END PUTTelexNumber; PROCEDURE (this: _ContactItem) Title* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14917) END Title; PROCEDURE (this: _ContactItem) PUTTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14917, p1) END PUTTitle; PROCEDURE (this: _ContactItem) TTYTDDTelephoneNumber* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14923) END TTYTDDTelephoneNumber; PROCEDURE (this: _ContactItem) PUTTTYTDDTelephoneNumber* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 14923, p1) END PUTTTYTDDTelephoneNumber; PROCEDURE (this: _ContactItem) User1* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32847) END User1; PROCEDURE (this: _ContactItem) PUTUser1* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32847, p1) END PUTUser1; PROCEDURE (this: _ContactItem) User2* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32848) END User2; PROCEDURE (this: _ContactItem) PUTUser2* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32848, p1) END PUTUser2; PROCEDURE (this: _ContactItem) User3* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32849) END User3; PROCEDURE (this: _ContactItem) PUTUser3* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32849, p1) END PUTUser3; PROCEDURE (this: _ContactItem) User4* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32850) END User4; PROCEDURE (this: _ContactItem) PUTUser4* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32850, p1) END PUTUser4; PROCEDURE (this: _ContactItem) UserCertificate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32790) END UserCertificate; PROCEDURE (this: _ContactItem) PUTUserCertificate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32790, p1) END PUTUserCertificate; PROCEDURE (this: _ContactItem) WebPage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32811) END WebPage; PROCEDURE (this: _ContactItem) PUTWebPage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32811, p1) END PUTWebPage; PROCEDURE (this: _ContactItem) YomiCompanyName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32814) END YomiCompanyName; PROCEDURE (this: _ContactItem) PUTYomiCompanyName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32814, p1) END PUTYomiCompanyName; PROCEDURE (this: _ContactItem) YomiFirstName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32812) END YomiFirstName; PROCEDURE (this: _ContactItem) PUTYomiFirstName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32812, p1) END PUTYomiFirstName; PROCEDURE (this: _ContactItem) YomiLastName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32813) END YomiLastName; PROCEDURE (this: _ContactItem) PUTYomiLastName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32813, p1) END PUTYomiLastName; PROCEDURE (this: _ContactItem) ForwardAsVcard* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63649, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END ForwardAsVcard; PROCEDURE (this: _ContactItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _DistListItem, dual ---------- *) PROCEDURE (this: _DistListItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _DistListItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _DistListItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _DistListItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _DistListItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _DistListItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _DistListItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _DistListItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _DistListItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _DistListItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _DistListItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _DistListItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _DistListItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _DistListItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _DistListItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _DistListItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _DistListItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _DistListItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _DistListItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _DistListItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _DistListItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _DistListItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _DistListItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _DistListItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _DistListItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _DistListItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _DistListItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _DistListItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _DistListItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _DistListItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _DistListItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _DistListItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _DistListItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _DistListItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _DistListItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _DistListItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _DistListItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _DistListItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _DistListItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _DistListItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _DistListItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _DistListItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _DistListItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _DistListItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _DistListItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _DistListItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _DistListItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _DistListItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _DistListItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _DistListItem) DLName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32851) END DLName; PROCEDURE (this: _DistListItem) PUTDLName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 32851, p1) END PUTDLName; PROCEDURE (this: _DistListItem) MemberCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32843) END MemberCount; PROCEDURE (this: _DistListItem) CheckSum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32844) END CheckSum; PROCEDURE (this: _DistListItem) Members* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 32853) END Members; PROCEDURE (this: _DistListItem) PUTMembers* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 32853, p1) END PUTMembers; PROCEDURE (this: _DistListItem) OneOffMembers* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 32852) END OneOffMembers; PROCEDURE (this: _DistListItem) PUTOneOffMembers* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 32852, p1) END PUTOneOffMembers; PROCEDURE (this: _DistListItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; PROCEDURE (this: _DistListItem) AddMembers* (recipients: Recipients), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(recipients, arg[0]); CtlC.CallParMethod(this, 63744, arg, NIL); END AddMembers; PROCEDURE (this: _DistListItem) RemoveMembers* (recipients: Recipients), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(recipients, arg[0]); CtlC.CallParMethod(this, 63745, arg, NIL); END RemoveMembers; PROCEDURE (this: _DistListItem) GetMember* (Index: INTEGER): Recipient, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 63749, arg, ret); RETURN ThisRecipient(CtlC.VarAny(ret)) END GetMember; (* ---------- _DocumentItem, dual ---------- *) PROCEDURE (this: _DocumentItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _DocumentItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _DocumentItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _DocumentItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _DocumentItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _DocumentItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _DocumentItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _DocumentItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _DocumentItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _DocumentItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _DocumentItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _DocumentItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _DocumentItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _DocumentItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _DocumentItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _DocumentItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _DocumentItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _DocumentItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _DocumentItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _DocumentItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _DocumentItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _DocumentItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _DocumentItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _DocumentItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _DocumentItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _DocumentItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _DocumentItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _DocumentItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _DocumentItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _DocumentItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _DocumentItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _DocumentItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _DocumentItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _DocumentItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _DocumentItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _DocumentItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _DocumentItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _DocumentItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _DocumentItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _DocumentItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _DocumentItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _DocumentItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _DocumentItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _DocumentItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _DocumentItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _DocumentItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _DocumentItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _DocumentItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _DocumentItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _DocumentItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- ExplorersEvents ---------- *) PROCEDURE (this: ExplorersEvents) NewExplorer* (Explorer: _Explorer), NEW, ABSTRACT; PROCEDURE (this: ExplorersEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.NewExplorer(This_Explorer(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: ExplorersEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00063078-0000-0000-C000-000000000046}" END GetIID; (* ---------- FoldersEvents ---------- *) PROCEDURE (this: FoldersEvents) FolderAdd* (Folder: MAPIFolder), NEW, ABSTRACT; PROCEDURE (this: FoldersEvents) FolderChange* (Folder: MAPIFolder), NEW, ABSTRACT; PROCEDURE (this: FoldersEvents) FolderRemove* (), NEW, ABSTRACT; PROCEDURE (this: FoldersEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.FolderAdd(ThisMAPIFolder(CtlC.VarAny(par[0]))) | 61442: ASSERT(n = 1, 11); this.FolderChange(ThisMAPIFolder(CtlC.VarAny(par[0]))) | 61443: ASSERT(n = 0, 11); this.FolderRemove() END END Invoke; PROCEDURE (this: FoldersEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00063076-0000-0000-C000-000000000046}" END GetIID; (* ---------- InspectorsEvents ---------- *) PROCEDURE (this: InspectorsEvents) NewInspector* (Inspector: _Inspector), NEW, ABSTRACT; PROCEDURE (this: InspectorsEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.NewInspector(This_Inspector(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: InspectorsEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00063079-0000-0000-C000-000000000046}" END GetIID; (* ---------- ItemsEvents ---------- *) PROCEDURE (this: ItemsEvents) ItemAdd* (Item: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: ItemsEvents) ItemChange* (Item: CtlT.Object), NEW, ABSTRACT; PROCEDURE (this: ItemsEvents) ItemRemove* (), NEW, ABSTRACT; PROCEDURE (this: ItemsEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.ItemAdd(CtlC.VarObj(par[0])) | 61442: ASSERT(n = 1, 11); this.ItemChange(CtlC.VarObj(par[0])) | 61443: ASSERT(n = 0, 11); this.ItemRemove() END END Invoke; PROCEDURE (this: ItemsEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{00063077-0000-0000-C000-000000000046}" END GetIID; (* ---------- _JournalItem, dual ---------- *) PROCEDURE (this: _JournalItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _JournalItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _JournalItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _JournalItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _JournalItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _JournalItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _JournalItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _JournalItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _JournalItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _JournalItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _JournalItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _JournalItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _JournalItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _JournalItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _JournalItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _JournalItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _JournalItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _JournalItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _JournalItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _JournalItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _JournalItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _JournalItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _JournalItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _JournalItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _JournalItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _JournalItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _JournalItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _JournalItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _JournalItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _JournalItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _JournalItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _JournalItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _JournalItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _JournalItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _JournalItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _JournalItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _JournalItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _JournalItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _JournalItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _JournalItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _JournalItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _JournalItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _JournalItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _JournalItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _JournalItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _JournalItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _JournalItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _JournalItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _JournalItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _JournalItem) ContactNames* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3588) END ContactNames; PROCEDURE (this: _JournalItem) PUTContactNames* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3588, p1) END PUTContactNames; PROCEDURE (this: _JournalItem) DocPosted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34577) END DocPosted; PROCEDURE (this: _JournalItem) PUTDocPosted* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34577, p1) END PUTDocPosted; PROCEDURE (this: _JournalItem) DocPrinted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34574) END DocPrinted; PROCEDURE (this: _JournalItem) PUTDocPrinted* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34574, p1) END PUTDocPrinted; PROCEDURE (this: _JournalItem) DocRouted* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34576) END DocRouted; PROCEDURE (this: _JournalItem) PUTDocRouted* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34576, p1) END PUTDocRouted; PROCEDURE (this: _JournalItem) DocSaved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34575) END DocSaved; PROCEDURE (this: _JournalItem) PUTDocSaved* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34575, p1) END PUTDocSaved; PROCEDURE (this: _JournalItem) Duration* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34567) END Duration; PROCEDURE (this: _JournalItem) PUTDuration* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 34567, p1) END PUTDuration; PROCEDURE (this: _JournalItem) End* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 34568) END End; PROCEDURE (this: _JournalItem) PUTEnd* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 34568, p1) END PUTEnd; PROCEDURE (this: _JournalItem) Type* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34560) END Type; PROCEDURE (this: _JournalItem) PUTType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34560, p1) END PUTType; PROCEDURE (this: _JournalItem) Recipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 63508)) END Recipients; PROCEDURE (this: _JournalItem) Start* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 34566) END Start; PROCEDURE (this: _JournalItem) PUTStart* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 34566, p1) END PUTStart; PROCEDURE (this: _JournalItem) Forward* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63507, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Forward; PROCEDURE (this: _JournalItem) Reply* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63504, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Reply; PROCEDURE (this: _JournalItem) ReplyAll* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63505, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END ReplyAll; PROCEDURE (this: _JournalItem) StartTimer* (), NEW; BEGIN CtlC.CallMethod(this, 63269, NIL); END StartTimer; PROCEDURE (this: _JournalItem) StopTimer* (), NEW; BEGIN CtlC.CallMethod(this, 63270, NIL); END StopTimer; PROCEDURE (this: _JournalItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- NameSpaceEvents ---------- *) PROCEDURE (this: NameSpaceEvents) OptionsPagesAdd* (Pages: PropertyPages; Folder: MAPIFolder), NEW, ABSTRACT; PROCEDURE (this: NameSpaceEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61445: ASSERT(n = 2, 11); this.OptionsPagesAdd(ThisPropertyPages(CtlC.VarAny(par[1])), ThisMAPIFolder(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: NameSpaceEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006308C-0000-0000-C000-000000000046}" END GetIID; (* ---------- _NoteItem, dual ---------- *) PROCEDURE (this: _NoteItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _NoteItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _NoteItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _NoteItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _NoteItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _NoteItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _NoteItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _NoteItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _NoteItem) Color* (): OlNoteColor, NEW; BEGIN RETURN CtlC.GetInt(this, 35584) END Color; PROCEDURE (this: _NoteItem) PUTColor* (p1: OlNoteColor), NEW; BEGIN CtlC.PutInt(this, 35584, p1) END PUTColor; PROCEDURE (this: _NoteItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _NoteItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _NoteItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _NoteItem) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 35587) END Height; PROCEDURE (this: _NoteItem) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 35587, p1) END PUTHeight; PROCEDURE (this: _NoteItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _NoteItem) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 35588) END Left; PROCEDURE (this: _NoteItem) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 35588, p1) END PUTLeft; PROCEDURE (this: _NoteItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _NoteItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _NoteItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _NoteItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _NoteItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 63392) END Subject; PROCEDURE (this: _NoteItem) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 35589) END Top; PROCEDURE (this: _NoteItem) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 35589, p1) END PUTTop; PROCEDURE (this: _NoteItem) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 35586) END Width; PROCEDURE (this: _NoteItem) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 35586, p1) END PUTWidth; PROCEDURE (this: _NoteItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _NoteItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _NoteItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _NoteItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _NoteItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _NoteItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _NoteItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _NoteItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _NoteItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- OutlookBarGroup, dual ---------- *) PROCEDURE (this: OutlookBarGroup) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: OutlookBarGroup) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: OutlookBarGroup) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: OutlookBarGroup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: OutlookBarGroup) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: OutlookBarGroup) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: OutlookBarGroup) Shortcuts* (): _OutlookBarShortcuts, NEW; BEGIN RETURN This_OutlookBarShortcuts(CtlC.GetAny(this, 8450)) END Shortcuts; PROCEDURE (this: OutlookBarGroup) ViewType* (): OlOutlookBarViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 8451) END ViewType; PROCEDURE (this: OutlookBarGroup) PUTViewType* (p1: OlOutlookBarViewType), NEW; BEGIN CtlC.PutInt(this, 8451, p1) END PUTViewType; (* ---------- _OutlookBarShortcuts, dual ---------- *) PROCEDURE (this: _OutlookBarShortcuts) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _OutlookBarShortcuts) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _OutlookBarShortcuts) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _OutlookBarShortcuts) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _OutlookBarShortcuts) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _OutlookBarShortcuts) Item* (Index: CtlT.Any): OutlookBarShortcut, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisOutlookBarShortcut(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _OutlookBarShortcuts) Add* (Target: CtlT.Any; Name: ARRAY OF CHAR; (* optional *) Index: CtlT.Any): OutlookBarShortcut, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Target, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN ThisOutlookBarShortcut(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _OutlookBarShortcuts) Remove* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- OutlookBarShortcut, dual ---------- *) PROCEDURE (this: OutlookBarShortcut) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: OutlookBarShortcut) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: OutlookBarShortcut) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: OutlookBarShortcut) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: OutlookBarShortcut) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: OutlookBarShortcut) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: OutlookBarShortcut) Target* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 8448) END Target; (* ---------- _OutlookBarGroups, dual ---------- *) PROCEDURE (this: _OutlookBarGroups) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _OutlookBarGroups) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _OutlookBarGroups) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _OutlookBarGroups) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _OutlookBarGroups) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: _OutlookBarGroups) Item* (Index: CtlT.Any): OutlookBarGroup, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN ThisOutlookBarGroup(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _OutlookBarGroups) Add* (Name: ARRAY OF CHAR; (* optional *) Index: CtlT.Any): OutlookBarGroup, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 95, arg, ret); RETURN ThisOutlookBarGroup(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _OutlookBarGroups) Remove* (Index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 84, arg, NIL); END Remove; (* ---------- OutlookBarGroupsEvents ---------- *) PROCEDURE (this: OutlookBarGroupsEvents) GroupAdd* (NewGroup: OutlookBarGroup), NEW, ABSTRACT; PROCEDURE (this: OutlookBarGroupsEvents) BeforeGroupAdd* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarGroupsEvents) BeforeGroupRemove* (Group: OutlookBarGroup; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarGroupsEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.GroupAdd(ThisOutlookBarGroup(CtlC.VarAny(par[0]))) | 61442: ASSERT(n = 1, 11); this.BeforeGroupAdd(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61443: ASSERT(n = 2, 11); this.BeforeGroupRemove(ThisOutlookBarGroup(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: OutlookBarGroupsEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006307B-0000-0000-C000-000000000046}" END GetIID; (* ---------- _OutlookBarPane, dual ---------- *) PROCEDURE (this: _OutlookBarPane) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _OutlookBarPane) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _OutlookBarPane) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _OutlookBarPane) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _OutlookBarPane) Contents* (): OutlookBarStorage, NEW; BEGIN RETURN ThisOutlookBarStorage(CtlC.GetAny(this, 8448)) END Contents; PROCEDURE (this: _OutlookBarPane) CurrentGroup* (): OutlookBarGroup, NEW; BEGIN RETURN ThisOutlookBarGroup(CtlC.GetAny(this, 8449)) END CurrentGroup; PROCEDURE (this: _OutlookBarPane) PUTREFCurrentGroup* (p1: OutlookBarGroup), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 8449, arg, NIL); END PUTREFCurrentGroup; PROCEDURE (this: _OutlookBarPane) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _OutlookBarPane) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8451) END Visible; PROCEDURE (this: _OutlookBarPane) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8451, p1) END PUTVisible; (* ---------- OutlookBarStorage, dual ---------- *) PROCEDURE (this: OutlookBarStorage) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: OutlookBarStorage) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: OutlookBarStorage) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: OutlookBarStorage) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: OutlookBarStorage) Groups* (): _OutlookBarGroups, NEW; BEGIN RETURN This_OutlookBarGroups(CtlC.GetAny(this, 0)) END Groups; (* ---------- OutlookBarPaneEvents ---------- *) PROCEDURE (this: OutlookBarPaneEvents) BeforeNavigate* (Shortcut: OutlookBarShortcut; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarPaneEvents) BeforeGroupSwitch* (ToGroup: OutlookBarGroup; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarPaneEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 2, 11); this.BeforeNavigate(ThisOutlookBarShortcut(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61442: ASSERT(n = 2, 11); this.BeforeGroupSwitch(ThisOutlookBarGroup(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: OutlookBarPaneEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006307A-0000-0000-C000-000000000046}" END GetIID; (* ---------- OutlookBarShortcutsEvents ---------- *) PROCEDURE (this: OutlookBarShortcutsEvents) ShortcutAdd* (NewShortcut: OutlookBarShortcut), NEW, ABSTRACT; PROCEDURE (this: OutlookBarShortcutsEvents) BeforeShortcutAdd* (VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarShortcutsEvents) BeforeShortcutRemove* (Shortcut: OutlookBarShortcut; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: OutlookBarShortcutsEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 61441: ASSERT(n = 1, 11); this.ShortcutAdd(ThisOutlookBarShortcut(CtlC.VarAny(par[0]))) | 61442: ASSERT(n = 1, 11); this.BeforeShortcutAdd(CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 61443: ASSERT(n = 2, 11); this.BeforeShortcutRemove(ThisOutlookBarShortcut(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: OutlookBarShortcutsEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0006307C-0000-0000-C000-000000000046}" END GetIID; (* ---------- PropertyPageSite, dual ---------- *) PROCEDURE (this: PropertyPageSite) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: PropertyPageSite) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: PropertyPageSite) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: PropertyPageSite) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: PropertyPageSite) OnStatusChange* (), NEW; BEGIN CtlC.CallMethod(this, 8448, NIL); END OnStatusChange; (* ---------- Pages, dual ---------- *) PROCEDURE (this: Pages) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: Pages) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: Pages) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: Pages) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: Pages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 80) END Count; PROCEDURE (this: Pages) Item* (Index: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 81, arg, ret); RETURN CtlC.VarObj(ret) END Item; PROCEDURE (this: Pages) Add* ((* optional *) Name: CtlT.Any): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 300, arg, ret); RETURN CtlC.VarObj(ret) END Add; PROCEDURE (this: Pages) Remove* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 301, arg, NIL); END Remove; (* ---------- _PostItem, dual ---------- *) PROCEDURE (this: _PostItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _PostItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _PostItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _PostItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _PostItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _PostItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _PostItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _PostItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _PostItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _PostItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _PostItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _PostItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _PostItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _PostItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _PostItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _PostItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _PostItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _PostItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _PostItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _PostItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _PostItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _PostItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _PostItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _PostItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _PostItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _PostItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _PostItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _PostItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _PostItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _PostItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _PostItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _PostItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _PostItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _PostItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _PostItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _PostItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _PostItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _PostItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _PostItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _PostItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _PostItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _PostItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _PostItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _PostItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _PostItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _PostItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _PostItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _PostItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _PostItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _PostItem) ExpiryTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 21) END ExpiryTime; PROCEDURE (this: _PostItem) PUTExpiryTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 21, p1) END PUTExpiryTime; PROCEDURE (this: _PostItem) HTMLBody* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 62468) END HTMLBody; PROCEDURE (this: _PostItem) PUTHTMLBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 62468, p1) END PUTHTMLBody; PROCEDURE (this: _PostItem) ReceivedTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 3590) END ReceivedTime; PROCEDURE (this: _PostItem) SenderName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3098) END SenderName; PROCEDURE (this: _PostItem) SentOn* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 57) END SentOn; PROCEDURE (this: _PostItem) ClearConversationIndex* (), NEW; BEGIN CtlC.CallMethod(this, 63522, NIL); END ClearConversationIndex; PROCEDURE (this: _PostItem) Forward* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63507, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Forward; PROCEDURE (this: _PostItem) Post* (), NEW; BEGIN CtlC.CallMethod(this, 61557, NIL); END Post; PROCEDURE (this: _PostItem) Reply* (): MailItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63504, ret); RETURN This_MailItem(CtlC.VarAny(ret)) END Reply; PROCEDURE (this: _PostItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _RemoteItem, dual ---------- *) PROCEDURE (this: _RemoteItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _RemoteItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _RemoteItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _RemoteItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _RemoteItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _RemoteItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _RemoteItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _RemoteItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _RemoteItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _RemoteItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _RemoteItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _RemoteItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _RemoteItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _RemoteItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _RemoteItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _RemoteItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _RemoteItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _RemoteItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _RemoteItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _RemoteItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _RemoteItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _RemoteItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _RemoteItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _RemoteItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _RemoteItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _RemoteItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _RemoteItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _RemoteItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _RemoteItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _RemoteItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _RemoteItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _RemoteItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _RemoteItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _RemoteItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _RemoteItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _RemoteItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _RemoteItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _RemoteItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _RemoteItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _RemoteItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _RemoteItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _RemoteItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _RemoteItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _RemoteItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _RemoteItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _RemoteItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _RemoteItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _RemoteItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _RemoteItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _RemoteItem) HasAttachment* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36615) END HasAttachment; PROCEDURE (this: _RemoteItem) RemoteMessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36610) END RemoteMessageClass; PROCEDURE (this: _RemoteItem) TransferSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 36613) END TransferSize; PROCEDURE (this: _RemoteItem) TransferTime* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 36612) END TransferTime; PROCEDURE (this: _RemoteItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _ReportItem, dual ---------- *) PROCEDURE (this: _ReportItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _ReportItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _ReportItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _ReportItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _ReportItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _ReportItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _ReportItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _ReportItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _ReportItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _ReportItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _ReportItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _ReportItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _ReportItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _ReportItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _ReportItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _ReportItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _ReportItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _ReportItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _ReportItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _ReportItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _ReportItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _ReportItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _ReportItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _ReportItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _ReportItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _ReportItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _ReportItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _ReportItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _ReportItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _ReportItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _ReportItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _ReportItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _ReportItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _ReportItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _ReportItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _ReportItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _ReportItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _ReportItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _ReportItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _ReportItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _ReportItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _ReportItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _ReportItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _ReportItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _ReportItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _ReportItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _ReportItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _ReportItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _ReportItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _ReportItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _TaskItem, dual ---------- *) PROCEDURE (this: _TaskItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _TaskItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _TaskItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _TaskItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _TaskItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _TaskItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _TaskItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _TaskItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _TaskItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _TaskItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _TaskItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _TaskItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _TaskItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _TaskItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _TaskItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _TaskItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _TaskItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _TaskItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _TaskItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _TaskItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _TaskItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _TaskItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _TaskItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _TaskItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _TaskItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _TaskItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _TaskItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _TaskItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _TaskItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _TaskItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _TaskItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _TaskItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _TaskItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _TaskItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _TaskItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _TaskItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _TaskItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _TaskItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _TaskItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _TaskItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _TaskItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _TaskItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _TaskItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _TaskItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _TaskItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _TaskItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _TaskItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _TaskItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _TaskItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _TaskItem) ActualWork* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 33040) END ActualWork; PROCEDURE (this: _TaskItem) PUTActualWork* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 33040, p1) END PUTActualWork; PROCEDURE (this: _TaskItem) CardData* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33067) END CardData; PROCEDURE (this: _TaskItem) PUTCardData* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33067, p1) END PUTCardData; PROCEDURE (this: _TaskItem) Complete* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33052) END Complete; PROCEDURE (this: _TaskItem) PUTComplete* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33052, p1) END PUTComplete; PROCEDURE (this: _TaskItem) Contacts* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34106) END Contacts; PROCEDURE (this: _TaskItem) PUTContacts* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34106, p1) END PUTContacts; PROCEDURE (this: _TaskItem) ContactNames* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34108) END ContactNames; PROCEDURE (this: _TaskItem) PUTContactNames* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34108, p1) END PUTContactNames; PROCEDURE (this: _TaskItem) DateCompleted* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33039) END DateCompleted; PROCEDURE (this: _TaskItem) PUTDateCompleted* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33039, p1) END PUTDateCompleted; PROCEDURE (this: _TaskItem) DelegationState* (): OlTaskDelegationState, NEW; BEGIN RETURN CtlC.GetInt(this, 33066) END DelegationState; PROCEDURE (this: _TaskItem) Delegator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33057) END Delegator; PROCEDURE (this: _TaskItem) DueDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33029) END DueDate; PROCEDURE (this: _TaskItem) PUTDueDate* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33029, p1) END PUTDueDate; PROCEDURE (this: _TaskItem) IsRecurring* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 62999) END IsRecurring; PROCEDURE (this: _TaskItem) Ordinal* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 33059) END Ordinal; PROCEDURE (this: _TaskItem) PUTOrdinal* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 33059, p1) END PUTOrdinal; PROCEDURE (this: _TaskItem) Owner* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33055) END Owner; PROCEDURE (this: _TaskItem) PUTOwner* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33055, p1) END PUTOwner; PROCEDURE (this: _TaskItem) Ownership* (): OlTaskOwnership, NEW; BEGIN RETURN CtlC.GetInt(this, 33065) END Ownership; PROCEDURE (this: _TaskItem) PercentComplete* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 63007) END PercentComplete; PROCEDURE (this: _TaskItem) PUTPercentComplete* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 63007, p1) END PUTPercentComplete; PROCEDURE (this: _TaskItem) Recipients* (): Recipients, NEW; BEGIN RETURN ThisRecipients(CtlC.GetAny(this, 63508)) END Recipients; PROCEDURE (this: _TaskItem) ReminderTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 34050) END ReminderTime; PROCEDURE (this: _TaskItem) PUTReminderTime* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 34050, p1) END PUTReminderTime; PROCEDURE (this: _TaskItem) ReminderOverrideDefault* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34076) END ReminderOverrideDefault; PROCEDURE (this: _TaskItem) PUTReminderOverrideDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34076, p1) END PUTReminderOverrideDefault; PROCEDURE (this: _TaskItem) ReminderPlaySound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34078) END ReminderPlaySound; PROCEDURE (this: _TaskItem) PUTReminderPlaySound* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34078, p1) END PUTReminderPlaySound; PROCEDURE (this: _TaskItem) ReminderSet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34051) END ReminderSet; PROCEDURE (this: _TaskItem) PUTReminderSet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34051, p1) END PUTReminderSet; PROCEDURE (this: _TaskItem) ReminderSoundFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34079) END ReminderSoundFile; PROCEDURE (this: _TaskItem) PUTReminderSoundFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34079, p1) END PUTReminderSoundFile; PROCEDURE (this: _TaskItem) ResponseState* (): OlTaskResponse, NEW; BEGIN RETURN CtlC.GetInt(this, 63011) END ResponseState; PROCEDURE (this: _TaskItem) Role* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33063) END Role; PROCEDURE (this: _TaskItem) PUTRole* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33063, p1) END PUTRole; PROCEDURE (this: _TaskItem) SchedulePlusPriority* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 33071) END SchedulePlusPriority; PROCEDURE (this: _TaskItem) PUTSchedulePlusPriority* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 33071, p1) END PUTSchedulePlusPriority; PROCEDURE (this: _TaskItem) StartDate* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 33028) END StartDate; PROCEDURE (this: _TaskItem) PUTStartDate* (p1: CtlT.OleDate), NEW; BEGIN CtlC.PutDate(this, 33028, p1) END PUTStartDate; PROCEDURE (this: _TaskItem) Status* (): OlTaskStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 33025) END Status; PROCEDURE (this: _TaskItem) PUTStatus* (p1: OlTaskStatus), NEW; BEGIN CtlC.PutInt(this, 33025, p1) END PUTStatus; PROCEDURE (this: _TaskItem) StatusOnCompletionRecipients* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3586) END StatusOnCompletionRecipients; PROCEDURE (this: _TaskItem) PUTStatusOnCompletionRecipients* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3586, p1) END PUTStatusOnCompletionRecipients; PROCEDURE (this: _TaskItem) StatusUpdateRecipients* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3587) END StatusUpdateRecipients; PROCEDURE (this: _TaskItem) PUTStatusUpdateRecipients* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3587, p1) END PUTStatusUpdateRecipients; PROCEDURE (this: _TaskItem) TeamTask* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33027) END TeamTask; PROCEDURE (this: _TaskItem) PUTTeamTask* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33027, p1) END PUTTeamTask; PROCEDURE (this: _TaskItem) TotalWork* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 33041) END TotalWork; PROCEDURE (this: _TaskItem) PUTTotalWork* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 33041, p1) END PUTTotalWork; PROCEDURE (this: _TaskItem) Assign* (): TaskItem, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63008, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END Assign; PROCEDURE (this: _TaskItem) CancelResponseState* (), NEW; BEGIN CtlC.CallMethod(this, 63010, NIL); END CancelResponseState; PROCEDURE (this: _TaskItem) ClearRecurrencePattern* (), NEW; BEGIN CtlC.CallMethod(this, 61605, NIL); END ClearRecurrencePattern; PROCEDURE (this: _TaskItem) GetRecurrencePattern* (): RecurrencePattern, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61604, ret); RETURN ThisRecurrencePattern(CtlC.VarAny(ret)) END GetRecurrencePattern; PROCEDURE (this: _TaskItem) MarkComplete* (), NEW; BEGIN CtlC.CallMethod(this, 62989, NIL); END MarkComplete; PROCEDURE (this: _TaskItem) Respond* (Response: OlTaskResponse; fNoUI: CtlT.Any; fAdditionalTextDialog: CtlT.Any): TaskItem, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Response, arg[2]); CtlC.AnyVar(fNoUI, arg[1]); CtlC.AnyVar(fAdditionalTextDialog, arg[0]); CtlC.CallParMethod(this, 63009, arg, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END Respond; PROCEDURE (this: _TaskItem) Send* (), NEW; BEGIN CtlC.CallMethod(this, 61557, NIL); END Send; PROCEDURE (this: _TaskItem) SkipRecurrence* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 63012, ret); RETURN CtlC.VarBool(ret) END SkipRecurrence; PROCEDURE (this: _TaskItem) StatusReport* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 62994, ret); RETURN CtlC.VarObj(ret) END StatusReport; PROCEDURE (this: _TaskItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _TaskRequestAcceptItem, dual ---------- *) PROCEDURE (this: _TaskRequestAcceptItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _TaskRequestAcceptItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _TaskRequestAcceptItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _TaskRequestAcceptItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _TaskRequestAcceptItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _TaskRequestAcceptItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _TaskRequestAcceptItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _TaskRequestAcceptItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _TaskRequestAcceptItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _TaskRequestAcceptItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _TaskRequestAcceptItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _TaskRequestAcceptItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _TaskRequestAcceptItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _TaskRequestAcceptItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _TaskRequestAcceptItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _TaskRequestAcceptItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _TaskRequestAcceptItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _TaskRequestAcceptItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _TaskRequestAcceptItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _TaskRequestAcceptItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _TaskRequestAcceptItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _TaskRequestAcceptItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _TaskRequestAcceptItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _TaskRequestAcceptItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _TaskRequestAcceptItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _TaskRequestAcceptItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _TaskRequestAcceptItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _TaskRequestAcceptItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _TaskRequestAcceptItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _TaskRequestAcceptItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _TaskRequestAcceptItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _TaskRequestAcceptItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _TaskRequestAcceptItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _TaskRequestAcceptItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _TaskRequestAcceptItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _TaskRequestAcceptItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _TaskRequestAcceptItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _TaskRequestAcceptItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _TaskRequestAcceptItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _TaskRequestAcceptItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _TaskRequestAcceptItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _TaskRequestAcceptItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _TaskRequestAcceptItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _TaskRequestAcceptItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _TaskRequestAcceptItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _TaskRequestAcceptItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _TaskRequestAcceptItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _TaskRequestAcceptItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _TaskRequestAcceptItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _TaskRequestAcceptItem) GetAssociatedTask* (AddToTaskList: BOOLEAN): TaskItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(AddToTaskList, arg[0]); CtlC.CallParMethod(this, 61460, arg, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END GetAssociatedTask; PROCEDURE (this: _TaskRequestAcceptItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _TaskRequestDeclineItem, dual ---------- *) PROCEDURE (this: _TaskRequestDeclineItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _TaskRequestDeclineItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _TaskRequestDeclineItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _TaskRequestDeclineItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _TaskRequestDeclineItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _TaskRequestDeclineItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _TaskRequestDeclineItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _TaskRequestDeclineItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _TaskRequestDeclineItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _TaskRequestDeclineItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _TaskRequestDeclineItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _TaskRequestDeclineItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _TaskRequestDeclineItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _TaskRequestDeclineItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _TaskRequestDeclineItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _TaskRequestDeclineItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _TaskRequestDeclineItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _TaskRequestDeclineItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _TaskRequestDeclineItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _TaskRequestDeclineItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _TaskRequestDeclineItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _TaskRequestDeclineItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _TaskRequestDeclineItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _TaskRequestDeclineItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _TaskRequestDeclineItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _TaskRequestDeclineItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _TaskRequestDeclineItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _TaskRequestDeclineItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _TaskRequestDeclineItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _TaskRequestDeclineItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _TaskRequestDeclineItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _TaskRequestDeclineItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _TaskRequestDeclineItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _TaskRequestDeclineItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _TaskRequestDeclineItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _TaskRequestDeclineItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _TaskRequestDeclineItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _TaskRequestDeclineItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _TaskRequestDeclineItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _TaskRequestDeclineItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _TaskRequestDeclineItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _TaskRequestDeclineItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _TaskRequestDeclineItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _TaskRequestDeclineItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _TaskRequestDeclineItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _TaskRequestDeclineItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _TaskRequestDeclineItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _TaskRequestDeclineItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _TaskRequestDeclineItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _TaskRequestDeclineItem) GetAssociatedTask* (AddToTaskList: BOOLEAN): TaskItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(AddToTaskList, arg[0]); CtlC.CallParMethod(this, 61460, arg, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END GetAssociatedTask; PROCEDURE (this: _TaskRequestDeclineItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _TaskRequestItem, dual ---------- *) PROCEDURE (this: _TaskRequestItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _TaskRequestItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _TaskRequestItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _TaskRequestItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _TaskRequestItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _TaskRequestItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _TaskRequestItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _TaskRequestItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _TaskRequestItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _TaskRequestItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _TaskRequestItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _TaskRequestItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _TaskRequestItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _TaskRequestItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _TaskRequestItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _TaskRequestItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _TaskRequestItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _TaskRequestItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _TaskRequestItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _TaskRequestItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _TaskRequestItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _TaskRequestItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _TaskRequestItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _TaskRequestItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _TaskRequestItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _TaskRequestItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _TaskRequestItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _TaskRequestItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _TaskRequestItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _TaskRequestItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _TaskRequestItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _TaskRequestItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _TaskRequestItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _TaskRequestItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _TaskRequestItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _TaskRequestItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _TaskRequestItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _TaskRequestItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _TaskRequestItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _TaskRequestItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _TaskRequestItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _TaskRequestItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _TaskRequestItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _TaskRequestItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _TaskRequestItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _TaskRequestItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _TaskRequestItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _TaskRequestItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _TaskRequestItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _TaskRequestItem) GetAssociatedTask* (AddToTaskList: BOOLEAN): TaskItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(AddToTaskList, arg[0]); CtlC.CallParMethod(this, 61460, arg, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END GetAssociatedTask; PROCEDURE (this: _TaskRequestItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _TaskRequestUpdateItem, dual ---------- *) PROCEDURE (this: _TaskRequestUpdateItem) Application* (): _Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 61440)) END Application; PROCEDURE (this: _TaskRequestUpdateItem) Class* (): OlObjectClass, NEW; BEGIN RETURN CtlC.GetInt(this, 61450) END Class; PROCEDURE (this: _TaskRequestUpdateItem) Session* (): _NameSpace, NEW; BEGIN RETURN This_NameSpace(CtlC.GetAny(this, 61451)) END Session; PROCEDURE (this: _TaskRequestUpdateItem) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 61441) END Parent; PROCEDURE (this: _TaskRequestUpdateItem) Actions* (): Actions, NEW; BEGIN RETURN ThisActions(CtlC.GetAny(this, 63511)) END Actions; PROCEDURE (this: _TaskRequestUpdateItem) Attachments* (): Attachments, NEW; BEGIN RETURN ThisAttachments(CtlC.GetAny(this, 63509)) END Attachments; PROCEDURE (this: _TaskRequestUpdateItem) BillingInformation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34101) END BillingInformation; PROCEDURE (this: _TaskRequestUpdateItem) PUTBillingInformation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34101, p1) END PUTBillingInformation; PROCEDURE (this: _TaskRequestUpdateItem) Body* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 37120) END Body; PROCEDURE (this: _TaskRequestUpdateItem) PUTBody* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 37120, p1) END PUTBody; PROCEDURE (this: _TaskRequestUpdateItem) Categories* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36865) END Categories; PROCEDURE (this: _TaskRequestUpdateItem) PUTCategories* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36865, p1) END PUTCategories; PROCEDURE (this: _TaskRequestUpdateItem) Companies* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34107) END Companies; PROCEDURE (this: _TaskRequestUpdateItem) PUTCompanies* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34107, p1) END PUTCompanies; PROCEDURE (this: _TaskRequestUpdateItem) ConversationIndex* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 113) END ConversationIndex; PROCEDURE (this: _TaskRequestUpdateItem) ConversationTopic* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END ConversationTopic; PROCEDURE (this: _TaskRequestUpdateItem) CreationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12295) END CreationTime; PROCEDURE (this: _TaskRequestUpdateItem) EntryID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 61470) END EntryID; PROCEDURE (this: _TaskRequestUpdateItem) FormDescription* (): FormDescription, NEW; BEGIN RETURN ThisFormDescription(CtlC.GetAny(this, 61589)) END FormDescription; PROCEDURE (this: _TaskRequestUpdateItem) GetInspector* (): _Inspector, NEW; BEGIN RETURN This_Inspector(CtlC.GetAny(this, 61502)) END GetInspector; PROCEDURE (this: _TaskRequestUpdateItem) Importance* (): OlImportance, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END Importance; PROCEDURE (this: _TaskRequestUpdateItem) PUTImportance* (p1: OlImportance), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTImportance; PROCEDURE (this: _TaskRequestUpdateItem) LastModificationTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 12296) END LastModificationTime; PROCEDURE (this: _TaskRequestUpdateItem) MAPIOBJECT* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 61696) END MAPIOBJECT; PROCEDURE (this: _TaskRequestUpdateItem) MessageClass* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 26) END MessageClass; PROCEDURE (this: _TaskRequestUpdateItem) PUTMessageClass* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 26, p1) END PUTMessageClass; PROCEDURE (this: _TaskRequestUpdateItem) Mileage* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34100) END Mileage; PROCEDURE (this: _TaskRequestUpdateItem) PUTMileage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34100, p1) END PUTMileage; PROCEDURE (this: _TaskRequestUpdateItem) NoAging* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34062) END NoAging; PROCEDURE (this: _TaskRequestUpdateItem) PUTNoAging* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34062, p1) END PUTNoAging; PROCEDURE (this: _TaskRequestUpdateItem) OutlookInternalVersion* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34130) END OutlookInternalVersion; PROCEDURE (this: _TaskRequestUpdateItem) OutlookVersion* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34132) END OutlookVersion; PROCEDURE (this: _TaskRequestUpdateItem) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61603) END Saved; PROCEDURE (this: _TaskRequestUpdateItem) Sensitivity* (): OlSensitivity, NEW; BEGIN RETURN CtlC.GetInt(this, 54) END Sensitivity; PROCEDURE (this: _TaskRequestUpdateItem) PUTSensitivity* (p1: OlSensitivity), NEW; BEGIN CtlC.PutInt(this, 54, p1) END PUTSensitivity; PROCEDURE (this: _TaskRequestUpdateItem) Size* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3592) END Size; PROCEDURE (this: _TaskRequestUpdateItem) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 55) END Subject; PROCEDURE (this: _TaskRequestUpdateItem) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 55, p1) END PUTSubject; PROCEDURE (this: _TaskRequestUpdateItem) UnRead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61468) END UnRead; PROCEDURE (this: _TaskRequestUpdateItem) PUTUnRead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61468, p1) END PUTUnRead; PROCEDURE (this: _TaskRequestUpdateItem) UserProperties* (): UserProperties, NEW; BEGIN RETURN ThisUserProperties(CtlC.GetAny(this, 63510)) END UserProperties; PROCEDURE (this: _TaskRequestUpdateItem) Close* (SaveMode: OlInspectorClose), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(SaveMode, arg[0]); CtlC.CallParMethod(this, 61475, arg, NIL); END Close; PROCEDURE (this: _TaskRequestUpdateItem) Copy* (): CtlT.Object, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 61490, ret); RETURN CtlC.VarObj(ret) END Copy; PROCEDURE (this: _TaskRequestUpdateItem) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 61514, NIL); END Delete; PROCEDURE (this: _TaskRequestUpdateItem) Display* ((* optional *) Modal: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Modal, arg[0]); CtlC.CallParMethod(this, 61606, arg, NIL); END Display; PROCEDURE (this: _TaskRequestUpdateItem) Move* (DestFldr: MAPIFolder): CtlT.Object, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(DestFldr, arg[0]); CtlC.CallParMethod(this, 61492, arg, ret); RETURN CtlC.VarObj(ret) END Move; PROCEDURE (this: _TaskRequestUpdateItem) PrintOut* (), NEW; BEGIN CtlC.CallMethod(this, 61491, NIL); END PrintOut; PROCEDURE (this: _TaskRequestUpdateItem) Save* (), NEW; BEGIN CtlC.CallMethod(this, 61512, NIL); END Save; PROCEDURE (this: _TaskRequestUpdateItem) SaveAs* (Path: ARRAY OF CHAR; (* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 61521, arg, NIL); END SaveAs; PROCEDURE (this: _TaskRequestUpdateItem) GetAssociatedTask* (AddToTaskList: BOOLEAN): TaskItem, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.BoolVar(AddToTaskList, arg[0]); CtlC.CallParMethod(this, 61460, arg, ret); RETURN This_TaskItem(CtlC.VarAny(ret)) END GetAssociatedTask; PROCEDURE (this: _TaskRequestUpdateItem) Links* (): Links, NEW; BEGIN RETURN ThisLinks(CtlC.GetAny(this, 62469)) END Links; (* ---------- _DRecipientControl, hidden ---------- *) PROCEDURE (this: _DRecipientControl) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -514) END Enabled; PROCEDURE (this: _DRecipientControl) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -514, p1) END PUTEnabled; PROCEDURE (this: _DRecipientControl) BackColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -501) END BackColor; PROCEDURE (this: _DRecipientControl) PUTBackColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -501, p1) END PUTBackColor; PROCEDURE (this: _DRecipientControl) ForeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -513) END ForeColor; PROCEDURE (this: _DRecipientControl) PUTForeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, -513, p1) END PUTForeColor; PROCEDURE (this: _DRecipientControl) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147356664) END ReadOnly; PROCEDURE (this: _DRecipientControl) PUTReadOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147356664, p1) END PUTReadOnly; PROCEDURE (this: _DRecipientControl) Font* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -512) END Font; PROCEDURE (this: _DRecipientControl) PUTFont* (p1: CtlT.Object), NEW; BEGIN CtlC.PutObj(this, -512, p1) END PUTFont; PROCEDURE (this: _DRecipientControl) SpecialEffect* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END SpecialEffect; PROCEDURE (this: _DRecipientControl) PUTSpecialEffect* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTSpecialEffect; (* ---------- _DRecipientControlEvents, hidden ---------- *) PROCEDURE (this: _DRecipientControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF END END Invoke; PROCEDURE (this: _DRecipientControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{D87E7E17-6897-11CE-A6C0-00AA00608FAA}" END GetIID; (* ---------- _DDocSiteControl, hidden ---------- *) PROCEDURE (this: _DDocSiteControl) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147356664) END ReadOnly; PROCEDURE (this: _DDocSiteControl) PUTReadOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147356664, p1) END PUTReadOnly; (* ---------- _DDocSiteControlEvents, hidden ---------- *) PROCEDURE (this: _DDocSiteControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF END END Invoke; PROCEDURE (this: _DDocSiteControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{50BB9B50-811D-11CE-B565-00AA00608FAA}" END GetIID; PROCEDURE NewSyncObject* (): _SyncObject; BEGIN RETURN This_SyncObject(CtlC.NewObj("{00063084-0000-0000-C000-000000000046}")) END NewSyncObject; PROCEDURE NewExplorer* (): _Explorer; BEGIN RETURN This_Explorer(CtlC.NewObj("{00063050-0000-0000-C000-000000000046}")) END NewExplorer; PROCEDURE NewInspector* (): _Inspector; BEGIN RETURN This_Inspector(CtlC.NewObj("{00063058-0000-0000-C000-000000000046}")) END NewInspector; PROCEDURE NewMailItem* (): _MailItem; BEGIN RETURN This_MailItem(CtlC.NewObj("{00061033-0000-0000-C000-000000000046}")) END NewMailItem; PROCEDURE NewAppointmentItem* (): _AppointmentItem; BEGIN RETURN This_AppointmentItem(CtlC.NewObj("{00061030-0000-0000-C000-000000000046}")) END NewAppointmentItem; PROCEDURE NewMeetingItem* (): _MeetingItem; BEGIN RETURN This_MeetingItem(CtlC.NewObj("{00061036-0000-0000-C000-000000000046}")) END NewMeetingItem; PROCEDURE NewTaskItem* (): _TaskItem; BEGIN RETURN This_TaskItem(CtlC.NewObj("{00061032-0000-0000-C000-000000000046}")) END NewTaskItem; PROCEDURE NewApplication* (): _Application; BEGIN RETURN This_Application(CtlC.NewObj("{0006F03A-0000-0000-C000-000000000046}")) END NewApplication; PROCEDURE NewContactItem* (): _ContactItem; BEGIN RETURN This_ContactItem(CtlC.NewObj("{00061031-0000-0000-C000-000000000046}")) END NewContactItem; PROCEDURE NewDistListItem* (): _DistListItem; BEGIN RETURN This_DistListItem(CtlC.NewObj("{0006103C-0000-0000-C000-000000000046}")) END NewDistListItem; PROCEDURE NewDocumentItem* (): _DocumentItem; BEGIN RETURN This_DocumentItem(CtlC.NewObj("{00061061-0000-0000-C000-000000000046}")) END NewDocumentItem; PROCEDURE NewExplorers* (): _Explorers; BEGIN RETURN This_Explorers(CtlC.NewObj("{00063053-0000-0000-C000-000000000046}")) END NewExplorers; PROCEDURE NewInspectors* (): _Inspectors; BEGIN RETURN This_Inspectors(CtlC.NewObj("{00063054-0000-0000-C000-000000000046}")) END NewInspectors; PROCEDURE NewFolders* (): _Folders; BEGIN RETURN This_Folders(CtlC.NewObj("{00063051-0000-0000-C000-000000000046}")) END NewFolders; PROCEDURE NewItems* (): _Items; BEGIN RETURN This_Items(CtlC.NewObj("{00063052-0000-0000-C000-000000000046}")) END NewItems; PROCEDURE NewJournalItem* (): _JournalItem; BEGIN RETURN This_JournalItem(CtlC.NewObj("{00061037-0000-0000-C000-000000000046}")) END NewJournalItem; PROCEDURE NewNameSpace* (): _NameSpace; BEGIN RETURN This_NameSpace(CtlC.NewObj("{0006308B-0000-0000-C000-000000000046}")) END NewNameSpace; PROCEDURE NewNoteItem* (): _NoteItem; BEGIN RETURN This_NoteItem(CtlC.NewObj("{00061034-0000-0000-C000-000000000046}")) END NewNoteItem; PROCEDURE NewOutlookBarGroups* (): _OutlookBarGroups; BEGIN RETURN This_OutlookBarGroups(CtlC.NewObj("{00063056-0000-0000-C000-000000000046}")) END NewOutlookBarGroups; PROCEDURE NewOutlookBarPane* (): _OutlookBarPane; BEGIN RETURN This_OutlookBarPane(CtlC.NewObj("{00063055-0000-0000-C000-000000000046}")) END NewOutlookBarPane; PROCEDURE NewOutlookBarShortcuts* (): _OutlookBarShortcuts; BEGIN RETURN This_OutlookBarShortcuts(CtlC.NewObj("{00063057-0000-0000-C000-000000000046}")) END NewOutlookBarShortcuts; PROCEDURE NewPostItem* (): _PostItem; BEGIN RETURN This_PostItem(CtlC.NewObj("{0006103A-0000-0000-C000-000000000046}")) END NewPostItem; PROCEDURE NewRemoteItem* (): _RemoteItem; BEGIN RETURN This_RemoteItem(CtlC.NewObj("{00061060-0000-0000-C000-000000000046}")) END NewRemoteItem; PROCEDURE NewReportItem* (): _ReportItem; BEGIN RETURN This_ReportItem(CtlC.NewObj("{00061035-0000-0000-C000-000000000046}")) END NewReportItem; PROCEDURE NewTaskRequestAcceptItem* (): _TaskRequestAcceptItem; BEGIN RETURN This_TaskRequestAcceptItem(CtlC.NewObj("{00061052-0000-0000-C000-000000000046}")) END NewTaskRequestAcceptItem; PROCEDURE NewTaskRequestDeclineItem* (): _TaskRequestDeclineItem; BEGIN RETURN This_TaskRequestDeclineItem(CtlC.NewObj("{00061053-0000-0000-C000-000000000046}")) END NewTaskRequestDeclineItem; PROCEDURE NewTaskRequestItem* (): _TaskRequestItem; BEGIN RETURN This_TaskRequestItem(CtlC.NewObj("{00061050-0000-0000-C000-000000000046}")) END NewTaskRequestItem; PROCEDURE NewTaskRequestUpdateItem* (): _TaskRequestUpdateItem; BEGIN RETURN This_TaskRequestUpdateItem(CtlC.NewObj("{00061051-0000-0000-C000-000000000046}")) END NewTaskRequestUpdateItem; PROCEDURE New_RecipientControl* (): _DRecipientControl; BEGIN RETURN This_DRecipientControl(CtlC.NewObj("{0006F023-0000-0000-C000-000000000046}")) END New_RecipientControl; PROCEDURE New_DocSiteControl* (): _DDocSiteControl; BEGIN RETURN This_DDocSiteControl(CtlC.NewObj("{0006F024-0000-0000-C000-000000000046}")) END New_DocSiteControl; END CtlOutlook9.

Ctl/Mod/Outlook9.odc

MODULE CtlPowerPoint9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft PowerPoint 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\VBAPPT9.CHM, id: 500000 *) (* guid: {91493440-5A91-11CF-8700-00AA0060263B}, lcid: 0, syskind: win32, version: 2.6 *) IMPORT CtlT, CtlC, CtlOffice, CtlVBIDE; CONST (* PpWindowState *) ppWindowNormal* = 1; ppWindowMinimized* = 2; ppWindowMaximized* = 3; (* PpArrangeStyle *) ppArrangeTiled* = 1; ppArrangeCascade* = 2; (* PpViewType *) ppViewSlide* = 1; ppViewSlideMaster* = 2; ppViewNotesPage* = 3; ppViewHandoutMaster* = 4; ppViewNotesMaster* = 5; ppViewOutline* = 6; ppViewSlideSorter* = 7; ppViewTitleMaster* = 8; ppViewNormal* = 9; (* PpColorSchemeIndex *) ppSchemeColorMixed* = -2; ppNotSchemeColor* = 0; ppBackground* = 1; ppForeground* = 2; ppShadow* = 3; ppTitle* = 4; ppFill* = 5; ppAccent1* = 6; ppAccent2* = 7; ppAccent3* = 8; (* PpSlideSizeType *) ppSlideSizeOnScreen* = 1; ppSlideSizeLetterPaper* = 2; ppSlideSizeA4Paper* = 3; ppSlideSize35MM* = 4; ppSlideSizeOverhead* = 5; ppSlideSizeBanner* = 6; ppSlideSizeCustom* = 7; (* PpSaveAsFileType *) ppSaveAsPresentation* = 1; ppSaveAsPowerPoint7* = 2; ppSaveAsPowerPoint4* = 3; ppSaveAsPowerPoint3* = 4; ppSaveAsTemplate* = 5; ppSaveAsRTF* = 6; ppSaveAsShow* = 7; ppSaveAsAddIn* = 8; ppSaveAsPowerPoint4FarEast* = 10; ppSaveAsDefault* = 11; ppSaveAsHTML* = 12; ppSaveAsHTMLv3* = 13; ppSaveAsHTMLDual* = 14; ppSaveAsMetaFile* = 15; ppSaveAsGIF* = 16; ppSaveAsJPG* = 17; ppSaveAsPNG* = 18; ppSaveAsBMP* = 19; (* PpTextStyleType *) ppDefaultStyle* = 1; ppTitleStyle* = 2; ppBodyStyle* = 3; (* PpSlideLayout *) ppLayoutMixed* = -2; ppLayoutTitle* = 1; ppLayoutText* = 2; ppLayoutTwoColumnText* = 3; ppLayoutTable* = 4; ppLayoutTextAndChart* = 5; ppLayoutChartAndText* = 6; ppLayoutOrgchart* = 7; ppLayoutChart* = 8; ppLayoutTextAndClipart* = 9; ppLayoutClipartAndText* = 10; ppLayoutTitleOnly* = 11; ppLayoutBlank* = 12; ppLayoutTextAndObject* = 13; ppLayoutObjectAndText* = 14; ppLayoutLargeObject* = 15; ppLayoutObject* = 16; ppLayoutTextAndMediaClip* = 17; ppLayoutMediaClipAndText* = 18; ppLayoutObjectOverText* = 19; ppLayoutTextOverObject* = 20; ppLayoutTextAndTwoObjects* = 21; ppLayoutTwoObjectsAndText* = 22; ppLayoutTwoObjectsOverText* = 23; ppLayoutFourObjects* = 24; ppLayoutVerticalText* = 25; ppLayoutClipArtAndVerticalText* = 26; ppLayoutVerticalTitleAndText* = 27; ppLayoutVerticalTitleAndTextOverChart* = 28; (* PpEntryEffect *) ppEffectMixed* = -2; ppEffectNone* = 0; ppEffectCut* = 257; ppEffectCutThroughBlack* = 258; ppEffectRandom* = 513; ppEffectBlindsHorizontal* = 769; ppEffectBlindsVertical* = 770; ppEffectCheckerboardAcross* = 1025; ppEffectCheckerboardDown* = 1026; ppEffectCoverLeft* = 1281; ppEffectCoverUp* = 1282; ppEffectCoverRight* = 1283; ppEffectCoverDown* = 1284; ppEffectCoverLeftUp* = 1285; ppEffectCoverRightUp* = 1286; ppEffectCoverLeftDown* = 1287; ppEffectCoverRightDown* = 1288; ppEffectDissolve* = 1537; ppEffectFade* = 1793; ppEffectUncoverLeft* = 2049; ppEffectUncoverUp* = 2050; ppEffectUncoverRight* = 2051; ppEffectUncoverDown* = 2052; ppEffectUncoverLeftUp* = 2053; ppEffectUncoverRightUp* = 2054; ppEffectUncoverLeftDown* = 2055; ppEffectUncoverRightDown* = 2056; ppEffectRandomBarsHorizontal* = 2305; ppEffectRandomBarsVertical* = 2306; ppEffectStripsUpLeft* = 2561; ppEffectStripsUpRight* = 2562; ppEffectStripsDownLeft* = 2563; ppEffectStripsDownRight* = 2564; ppEffectStripsLeftUp* = 2565; ppEffectStripsRightUp* = 2566; ppEffectStripsLeftDown* = 2567; ppEffectStripsRightDown* = 2568; ppEffectWipeLeft* = 2817; ppEffectWipeUp* = 2818; ppEffectWipeRight* = 2819; ppEffectWipeDown* = 2820; ppEffectBoxOut* = 3073; ppEffectBoxIn* = 3074; ppEffectFlyFromLeft* = 3329; ppEffectFlyFromTop* = 3330; ppEffectFlyFromRight* = 3331; ppEffectFlyFromBottom* = 3332; ppEffectFlyFromTopLeft* = 3333; ppEffectFlyFromTopRight* = 3334; ppEffectFlyFromBottomLeft* = 3335; ppEffectFlyFromBottomRight* = 3336; ppEffectPeekFromLeft* = 3337; ppEffectPeekFromDown* = 3338; ppEffectPeekFromRight* = 3339; ppEffectPeekFromUp* = 3340; ppEffectCrawlFromLeft* = 3341; ppEffectCrawlFromUp* = 3342; ppEffectCrawlFromRight* = 3343; ppEffectCrawlFromDown* = 3344; ppEffectZoomIn* = 3345; ppEffectZoomInSlightly* = 3346; ppEffectZoomOut* = 3347; ppEffectZoomOutSlightly* = 3348; ppEffectZoomCenter* = 3349; ppEffectZoomBottom* = 3350; ppEffectStretchAcross* = 3351; ppEffectStretchLeft* = 3352; ppEffectStretchUp* = 3353; ppEffectStretchRight* = 3354; ppEffectStretchDown* = 3355; ppEffectSwivel* = 3356; ppEffectSpiral* = 3357; ppEffectSplitHorizontalOut* = 3585; ppEffectSplitHorizontalIn* = 3586; ppEffectSplitVerticalOut* = 3587; ppEffectSplitVerticalIn* = 3588; ppEffectFlashOnceFast* = 3841; ppEffectFlashOnceMedium* = 3842; ppEffectFlashOnceSlow* = 3843; ppEffectAppear* = 3844; (* PpTextLevelEffect *) ppAnimateLevelMixed* = -2; ppAnimateLevelNone* = 0; ppAnimateByFirstLevel* = 1; ppAnimateBySecondLevel* = 2; ppAnimateByThirdLevel* = 3; ppAnimateByFourthLevel* = 4; ppAnimateByFifthLevel* = 5; ppAnimateByAllLevels* = 16; (* PpTextUnitEffect *) ppAnimateUnitMixed* = -2; ppAnimateByParagraph* = 0; ppAnimateByWord* = 1; ppAnimateByCharacter* = 2; (* PpChartUnitEffect *) ppAnimateChartMixed* = -2; ppAnimateBySeries* = 1; ppAnimateByCategory* = 2; ppAnimateBySeriesElements* = 3; ppAnimateByCategoryElements* = 4; (* PpAfterEffect *) ppAfterEffectMixed* = -2; ppAfterEffectNothing* = 0; ppAfterEffectHide* = 1; ppAfterEffectDim* = 2; ppAfterEffectHideOnClick* = 3; (* PpAdvanceMode *) ppAdvanceModeMixed* = -2; ppAdvanceOnClick* = 1; ppAdvanceOnTime* = 2; (* PpSoundEffectType *) ppSoundEffectsMixed* = -2; ppSoundNone* = 0; ppSoundStopPrevious* = 1; ppSoundFile* = 2; (* PpFollowColors *) ppFollowColorsMixed* = -2; ppFollowColorsNone* = 0; ppFollowColorsScheme* = 1; ppFollowColorsTextAndBackground* = 2; (* PpUpdateOption *) ppUpdateOptionMixed* = -2; ppUpdateOptionManual* = 1; ppUpdateOptionAutomatic* = 2; (* PpParagraphAlignment *) ppAlignmentMixed* = -2; ppAlignLeft* = 1; ppAlignCenter* = 2; ppAlignRight* = 3; ppAlignJustify* = 4; ppAlignDistribute* = 5; (* PpBaselineAlignment *) ppBaselineAlignMixed* = -2; ppBaselineAlignBaseline* = 1; ppBaselineAlignTop* = 2; ppBaselineAlignCenter* = 3; ppBaselineAlignFarEast50* = 4; (* PpTabStopType *) ppTabStopMixed* = -2; ppTabStopLeft* = 1; ppTabStopCenter* = 2; ppTabStopRight* = 3; ppTabStopDecimal* = 4; (* PpIndentControl *) ppIndentControlMixed* = -2; ppIndentReplaceAttr* = 1; ppIndentKeepAttr* = 2; (* PpChangeCase *) ppCaseSentence* = 1; ppCaseLower* = 2; ppCaseUpper* = 3; ppCaseTitle* = 4; ppCaseToggle* = 5; (* PpDialogMode, hidden *) ppDialogModeMixed* = -2; ppDialogModeless* = 0; ppDialogModal* = 1; (* PpDialogStyle, hidden *) ppDialogStyleMixed* = -2; ppDialogStandard* = 1; ppDialogTabbed* = 2; (* PpDialogPositioning, hidden *) ppDialogPositionNormal* = 1; ppDialogPositionCenterParent* = 2; ppDialogPositionCenterScreen* = 3; ppDialogPositionRememberLast* = 4; (* PpDialogFontStyle, hidden *) ppDialogFontStyleMixed* = -2; ppDialogSmall* = -1; ppDialogItalic* = 0; (* PpScrollBarStyle, hidden *) ppScrollBarVertical* = 0; ppScrollBarHorizontal* = 1; (* PpListBoxSelectionStyle, hidden *) ppListBoxSingle* = 0; ppListBoxMulti* = 1; (* PpListBoxAbbreviationStyle, hidden *) ppListBoxAbbreviationNone* = 0; ppListBoxAbbreviationTruncation* = 1; ppListBoxAbbreviationTruncationWithEllipsis* = 2; ppListBoxAbbreviationFileNames* = 3; (* PpAlertType, hidden *) ppAlertTypeOK* = 0; ppAlertTypeOKCANCEL* = 1; ppAlertTypeYESNO* = 2; ppAlertTypeYESNOCANCEL* = 3; ppAlertTypeBACKNEXTCLOSE* = 4; ppAlertTypeRETRYCANCEL* = 5; ppAlertTypeABORTRETRYIGNORE* = 6; (* PpAlertButton, hidden *) ppAlertButtonCLOSE* = 0; ppAlertButtonSNOOZE* = 1; ppAlertButtonSEARCH* = 2; ppAlertButtonIGNORE* = 3; ppAlertButtonABORT* = 4; ppAlertButtonRETRY* = 5; ppAlertButtonNEXT* = 6; ppAlertButtonBACK* = 7; ppAlertButtonNO* = 8; ppAlertButtonYES* = 9; ppAlertButtonCANCEL* = 10; ppAlertButtonOK* = 11; ppAlertButtonNULL* = 12; (* PpAlertIcon, hidden *) ppAlertIconQuestionMark* = 0; ppAlertIconNote* = 1; ppAlertIconCaution* = 2; ppAlertIconStop* = 3; (* PpSlideShowPointerType *) ppSlideShowPointerNone* = 0; ppSlideShowPointerArrow* = 1; ppSlideShowPointerPen* = 2; ppSlideShowPointerAlwaysHidden* = 3; ppSlideShowPointerAutoArrow* = 4; (* PpSlideShowState *) ppSlideShowRunning* = 1; ppSlideShowPaused* = 2; ppSlideShowBlackScreen* = 3; ppSlideShowWhiteScreen* = 4; ppSlideShowDone* = 5; (* PpSlideShowAdvanceMode *) ppSlideShowManualAdvance* = 1; ppSlideShowUseSlideTimings* = 2; ppSlideShowRehearseNewTimings* = 3; (* PpFileDialogType, hidden *) ppFileDialogOpen* = 1; ppFileDialogSave* = 2; (* PpFileDialogView, hidden *) ppFileDialogViewDetails* = 1; ppFileDialogViewPreview* = 2; ppFileDialogViewProperties* = 3; ppFileDialogViewList* = 4; (* PpPrintOutputType *) ppPrintOutputSlides* = 1; ppPrintOutputTwoSlideHandouts* = 2; ppPrintOutputThreeSlideHandouts* = 3; ppPrintOutputSixSlideHandouts* = 4; ppPrintOutputNotesPages* = 5; ppPrintOutputOutline* = 6; ppPrintOutputBuildSlides* = 7; ppPrintOutputFourSlideHandouts* = 8; ppPrintOutputNineSlideHandouts* = 9; (* PpPrintHandoutOrder *) ppPrintHandoutVerticalFirst* = 1; ppPrintHandoutHorizontalFirst* = 2; (* PpPrintColorType *) ppPrintColor* = 1; ppPrintBlackAndWhite* = 2; ppPrintPureBlackAndWhite* = 3; (* PpSelectionType *) ppSelectionNone* = 0; ppSelectionSlides* = 1; ppSelectionShapes* = 2; ppSelectionText* = 3; (* PpDirection *) ppDirectionMixed* = -2; ppDirectionLeftToRight* = 1; ppDirectionRightToLeft* = 2; (* PpDateTimeFormat *) ppDateTimeFormatMixed* = -2; ppDateTimeMdyy* = 1; ppDateTimeddddMMMMddyyyy* = 2; ppDateTimedMMMMyyyy* = 3; ppDateTimeMMMMdyyyy* = 4; ppDateTimedMMMyy* = 5; ppDateTimeMMMMyy* = 6; ppDateTimeMMyy* = 7; ppDateTimeMMddyyHmm* = 8; ppDateTimeMMddyyhmmAMPM* = 9; ppDateTimeHmm* = 10; ppDateTimeHmmss* = 11; ppDateTimehmmAMPM* = 12; ppDateTimehmmssAMPM* = 13; (* PpTransitionSpeed *) ppTransitionSpeedMixed* = -2; ppTransitionSpeedSlow* = 1; ppTransitionSpeedMedium* = 2; ppTransitionSpeedFast* = 3; (* PpMouseActivation *) ppMouseClick* = 1; ppMouseOver* = 2; (* PpActionType *) ppActionMixed* = -2; ppActionNone* = 0; ppActionNextSlide* = 1; ppActionPreviousSlide* = 2; ppActionFirstSlide* = 3; ppActionLastSlide* = 4; ppActionLastSlideViewed* = 5; ppActionEndShow* = 6; ppActionHyperlink* = 7; ppActionRunMacro* = 8; ppActionRunProgram* = 9; ppActionNamedSlideShow* = 10; ppActionOLEVerb* = 11; ppActionPlay* = 12; (* PpPlaceholderType *) ppPlaceholderMixed* = -2; ppPlaceholderTitle* = 1; ppPlaceholderBody* = 2; ppPlaceholderCenterTitle* = 3; ppPlaceholderSubtitle* = 4; ppPlaceholderVerticalTitle* = 5; ppPlaceholderVerticalBody* = 6; ppPlaceholderObject* = 7; ppPlaceholderChart* = 8; ppPlaceholderBitmap* = 9; ppPlaceholderMediaClip* = 10; ppPlaceholderOrgChart* = 11; ppPlaceholderTable* = 12; ppPlaceholderSlideNumber* = 13; ppPlaceholderHeader* = 14; ppPlaceholderFooter* = 15; ppPlaceholderDate* = 16; (* PpSlideShowType *) ppShowTypeSpeaker* = 1; ppShowTypeWindow* = 2; ppShowTypeKiosk* = 3; (* PpPrintRangeType *) ppPrintAll* = 1; ppPrintSelection* = 2; ppPrintCurrent* = 3; ppPrintSlideRange* = 4; ppPrintNamedSlideShow* = 5; (* PpAutoSize *) ppAutoSizeMixed* = -2; ppAutoSizeNone* = 0; ppAutoSizeShapeToFitText* = 1; (* PpMediaType *) ppMediaTypeMixed* = -2; ppMediaTypeOther* = 1; ppMediaTypeSound* = 2; ppMediaTypeMovie* = 3; (* PpSoundFormatType *) ppSoundFormatMixed* = -2; ppSoundFormatNone* = 0; ppSoundFormatWAV* = 1; ppSoundFormatMIDI* = 2; ppSoundFormatCDAudio* = 3; (* PpFarEastLineBreakLevel *) ppFarEastLineBreakLevelNormal* = 1; ppFarEastLineBreakLevelStrict* = 2; ppFarEastLineBreakLevelCustom* = 3; (* PpSlideShowRangeType *) ppShowAll* = 1; ppShowSlideRange* = 2; ppShowNamedSlideShow* = 3; (* PpFrameColors *) ppFrameColorsBrowserColors* = 1; ppFrameColorsPresentationSchemeTextColor* = 2; ppFrameColorsPresentationSchemeAccentColor* = 3; ppFrameColorsWhiteTextOnBlack* = 4; ppFrameColorsBlackTextOnWhite* = 5; (* PpBorderType *) ppBorderTop* = 1; ppBorderLeft* = 2; ppBorderBottom* = 3; ppBorderRight* = 4; ppBorderDiagonalDown* = 5; ppBorderDiagonalUp* = 6; (* PpHTMLVersion *) ppHTMLv3* = 1; ppHTMLv4* = 2; ppHTMLDual* = 3; (* PpPublishSourceType *) ppPublishAll* = 1; ppPublishSlideRange* = 2; ppPublishNamedSlideShow* = 3; (* PpBulletType *) ppBulletMixed* = -2; ppBulletNone* = 0; ppBulletUnnumbered* = 1; ppBulletNumbered* = 2; ppBulletPicture* = 3; (* PpNumberedBulletStyle *) ppBulletStyleMixed* = -2; ppBulletAlphaLCPeriod* = 0; ppBulletAlphaUCPeriod* = 1; ppBulletArabicParenRight* = 2; ppBulletArabicPeriod* = 3; ppBulletRomanLCParenBoth* = 4; ppBulletRomanLCParenRight* = 5; ppBulletRomanLCPeriod* = 6; ppBulletRomanUCPeriod* = 7; ppBulletAlphaLCParenBoth* = 8; ppBulletAlphaLCParenRight* = 9; ppBulletAlphaUCParenBoth* = 10; ppBulletAlphaUCParenRight* = 11; ppBulletArabicParenBoth* = 12; ppBulletArabicPlain* = 13; ppBulletRomanUCParenBoth* = 14; ppBulletRomanUCParenRight* = 15; ppBulletSimpChinPlain* = 16; ppBulletSimpChinPeriod* = 17; ppBulletCircleNumDBPlain* = 18; ppBulletCircleNumWDWhitePlain* = 19; ppBulletCircleNumWDBlackPlain* = 20; ppBulletTradChinPlain* = 21; ppBulletTradChinPeriod* = 22; ppBulletArabicAlphaDash* = 23; ppBulletArabicAbjadDash* = 24; ppBulletHebrewAlphaDash* = 25; ppBulletKanjiKoreanPlain* = 26; ppBulletKanjiKoreanPeriod* = 27; ppBulletArabicDBPlain* = 28; ppBulletArabicDBPeriod* = 29; (* PpMarkerType, hidden *) ppBoot* = 0; ppFileNew* = 1; ppFileOpen* = 2; ppFileSave* = 3; ppPrintForeground* = 4; ppPrintBackground* = 5; ppOLEInsert* = 6; ppSlideShowStart* = 7; ppSlideShowDraw* = 8; ppSlideViewScroll* = 9; ppDialogStart* = 10; (* PpShapeFormat, hidden *) ppShapeFormatGIF* = 0; ppShapeFormatJPG* = 1; ppShapeFormatPNG* = 2; ppShapeFormatBMP* = 3; ppShapeFormatWMF* = 4; (* PpExportMode, hidden *) ppRelativeToSlide* = 1; ppClipRelativeToSlide* = 2; ppScaleToFit* = 3; ppScaleXY* = 4; TYPE PpWindowState* = INTEGER; PpArrangeStyle* = INTEGER; PpViewType* = INTEGER; PpColorSchemeIndex* = INTEGER; PpSlideSizeType* = INTEGER; PpSaveAsFileType* = INTEGER; PpTextStyleType* = INTEGER; PpSlideLayout* = INTEGER; PpEntryEffect* = INTEGER; PpTextLevelEffect* = INTEGER; PpTextUnitEffect* = INTEGER; PpChartUnitEffect* = INTEGER; PpAfterEffect* = INTEGER; PpAdvanceMode* = INTEGER; PpSoundEffectType* = INTEGER; PpFollowColors* = INTEGER; PpUpdateOption* = INTEGER; PpParagraphAlignment* = INTEGER; PpBaselineAlignment* = INTEGER; PpTabStopType* = INTEGER; PpIndentControl* = INTEGER; PpChangeCase* = INTEGER; PpDialogMode* = INTEGER; PpDialogStyle* = INTEGER; PpDialogPositioning* = INTEGER; PpDialogFontStyle* = INTEGER; PpScrollBarStyle* = INTEGER; PpListBoxSelectionStyle* = INTEGER; PpListBoxAbbreviationStyle* = INTEGER; PpAlertType* = INTEGER; PpAlertButton* = INTEGER; PpAlertIcon* = INTEGER; PpSlideShowPointerType* = INTEGER; PpSlideShowState* = INTEGER; PpSlideShowAdvanceMode* = INTEGER; PpFileDialogType* = INTEGER; PpFileDialogView* = INTEGER; PpPrintOutputType* = INTEGER; PpPrintHandoutOrder* = INTEGER; PpPrintColorType* = INTEGER; PpSelectionType* = INTEGER; PpDirection* = INTEGER; PpDateTimeFormat* = INTEGER; PpTransitionSpeed* = INTEGER; PpMouseActivation* = INTEGER; PpActionType* = INTEGER; PpPlaceholderType* = INTEGER; PpSlideShowType* = INTEGER; PpPrintRangeType* = INTEGER; PpAutoSize* = INTEGER; PpMediaType* = INTEGER; PpSoundFormatType* = INTEGER; PpFarEastLineBreakLevel* = INTEGER; PpSlideShowRangeType* = INTEGER; PpFrameColors* = INTEGER; Collection* = POINTER TO RECORD (CtlT.Object) END; _Application* = POINTER TO RECORD (CtlT.Object) END; _Global* = POINTER TO RECORD (CtlT.Object) END; Application* = _Application; Global* = _Global; ColorFormat* = POINTER TO RECORD (CtlT.Object) END; SlideShowWindow* = POINTER TO RECORD (CtlT.Object) END; Selection* = POINTER TO RECORD (CtlT.Object) END; DocumentWindows* = POINTER TO RECORD (CtlT.Object) END; SlideShowWindows* = POINTER TO RECORD (CtlT.Object) END; DocumentWindow* = POINTER TO RECORD (CtlT.Object) END; View* = POINTER TO RECORD (CtlT.Object) END; SlideShowView* = POINTER TO RECORD (CtlT.Object) END; SlideShowSettings* = POINTER TO RECORD (CtlT.Object) END; NamedSlideShows* = POINTER TO RECORD (CtlT.Object) END; NamedSlideShow* = POINTER TO RECORD (CtlT.Object) END; PrintOptions* = POINTER TO RECORD (CtlT.Object) END; PrintRanges* = POINTER TO RECORD (CtlT.Object) END; PrintRange* = POINTER TO RECORD (CtlT.Object) END; AddIns* = POINTER TO RECORD (CtlT.Object) END; AddIn* = POINTER TO RECORD (CtlT.Object) END; Presentations* = POINTER TO RECORD (CtlT.Object) END; Presentation* = _Presentation; Hyperlinks* = POINTER TO RECORD (CtlT.Object) END; Hyperlink* = POINTER TO RECORD (CtlT.Object) END; PageSetup* = POINTER TO RECORD (CtlT.Object) END; Fonts* = POINTER TO RECORD (CtlT.Object) END; ExtraColors* = POINTER TO RECORD (CtlT.Object) END; Slides* = POINTER TO RECORD (CtlT.Object) END; _Slide* = POINTER TO RECORD (CtlT.Object) END; SlideRange* = POINTER TO RECORD (CtlT.Object) END; _Master* = POINTER TO RECORD (CtlT.Object) END; Slide* = _Slide; ColorSchemes* = POINTER TO RECORD (CtlT.Object) END; ColorScheme* = POINTER TO RECORD (CtlT.Object) END; RGBColor* = POINTER TO RECORD (CtlT.Object) END; SlideShowTransition* = POINTER TO RECORD (CtlT.Object) END; SoundEffect* = POINTER TO RECORD (CtlT.Object) END; SoundFormat* = POINTER TO RECORD (CtlT.Object) END; HeadersFooters* = POINTER TO RECORD (CtlT.Object) END; Shapes* = POINTER TO RECORD (CtlT.Object) END; Placeholders* = POINTER TO RECORD (CtlT.Object) END; PlaceholderFormat* = POINTER TO RECORD (CtlT.Object) END; FreeformBuilder* = POINTER TO RECORD (CtlT.Object) END; Shape* = POINTER TO RECORD (CtlT.Object) END; ShapeRange* = POINTER TO RECORD (CtlT.Object) END; GroupShapes* = POINTER TO RECORD (CtlT.Object) END; Adjustments* = POINTER TO RECORD (CtlT.Object) END; PictureFormat* = POINTER TO RECORD (CtlT.Object) END; FillFormat* = POINTER TO RECORD (CtlT.Object) END; LineFormat* = POINTER TO RECORD (CtlT.Object) END; ShadowFormat* = POINTER TO RECORD (CtlT.Object) END; ConnectorFormat* = POINTER TO RECORD (CtlT.Object) END; TextEffectFormat* = POINTER TO RECORD (CtlT.Object) END; ThreeDFormat* = POINTER TO RECORD (CtlT.Object) END; TextFrame* = POINTER TO RECORD (CtlT.Object) END; CalloutFormat* = POINTER TO RECORD (CtlT.Object) END; ShapeNodes* = POINTER TO RECORD (CtlT.Object) END; ShapeNode* = POINTER TO RECORD (CtlT.Object) END; OLEFormat* = POINTER TO RECORD (CtlT.Object) END; LinkFormat* = POINTER TO RECORD (CtlT.Object) END; ObjectVerbs* = POINTER TO RECORD (CtlT.Object) END; AnimationSettings* = POINTER TO RECORD (CtlT.Object) END; ActionSettings* = POINTER TO RECORD (CtlT.Object) END; ActionSetting* = POINTER TO RECORD (CtlT.Object) END; PlaySettings* = POINTER TO RECORD (CtlT.Object) END; TextRange* = POINTER TO RECORD (CtlT.Object) END; Ruler* = POINTER TO RECORD (CtlT.Object) END; RulerLevels* = POINTER TO RECORD (CtlT.Object) END; RulerLevel* = POINTER TO RECORD (CtlT.Object) END; TabStops* = POINTER TO RECORD (CtlT.Object) END; TabStop* = POINTER TO RECORD (CtlT.Object) END; Font* = POINTER TO RECORD (CtlT.Object) END; ParagraphFormat* = POINTER TO RECORD (CtlT.Object) END; BulletFormat* = POINTER TO RECORD (CtlT.Object) END; TextStyles* = POINTER TO RECORD (CtlT.Object) END; TextStyle* = POINTER TO RECORD (CtlT.Object) END; TextStyleLevels* = POINTER TO RECORD (CtlT.Object) END; TextStyleLevel* = POINTER TO RECORD (CtlT.Object) END; HeaderFooter* = POINTER TO RECORD (CtlT.Object) END; _Presentation* = POINTER TO RECORD (CtlT.Object) END; PPDialogs* = POINTER TO RECORD (CtlT.Object) END; PPAlert* = POINTER TO RECORD (CtlT.Object) END; PPDialog* = POINTER TO RECORD (CtlT.Object) END; PPTabSheet* = POINTER TO RECORD (CtlT.Object) END; PPControls* = POINTER TO RECORD (CtlT.Object) END; PPTabSheets* = POINTER TO RECORD (CtlT.Object) END; PPControl* = POINTER TO RECORD (CtlT.Object) END; PPPushButton* = POINTER TO RECORD (CtlT.Object) END; PPToggleButton* = POINTER TO RECORD (CtlT.Object) END; PPBitmapButton* = POINTER TO RECORD (CtlT.Object) END; PPListBox* = POINTER TO RECORD (CtlT.Object) END; PPStrings* = POINTER TO RECORD (CtlT.Object) END; PPCheckBox* = POINTER TO RECORD (CtlT.Object) END; PPRadioCluster* = POINTER TO RECORD (CtlT.Object) END; PPStaticText* = POINTER TO RECORD (CtlT.Object) END; PPEditText* = POINTER TO RECORD (CtlT.Object) END; PPIcon* = POINTER TO RECORD (CtlT.Object) END; PPBitmap* = POINTER TO RECORD (CtlT.Object) END; PPSpinner* = POINTER TO RECORD (CtlT.Object) END; PPScrollBar* = POINTER TO RECORD (CtlT.Object) END; PPGroupBox* = POINTER TO RECORD (CtlT.Object) END; PPFrame* = POINTER TO RECORD (CtlT.Object) END; PPTabControl* = POINTER TO RECORD (CtlT.Object) END; PPDropDown* = POINTER TO RECORD (CtlT.Object) END; PPDropDownEdit* = POINTER TO RECORD (CtlT.Object) END; PPSlideMiniature* = POINTER TO RECORD (CtlT.Object) END; PPRadioButton* = POINTER TO RECORD (CtlT.Object) END; Tags* = POINTER TO RECORD (CtlT.Object) END; FileDialogFileList* = POINTER TO RECORD (CtlT.Object) END; FileDialogExtension* = POINTER TO RECORD (CtlT.Object) END; FileDialogExtensionList* = POINTER TO RECORD (CtlT.Object) END; FileDialog* = POINTER TO RECORD (CtlT.Object) END; OCXExtender* = POINTER TO RECORD (CtlT.Object) END; OLEControl* = OCXExtender; PpBorderType* = INTEGER; PpHTMLVersion* = INTEGER; PpPublishSourceType* = INTEGER; PpBulletType* = INTEGER; PpNumberedBulletStyle* = INTEGER; PpMarkerType* = INTEGER; PpShapeFormat* = INTEGER; PpExportMode* = INTEGER; Table* = POINTER TO RECORD (CtlT.Object) END; Columns* = POINTER TO RECORD (CtlT.Object) END; Column* = POINTER TO RECORD (CtlT.Object) END; Rows* = POINTER TO RECORD (CtlT.Object) END; Row* = POINTER TO RECORD (CtlT.Object) END; CellRange* = POINTER TO RECORD (CtlT.Object) END; Cell* = POINTER TO RECORD (CtlT.Object) END; Borders* = POINTER TO RECORD (CtlT.Object) END; Panes* = POINTER TO RECORD (CtlT.Object) END; Pane* = POINTER TO RECORD (CtlT.Object) END; DefaultWebOptions* = POINTER TO RECORD (CtlT.Object) END; WebOptions* = POINTER TO RECORD (CtlT.Object) END; PublishObjects* = POINTER TO RECORD (CtlT.Object) END; PublishObject* = POINTER TO RECORD (CtlT.Object) END; Marker* = POINTER TO RECORD (CtlT.Object) END; Master* = _Master; PROCEDURE ThisCollection* (v: CtlT.Any): Collection; VAR new: Collection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493450-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisCollection; PROCEDURE IsCollection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493450-5A91-11CF-8700-00AA0060263B}") END IsCollection; PROCEDURE This_Application* (v: CtlT.Any): _Application; VAR new: _Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493442-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END This_Application; PROCEDURE Is_Application* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493442-5A91-11CF-8700-00AA0060263B}") END Is_Application; PROCEDURE This_Global* (v: CtlT.Any): _Global; VAR new: _Global; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493451-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END This_Global; PROCEDURE Is_Global* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493451-5A91-11CF-8700-00AA0060263B}") END Is_Global; PROCEDURE ThisColorFormat* (v: CtlT.Any): ColorFormat; VAR new: ColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493452-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisColorFormat; PROCEDURE IsColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493452-5A91-11CF-8700-00AA0060263B}") END IsColorFormat; PROCEDURE ThisSlideShowWindow* (v: CtlT.Any): SlideShowWindow; VAR new: SlideShowWindow; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493453-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideShowWindow; PROCEDURE IsSlideShowWindow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493453-5A91-11CF-8700-00AA0060263B}") END IsSlideShowWindow; PROCEDURE ThisSelection* (v: CtlT.Any): Selection; VAR new: Selection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493454-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSelection; PROCEDURE IsSelection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493454-5A91-11CF-8700-00AA0060263B}") END IsSelection; PROCEDURE ThisDocumentWindows* (v: CtlT.Any): DocumentWindows; VAR new: DocumentWindows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493455-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisDocumentWindows; PROCEDURE IsDocumentWindows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493455-5A91-11CF-8700-00AA0060263B}") END IsDocumentWindows; PROCEDURE ThisSlideShowWindows* (v: CtlT.Any): SlideShowWindows; VAR new: SlideShowWindows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493456-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideShowWindows; PROCEDURE IsSlideShowWindows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493456-5A91-11CF-8700-00AA0060263B}") END IsSlideShowWindows; PROCEDURE ThisDocumentWindow* (v: CtlT.Any): DocumentWindow; VAR new: DocumentWindow; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493457-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisDocumentWindow; PROCEDURE IsDocumentWindow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493457-5A91-11CF-8700-00AA0060263B}") END IsDocumentWindow; PROCEDURE ThisView* (v: CtlT.Any): View; VAR new: View; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493458-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisView; PROCEDURE IsView* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493458-5A91-11CF-8700-00AA0060263B}") END IsView; PROCEDURE ThisSlideShowView* (v: CtlT.Any): SlideShowView; VAR new: SlideShowView; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493459-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideShowView; PROCEDURE IsSlideShowView* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493459-5A91-11CF-8700-00AA0060263B}") END IsSlideShowView; PROCEDURE ThisSlideShowSettings* (v: CtlT.Any): SlideShowSettings; VAR new: SlideShowSettings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345A-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideShowSettings; PROCEDURE IsSlideShowSettings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345A-5A91-11CF-8700-00AA0060263B}") END IsSlideShowSettings; PROCEDURE ThisNamedSlideShows* (v: CtlT.Any): NamedSlideShows; VAR new: NamedSlideShows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345B-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisNamedSlideShows; PROCEDURE IsNamedSlideShows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345B-5A91-11CF-8700-00AA0060263B}") END IsNamedSlideShows; PROCEDURE ThisNamedSlideShow* (v: CtlT.Any): NamedSlideShow; VAR new: NamedSlideShow; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345C-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisNamedSlideShow; PROCEDURE IsNamedSlideShow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345C-5A91-11CF-8700-00AA0060263B}") END IsNamedSlideShow; PROCEDURE ThisPrintOptions* (v: CtlT.Any): PrintOptions; VAR new: PrintOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345D-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPrintOptions; PROCEDURE IsPrintOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345D-5A91-11CF-8700-00AA0060263B}") END IsPrintOptions; PROCEDURE ThisPrintRanges* (v: CtlT.Any): PrintRanges; VAR new: PrintRanges; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345E-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPrintRanges; PROCEDURE IsPrintRanges* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345E-5A91-11CF-8700-00AA0060263B}") END IsPrintRanges; PROCEDURE ThisPrintRange* (v: CtlT.Any): PrintRange; VAR new: PrintRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149345F-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPrintRange; PROCEDURE IsPrintRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149345F-5A91-11CF-8700-00AA0060263B}") END IsPrintRange; PROCEDURE ThisAddIns* (v: CtlT.Any): AddIns; VAR new: AddIns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493460-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisAddIns; PROCEDURE IsAddIns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493460-5A91-11CF-8700-00AA0060263B}") END IsAddIns; PROCEDURE ThisAddIn* (v: CtlT.Any): AddIn; VAR new: AddIn; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493461-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisAddIn; PROCEDURE IsAddIn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493461-5A91-11CF-8700-00AA0060263B}") END IsAddIn; PROCEDURE ThisPresentations* (v: CtlT.Any): Presentations; VAR new: Presentations; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493462-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPresentations; PROCEDURE IsPresentations* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493462-5A91-11CF-8700-00AA0060263B}") END IsPresentations; PROCEDURE ThisHyperlinks* (v: CtlT.Any): Hyperlinks; VAR new: Hyperlinks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493464-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisHyperlinks; PROCEDURE IsHyperlinks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493464-5A91-11CF-8700-00AA0060263B}") END IsHyperlinks; PROCEDURE ThisHyperlink* (v: CtlT.Any): Hyperlink; VAR new: Hyperlink; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493465-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisHyperlink; PROCEDURE IsHyperlink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493465-5A91-11CF-8700-00AA0060263B}") END IsHyperlink; PROCEDURE ThisPageSetup* (v: CtlT.Any): PageSetup; VAR new: PageSetup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493466-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPageSetup; PROCEDURE IsPageSetup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493466-5A91-11CF-8700-00AA0060263B}") END IsPageSetup; PROCEDURE ThisFonts* (v: CtlT.Any): Fonts; VAR new: Fonts; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493467-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFonts; PROCEDURE IsFonts* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493467-5A91-11CF-8700-00AA0060263B}") END IsFonts; PROCEDURE ThisExtraColors* (v: CtlT.Any): ExtraColors; VAR new: ExtraColors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493468-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisExtraColors; PROCEDURE IsExtraColors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493468-5A91-11CF-8700-00AA0060263B}") END IsExtraColors; PROCEDURE ThisSlides* (v: CtlT.Any): Slides; VAR new: Slides; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493469-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlides; PROCEDURE IsSlides* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493469-5A91-11CF-8700-00AA0060263B}") END IsSlides; PROCEDURE This_Slide* (v: CtlT.Any): _Slide; VAR new: _Slide; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149346A-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END This_Slide; PROCEDURE Is_Slide* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149346A-5A91-11CF-8700-00AA0060263B}") END Is_Slide; PROCEDURE ThisSlideRange* (v: CtlT.Any): SlideRange; VAR new: SlideRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149346B-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideRange; PROCEDURE IsSlideRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149346B-5A91-11CF-8700-00AA0060263B}") END IsSlideRange; PROCEDURE This_Master* (v: CtlT.Any): _Master; VAR new: _Master; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149346C-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END This_Master; PROCEDURE Is_Master* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149346C-5A91-11CF-8700-00AA0060263B}") END Is_Master; PROCEDURE ThisColorSchemes* (v: CtlT.Any): ColorSchemes; VAR new: ColorSchemes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149346E-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisColorSchemes; PROCEDURE IsColorSchemes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149346E-5A91-11CF-8700-00AA0060263B}") END IsColorSchemes; PROCEDURE ThisColorScheme* (v: CtlT.Any): ColorScheme; VAR new: ColorScheme; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149346F-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisColorScheme; PROCEDURE IsColorScheme* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149346F-5A91-11CF-8700-00AA0060263B}") END IsColorScheme; PROCEDURE ThisRGBColor* (v: CtlT.Any): RGBColor; VAR new: RGBColor; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493470-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRGBColor; PROCEDURE IsRGBColor* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493470-5A91-11CF-8700-00AA0060263B}") END IsRGBColor; PROCEDURE ThisSlideShowTransition* (v: CtlT.Any): SlideShowTransition; VAR new: SlideShowTransition; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493471-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSlideShowTransition; PROCEDURE IsSlideShowTransition* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493471-5A91-11CF-8700-00AA0060263B}") END IsSlideShowTransition; PROCEDURE ThisSoundEffect* (v: CtlT.Any): SoundEffect; VAR new: SoundEffect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493472-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSoundEffect; PROCEDURE IsSoundEffect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493472-5A91-11CF-8700-00AA0060263B}") END IsSoundEffect; PROCEDURE ThisSoundFormat* (v: CtlT.Any): SoundFormat; VAR new: SoundFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493473-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisSoundFormat; PROCEDURE IsSoundFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493473-5A91-11CF-8700-00AA0060263B}") END IsSoundFormat; PROCEDURE ThisHeadersFooters* (v: CtlT.Any): HeadersFooters; VAR new: HeadersFooters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493474-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisHeadersFooters; PROCEDURE IsHeadersFooters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493474-5A91-11CF-8700-00AA0060263B}") END IsHeadersFooters; PROCEDURE ThisShapes* (v: CtlT.Any): Shapes; VAR new: Shapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493475-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShapes; PROCEDURE IsShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493475-5A91-11CF-8700-00AA0060263B}") END IsShapes; PROCEDURE ThisPlaceholders* (v: CtlT.Any): Placeholders; VAR new: Placeholders; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493476-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPlaceholders; PROCEDURE IsPlaceholders* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493476-5A91-11CF-8700-00AA0060263B}") END IsPlaceholders; PROCEDURE ThisPlaceholderFormat* (v: CtlT.Any): PlaceholderFormat; VAR new: PlaceholderFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493477-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPlaceholderFormat; PROCEDURE IsPlaceholderFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493477-5A91-11CF-8700-00AA0060263B}") END IsPlaceholderFormat; PROCEDURE ThisFreeformBuilder* (v: CtlT.Any): FreeformBuilder; VAR new: FreeformBuilder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493478-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFreeformBuilder; PROCEDURE IsFreeformBuilder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493478-5A91-11CF-8700-00AA0060263B}") END IsFreeformBuilder; PROCEDURE ThisShape* (v: CtlT.Any): Shape; VAR new: Shape; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493479-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShape; PROCEDURE IsShape* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493479-5A91-11CF-8700-00AA0060263B}") END IsShape; PROCEDURE ThisShapeRange* (v: CtlT.Any): ShapeRange; VAR new: ShapeRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347A-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShapeRange; PROCEDURE IsShapeRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347A-5A91-11CF-8700-00AA0060263B}") END IsShapeRange; PROCEDURE ThisGroupShapes* (v: CtlT.Any): GroupShapes; VAR new: GroupShapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347B-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisGroupShapes; PROCEDURE IsGroupShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347B-5A91-11CF-8700-00AA0060263B}") END IsGroupShapes; PROCEDURE ThisAdjustments* (v: CtlT.Any): Adjustments; VAR new: Adjustments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347C-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisAdjustments; PROCEDURE IsAdjustments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347C-5A91-11CF-8700-00AA0060263B}") END IsAdjustments; PROCEDURE ThisPictureFormat* (v: CtlT.Any): PictureFormat; VAR new: PictureFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347D-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPictureFormat; PROCEDURE IsPictureFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347D-5A91-11CF-8700-00AA0060263B}") END IsPictureFormat; PROCEDURE ThisFillFormat* (v: CtlT.Any): FillFormat; VAR new: FillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347E-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFillFormat; PROCEDURE IsFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347E-5A91-11CF-8700-00AA0060263B}") END IsFillFormat; PROCEDURE ThisLineFormat* (v: CtlT.Any): LineFormat; VAR new: LineFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149347F-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisLineFormat; PROCEDURE IsLineFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149347F-5A91-11CF-8700-00AA0060263B}") END IsLineFormat; PROCEDURE ThisShadowFormat* (v: CtlT.Any): ShadowFormat; VAR new: ShadowFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493480-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShadowFormat; PROCEDURE IsShadowFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493480-5A91-11CF-8700-00AA0060263B}") END IsShadowFormat; PROCEDURE ThisConnectorFormat* (v: CtlT.Any): ConnectorFormat; VAR new: ConnectorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493481-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisConnectorFormat; PROCEDURE IsConnectorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493481-5A91-11CF-8700-00AA0060263B}") END IsConnectorFormat; PROCEDURE ThisTextEffectFormat* (v: CtlT.Any): TextEffectFormat; VAR new: TextEffectFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493482-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextEffectFormat; PROCEDURE IsTextEffectFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493482-5A91-11CF-8700-00AA0060263B}") END IsTextEffectFormat; PROCEDURE ThisThreeDFormat* (v: CtlT.Any): ThreeDFormat; VAR new: ThreeDFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493483-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisThreeDFormat; PROCEDURE IsThreeDFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493483-5A91-11CF-8700-00AA0060263B}") END IsThreeDFormat; PROCEDURE ThisTextFrame* (v: CtlT.Any): TextFrame; VAR new: TextFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493484-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextFrame; PROCEDURE IsTextFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493484-5A91-11CF-8700-00AA0060263B}") END IsTextFrame; PROCEDURE ThisCalloutFormat* (v: CtlT.Any): CalloutFormat; VAR new: CalloutFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493485-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisCalloutFormat; PROCEDURE IsCalloutFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493485-5A91-11CF-8700-00AA0060263B}") END IsCalloutFormat; PROCEDURE ThisShapeNodes* (v: CtlT.Any): ShapeNodes; VAR new: ShapeNodes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493486-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShapeNodes; PROCEDURE IsShapeNodes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493486-5A91-11CF-8700-00AA0060263B}") END IsShapeNodes; PROCEDURE ThisShapeNode* (v: CtlT.Any): ShapeNode; VAR new: ShapeNode; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493487-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisShapeNode; PROCEDURE IsShapeNode* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493487-5A91-11CF-8700-00AA0060263B}") END IsShapeNode; PROCEDURE ThisOLEFormat* (v: CtlT.Any): OLEFormat; VAR new: OLEFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493488-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisOLEFormat; PROCEDURE IsOLEFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493488-5A91-11CF-8700-00AA0060263B}") END IsOLEFormat; PROCEDURE ThisLinkFormat* (v: CtlT.Any): LinkFormat; VAR new: LinkFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493489-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisLinkFormat; PROCEDURE IsLinkFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493489-5A91-11CF-8700-00AA0060263B}") END IsLinkFormat; PROCEDURE ThisObjectVerbs* (v: CtlT.Any): ObjectVerbs; VAR new: ObjectVerbs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348A-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisObjectVerbs; PROCEDURE IsObjectVerbs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348A-5A91-11CF-8700-00AA0060263B}") END IsObjectVerbs; PROCEDURE ThisAnimationSettings* (v: CtlT.Any): AnimationSettings; VAR new: AnimationSettings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348B-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisAnimationSettings; PROCEDURE IsAnimationSettings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348B-5A91-11CF-8700-00AA0060263B}") END IsAnimationSettings; PROCEDURE ThisActionSettings* (v: CtlT.Any): ActionSettings; VAR new: ActionSettings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348C-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisActionSettings; PROCEDURE IsActionSettings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348C-5A91-11CF-8700-00AA0060263B}") END IsActionSettings; PROCEDURE ThisActionSetting* (v: CtlT.Any): ActionSetting; VAR new: ActionSetting; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348D-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisActionSetting; PROCEDURE IsActionSetting* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348D-5A91-11CF-8700-00AA0060263B}") END IsActionSetting; PROCEDURE ThisPlaySettings* (v: CtlT.Any): PlaySettings; VAR new: PlaySettings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348E-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPlaySettings; PROCEDURE IsPlaySettings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348E-5A91-11CF-8700-00AA0060263B}") END IsPlaySettings; PROCEDURE ThisTextRange* (v: CtlT.Any): TextRange; VAR new: TextRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149348F-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextRange; PROCEDURE IsTextRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149348F-5A91-11CF-8700-00AA0060263B}") END IsTextRange; PROCEDURE ThisRuler* (v: CtlT.Any): Ruler; VAR new: Ruler; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493490-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRuler; PROCEDURE IsRuler* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493490-5A91-11CF-8700-00AA0060263B}") END IsRuler; PROCEDURE ThisRulerLevels* (v: CtlT.Any): RulerLevels; VAR new: RulerLevels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493491-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRulerLevels; PROCEDURE IsRulerLevels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493491-5A91-11CF-8700-00AA0060263B}") END IsRulerLevels; PROCEDURE ThisRulerLevel* (v: CtlT.Any): RulerLevel; VAR new: RulerLevel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493492-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRulerLevel; PROCEDURE IsRulerLevel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493492-5A91-11CF-8700-00AA0060263B}") END IsRulerLevel; PROCEDURE ThisTabStops* (v: CtlT.Any): TabStops; VAR new: TabStops; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493493-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTabStops; PROCEDURE IsTabStops* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493493-5A91-11CF-8700-00AA0060263B}") END IsTabStops; PROCEDURE ThisTabStop* (v: CtlT.Any): TabStop; VAR new: TabStop; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493494-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTabStop; PROCEDURE IsTabStop* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493494-5A91-11CF-8700-00AA0060263B}") END IsTabStop; PROCEDURE ThisFont* (v: CtlT.Any): Font; VAR new: Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493495-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFont; PROCEDURE IsFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493495-5A91-11CF-8700-00AA0060263B}") END IsFont; PROCEDURE ThisParagraphFormat* (v: CtlT.Any): ParagraphFormat; VAR new: ParagraphFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493496-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisParagraphFormat; PROCEDURE IsParagraphFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493496-5A91-11CF-8700-00AA0060263B}") END IsParagraphFormat; PROCEDURE ThisBulletFormat* (v: CtlT.Any): BulletFormat; VAR new: BulletFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493497-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisBulletFormat; PROCEDURE IsBulletFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493497-5A91-11CF-8700-00AA0060263B}") END IsBulletFormat; PROCEDURE ThisTextStyles* (v: CtlT.Any): TextStyles; VAR new: TextStyles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493498-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextStyles; PROCEDURE IsTextStyles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493498-5A91-11CF-8700-00AA0060263B}") END IsTextStyles; PROCEDURE ThisTextStyle* (v: CtlT.Any): TextStyle; VAR new: TextStyle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{91493499-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextStyle; PROCEDURE IsTextStyle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{91493499-5A91-11CF-8700-00AA0060263B}") END IsTextStyle; PROCEDURE ThisTextStyleLevels* (v: CtlT.Any): TextStyleLevels; VAR new: TextStyleLevels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349A-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextStyleLevels; PROCEDURE IsTextStyleLevels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349A-5A91-11CF-8700-00AA0060263B}") END IsTextStyleLevels; PROCEDURE ThisTextStyleLevel* (v: CtlT.Any): TextStyleLevel; VAR new: TextStyleLevel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349B-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTextStyleLevel; PROCEDURE IsTextStyleLevel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349B-5A91-11CF-8700-00AA0060263B}") END IsTextStyleLevel; PROCEDURE ThisHeaderFooter* (v: CtlT.Any): HeaderFooter; VAR new: HeaderFooter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349C-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisHeaderFooter; PROCEDURE IsHeaderFooter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349C-5A91-11CF-8700-00AA0060263B}") END IsHeaderFooter; PROCEDURE This_Presentation* (v: CtlT.Any): _Presentation; VAR new: _Presentation; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349D-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END This_Presentation; PROCEDURE Is_Presentation* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349D-5A91-11CF-8700-00AA0060263B}") END Is_Presentation; PROCEDURE ThisPPDialogs* (v: CtlT.Any): PPDialogs; VAR new: PPDialogs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349E-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPDialogs; PROCEDURE IsPPDialogs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349E-5A91-11CF-8700-00AA0060263B}") END IsPPDialogs; PROCEDURE ThisPPAlert* (v: CtlT.Any): PPAlert; VAR new: PPAlert; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{9149349F-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPAlert; PROCEDURE IsPPAlert* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{9149349F-5A91-11CF-8700-00AA0060263B}") END IsPPAlert; PROCEDURE ThisPPDialog* (v: CtlT.Any): PPDialog; VAR new: PPDialog; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A0-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPDialog; PROCEDURE IsPPDialog* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A0-5A91-11CF-8700-00AA0060263B}") END IsPPDialog; PROCEDURE ThisPPTabSheet* (v: CtlT.Any): PPTabSheet; VAR new: PPTabSheet; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A1-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPTabSheet; PROCEDURE IsPPTabSheet* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A1-5A91-11CF-8700-00AA0060263B}") END IsPPTabSheet; PROCEDURE ThisPPControls* (v: CtlT.Any): PPControls; VAR new: PPControls; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A2-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPControls; PROCEDURE IsPPControls* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A2-5A91-11CF-8700-00AA0060263B}") END IsPPControls; PROCEDURE ThisPPTabSheets* (v: CtlT.Any): PPTabSheets; VAR new: PPTabSheets; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A3-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPTabSheets; PROCEDURE IsPPTabSheets* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A3-5A91-11CF-8700-00AA0060263B}") END IsPPTabSheets; PROCEDURE ThisPPControl* (v: CtlT.Any): PPControl; VAR new: PPControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A4-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPControl; PROCEDURE IsPPControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A4-5A91-11CF-8700-00AA0060263B}") END IsPPControl; PROCEDURE ThisPPPushButton* (v: CtlT.Any): PPPushButton; VAR new: PPPushButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A5-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPPushButton; PROCEDURE IsPPPushButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A5-5A91-11CF-8700-00AA0060263B}") END IsPPPushButton; PROCEDURE ThisPPToggleButton* (v: CtlT.Any): PPToggleButton; VAR new: PPToggleButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A6-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPToggleButton; PROCEDURE IsPPToggleButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A6-5A91-11CF-8700-00AA0060263B}") END IsPPToggleButton; PROCEDURE ThisPPBitmapButton* (v: CtlT.Any): PPBitmapButton; VAR new: PPBitmapButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A7-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPBitmapButton; PROCEDURE IsPPBitmapButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A7-5A91-11CF-8700-00AA0060263B}") END IsPPBitmapButton; PROCEDURE ThisPPListBox* (v: CtlT.Any): PPListBox; VAR new: PPListBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A8-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPListBox; PROCEDURE IsPPListBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A8-5A91-11CF-8700-00AA0060263B}") END IsPPListBox; PROCEDURE ThisPPStrings* (v: CtlT.Any): PPStrings; VAR new: PPStrings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934A9-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPStrings; PROCEDURE IsPPStrings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934A9-5A91-11CF-8700-00AA0060263B}") END IsPPStrings; PROCEDURE ThisPPCheckBox* (v: CtlT.Any): PPCheckBox; VAR new: PPCheckBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AA-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPCheckBox; PROCEDURE IsPPCheckBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AA-5A91-11CF-8700-00AA0060263B}") END IsPPCheckBox; PROCEDURE ThisPPRadioCluster* (v: CtlT.Any): PPRadioCluster; VAR new: PPRadioCluster; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AB-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPRadioCluster; PROCEDURE IsPPRadioCluster* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AB-5A91-11CF-8700-00AA0060263B}") END IsPPRadioCluster; PROCEDURE ThisPPStaticText* (v: CtlT.Any): PPStaticText; VAR new: PPStaticText; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AC-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPStaticText; PROCEDURE IsPPStaticText* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AC-5A91-11CF-8700-00AA0060263B}") END IsPPStaticText; PROCEDURE ThisPPEditText* (v: CtlT.Any): PPEditText; VAR new: PPEditText; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AD-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPEditText; PROCEDURE IsPPEditText* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AD-5A91-11CF-8700-00AA0060263B}") END IsPPEditText; PROCEDURE ThisPPIcon* (v: CtlT.Any): PPIcon; VAR new: PPIcon; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AE-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPIcon; PROCEDURE IsPPIcon* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AE-5A91-11CF-8700-00AA0060263B}") END IsPPIcon; PROCEDURE ThisPPBitmap* (v: CtlT.Any): PPBitmap; VAR new: PPBitmap; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934AF-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPBitmap; PROCEDURE IsPPBitmap* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934AF-5A91-11CF-8700-00AA0060263B}") END IsPPBitmap; PROCEDURE ThisPPSpinner* (v: CtlT.Any): PPSpinner; VAR new: PPSpinner; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B0-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPSpinner; PROCEDURE IsPPSpinner* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B0-5A91-11CF-8700-00AA0060263B}") END IsPPSpinner; PROCEDURE ThisPPScrollBar* (v: CtlT.Any): PPScrollBar; VAR new: PPScrollBar; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B1-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPScrollBar; PROCEDURE IsPPScrollBar* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B1-5A91-11CF-8700-00AA0060263B}") END IsPPScrollBar; PROCEDURE ThisPPGroupBox* (v: CtlT.Any): PPGroupBox; VAR new: PPGroupBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B2-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPGroupBox; PROCEDURE IsPPGroupBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B2-5A91-11CF-8700-00AA0060263B}") END IsPPGroupBox; PROCEDURE ThisPPFrame* (v: CtlT.Any): PPFrame; VAR new: PPFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B3-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPFrame; PROCEDURE IsPPFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B3-5A91-11CF-8700-00AA0060263B}") END IsPPFrame; PROCEDURE ThisPPTabControl* (v: CtlT.Any): PPTabControl; VAR new: PPTabControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B4-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPTabControl; PROCEDURE IsPPTabControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B4-5A91-11CF-8700-00AA0060263B}") END IsPPTabControl; PROCEDURE ThisPPDropDown* (v: CtlT.Any): PPDropDown; VAR new: PPDropDown; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B5-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPDropDown; PROCEDURE IsPPDropDown* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B5-5A91-11CF-8700-00AA0060263B}") END IsPPDropDown; PROCEDURE ThisPPDropDownEdit* (v: CtlT.Any): PPDropDownEdit; VAR new: PPDropDownEdit; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B6-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPDropDownEdit; PROCEDURE IsPPDropDownEdit* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B6-5A91-11CF-8700-00AA0060263B}") END IsPPDropDownEdit; PROCEDURE ThisPPSlideMiniature* (v: CtlT.Any): PPSlideMiniature; VAR new: PPSlideMiniature; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B7-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPSlideMiniature; PROCEDURE IsPPSlideMiniature* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B7-5A91-11CF-8700-00AA0060263B}") END IsPPSlideMiniature; PROCEDURE ThisPPRadioButton* (v: CtlT.Any): PPRadioButton; VAR new: PPRadioButton; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B8-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPPRadioButton; PROCEDURE IsPPRadioButton* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B8-5A91-11CF-8700-00AA0060263B}") END IsPPRadioButton; PROCEDURE ThisTags* (v: CtlT.Any): Tags; VAR new: Tags; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934B9-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTags; PROCEDURE IsTags* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934B9-5A91-11CF-8700-00AA0060263B}") END IsTags; PROCEDURE ThisFileDialogFileList* (v: CtlT.Any): FileDialogFileList; VAR new: FileDialogFileList; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934BA-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFileDialogFileList; PROCEDURE IsFileDialogFileList* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934BA-5A91-11CF-8700-00AA0060263B}") END IsFileDialogFileList; PROCEDURE ThisFileDialogExtension* (v: CtlT.Any): FileDialogExtension; VAR new: FileDialogExtension; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934BB-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFileDialogExtension; PROCEDURE IsFileDialogExtension* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934BB-5A91-11CF-8700-00AA0060263B}") END IsFileDialogExtension; PROCEDURE ThisFileDialogExtensionList* (v: CtlT.Any): FileDialogExtensionList; VAR new: FileDialogExtensionList; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934BC-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFileDialogExtensionList; PROCEDURE IsFileDialogExtensionList* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934BC-5A91-11CF-8700-00AA0060263B}") END IsFileDialogExtensionList; PROCEDURE ThisFileDialog* (v: CtlT.Any): FileDialog; VAR new: FileDialog; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934BD-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisFileDialog; PROCEDURE IsFileDialog* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934BD-5A91-11CF-8700-00AA0060263B}") END IsFileDialog; PROCEDURE ThisOCXExtender* (v: CtlT.Any): OCXExtender; VAR new: OCXExtender; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C0-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisOCXExtender; PROCEDURE IsOCXExtender* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C0-5A91-11CF-8700-00AA0060263B}") END IsOCXExtender; PROCEDURE ThisTable* (v: CtlT.Any): Table; VAR new: Table; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C3-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisTable; PROCEDURE IsTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C3-5A91-11CF-8700-00AA0060263B}") END IsTable; PROCEDURE ThisColumns* (v: CtlT.Any): Columns; VAR new: Columns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C4-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisColumns; PROCEDURE IsColumns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C4-5A91-11CF-8700-00AA0060263B}") END IsColumns; PROCEDURE ThisColumn* (v: CtlT.Any): Column; VAR new: Column; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C5-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisColumn; PROCEDURE IsColumn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C5-5A91-11CF-8700-00AA0060263B}") END IsColumn; PROCEDURE ThisRows* (v: CtlT.Any): Rows; VAR new: Rows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C6-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRows; PROCEDURE IsRows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C6-5A91-11CF-8700-00AA0060263B}") END IsRows; PROCEDURE ThisRow* (v: CtlT.Any): Row; VAR new: Row; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C7-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisRow; PROCEDURE IsRow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C7-5A91-11CF-8700-00AA0060263B}") END IsRow; PROCEDURE ThisCellRange* (v: CtlT.Any): CellRange; VAR new: CellRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C8-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisCellRange; PROCEDURE IsCellRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C8-5A91-11CF-8700-00AA0060263B}") END IsCellRange; PROCEDURE ThisCell* (v: CtlT.Any): Cell; VAR new: Cell; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934C9-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisCell; PROCEDURE IsCell* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934C9-5A91-11CF-8700-00AA0060263B}") END IsCell; PROCEDURE ThisBorders* (v: CtlT.Any): Borders; VAR new: Borders; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CA-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisBorders; PROCEDURE IsBorders* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CA-5A91-11CF-8700-00AA0060263B}") END IsBorders; PROCEDURE ThisPanes* (v: CtlT.Any): Panes; VAR new: Panes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CB-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPanes; PROCEDURE IsPanes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CB-5A91-11CF-8700-00AA0060263B}") END IsPanes; PROCEDURE ThisPane* (v: CtlT.Any): Pane; VAR new: Pane; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CC-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPane; PROCEDURE IsPane* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CC-5A91-11CF-8700-00AA0060263B}") END IsPane; PROCEDURE ThisDefaultWebOptions* (v: CtlT.Any): DefaultWebOptions; VAR new: DefaultWebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CD-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisDefaultWebOptions; PROCEDURE IsDefaultWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CD-5A91-11CF-8700-00AA0060263B}") END IsDefaultWebOptions; PROCEDURE ThisWebOptions* (v: CtlT.Any): WebOptions; VAR new: WebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CE-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisWebOptions; PROCEDURE IsWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CE-5A91-11CF-8700-00AA0060263B}") END IsWebOptions; PROCEDURE ThisPublishObjects* (v: CtlT.Any): PublishObjects; VAR new: PublishObjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934CF-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPublishObjects; PROCEDURE IsPublishObjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934CF-5A91-11CF-8700-00AA0060263B}") END IsPublishObjects; PROCEDURE ThisPublishObject* (v: CtlT.Any): PublishObject; VAR new: PublishObject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934D0-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisPublishObject; PROCEDURE IsPublishObject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934D0-5A91-11CF-8700-00AA0060263B}") END IsPublishObject; PROCEDURE ThisMarker* (v: CtlT.Any): Marker; VAR new: Marker; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{914934D1-5A91-11CF-8700-00AA0060263B}"); RETURN new ELSE RETURN NIL END END ThisMarker; PROCEDURE IsMarker* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{914934D1-5A91-11CF-8700-00AA0060263B}") END IsMarker; (* ---------- Collection, hidden, dual ---------- *) PROCEDURE (this: Collection) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Collection) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; (* ---------- _Application, dual, nonextensible ---------- *) PROCEDURE (this: _Application) Presentations* (): Presentations, NEW; BEGIN RETURN ThisPresentations(CtlC.GetAny(this, 2001)) END Presentations; PROCEDURE (this: _Application) Windows* (): DocumentWindows, NEW; BEGIN RETURN ThisDocumentWindows(CtlC.GetAny(this, 2002)) END Windows; PROCEDURE (this: _Application) Dialogs* (): PPDialogs, NEW; BEGIN RETURN ThisPPDialogs(CtlC.GetAny(this, 2003)) END Dialogs; PROCEDURE (this: _Application) ActiveWindow* (): DocumentWindow, NEW; BEGIN RETURN ThisDocumentWindow(CtlC.GetAny(this, 2004)) END ActiveWindow; PROCEDURE (this: _Application) ActivePresentation* (): Presentation, NEW; BEGIN RETURN This_Presentation(CtlC.GetAny(this, 2005)) END ActivePresentation; PROCEDURE (this: _Application) SlideShowWindows* (): SlideShowWindows, NEW; BEGIN RETURN ThisSlideShowWindows(CtlC.GetAny(this, 2006)) END SlideShowWindows; PROCEDURE (this: _Application) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 2007)) END CommandBars; PROCEDURE (this: _Application) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END Path; PROCEDURE (this: _Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _Application) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2009) END Caption; PROCEDURE (this: _Application) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2009, p1) END PUTCaption; PROCEDURE (this: _Application) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 2010)) END Assistant; PROCEDURE (this: _Application) FileSearch* (): CtlOffice.FileSearch, NEW; BEGIN RETURN CtlOffice.ThisFileSearch(CtlC.GetAny(this, 2011)) END FileSearch; PROCEDURE (this: _Application) FileFind* (): CtlOffice.IFind, NEW; BEGIN RETURN CtlOffice.ThisIFind(CtlC.GetAny(this, 2012)) END FileFind; PROCEDURE (this: _Application) Build* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2013) END Build; PROCEDURE (this: _Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2014) END Version; PROCEDURE (this: _Application) OperatingSystem* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2015) END OperatingSystem; PROCEDURE (this: _Application) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2016) END ActivePrinter; PROCEDURE (this: _Application) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2017) END Creator; PROCEDURE (this: _Application) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 2018)) END AddIns; PROCEDURE (this: _Application) VBE* (): CtlVBIDE.VBE, NEW; BEGIN RETURN CtlVBIDE.ThisVBE(CtlC.GetAny(this, 2019)) END VBE; PROCEDURE (this: _Application) Help* (HelpFile: ARRAY OF CHAR; ContextID: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(HelpFile, arg[1]); CtlC.IntVar(ContextID, arg[0]); CtlC.CallParMethod(this, 2020, arg, NIL); END Help; PROCEDURE (this: _Application) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 2021, NIL); END Quit; PROCEDURE (this: _Application) Run* (MacroName: ARRAY OF CHAR; (* optional *) safeArrayOfParams: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(MacroName, arg[1]); CtlC.AnyVar(safeArrayOfParams, arg[0]); CtlC.CallParMethod(this, 2022, arg, ret); RETURN CtlC.VarAny(ret) END Run; PROCEDURE (this: _Application) FileDialog* (Type: PpFileDialogType): FileDialog, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 2023, arg, ret); RETURN ThisFileDialog(CtlC.VarAny(ret)) END FileDialog; PROCEDURE (this: _Application) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2025) END Left; PROCEDURE (this: _Application) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2025, p1) END PUTLeft; PROCEDURE (this: _Application) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2026) END Top; PROCEDURE (this: _Application) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2026, p1) END PUTTop; PROCEDURE (this: _Application) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2027) END Width; PROCEDURE (this: _Application) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2027, p1) END PUTWidth; PROCEDURE (this: _Application) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2028) END Height; PROCEDURE (this: _Application) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2028, p1) END PUTHeight; PROCEDURE (this: _Application) WindowState* (): PpWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 2029) END WindowState; PROCEDURE (this: _Application) PUTWindowState* (p1: PpWindowState), NEW; BEGIN CtlC.PutInt(this, 2029, p1) END PUTWindowState; PROCEDURE (this: _Application) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2030) END Visible; PROCEDURE (this: _Application) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2030, p1) END PUTVisible; PROCEDURE (this: _Application) Active* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2032) END Active; PROCEDURE (this: _Application) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 2033, NIL); END Activate; PROCEDURE (this: _Application) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 2034)) END AnswerWizard; PROCEDURE (this: _Application) COMAddIns* (): CtlOffice.COMAddIns, NEW; BEGIN RETURN CtlOffice.ThisCOMAddIns(CtlC.GetAny(this, 2035)) END COMAddIns; PROCEDURE (this: _Application) ProductCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2036) END ProductCode; PROCEDURE (this: _Application) DefaultWebOptions* (): DefaultWebOptions, NEW; BEGIN RETURN ThisDefaultWebOptions(CtlC.GetAny(this, 2037)) END DefaultWebOptions; PROCEDURE (this: _Application) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 2038)) END LanguageSettings; PROCEDURE (this: _Application) MsoDebugOptions* (): CtlOffice.MsoDebugOptions, NEW; BEGIN RETURN CtlOffice.ThisMsoDebugOptions(CtlC.GetAny(this, 2039)) END MsoDebugOptions; PROCEDURE (this: _Application) ShowWindowsInTaskbar* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2040) END ShowWindowsInTaskbar; PROCEDURE (this: _Application) PUTShowWindowsInTaskbar* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2040, p1) END PUTShowWindowsInTaskbar; PROCEDURE (this: _Application) Marker* (): Marker, NEW; BEGIN RETURN ThisMarker(CtlC.GetAny(this, 2041)) END Marker; PROCEDURE (this: _Application) FeatureInstall* (): CtlOffice.MsoFeatureInstall, NEW; BEGIN RETURN CtlC.GetInt(this, 2042) END FeatureInstall; PROCEDURE (this: _Application) PUTFeatureInstall* (p1: CtlOffice.MsoFeatureInstall), NEW; BEGIN CtlC.PutInt(this, 2042, p1) END PUTFeatureInstall; PROCEDURE (this: _Application) GetOptionFlag* (Option: INTEGER; Persist: BOOLEAN): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Option, arg[1]); CtlC.BoolVar(Persist, arg[0]); CtlC.CallParMethod(this, 2043, arg, ret); RETURN CtlC.VarBool(ret) END GetOptionFlag; PROCEDURE (this: _Application) SetOptionFlag* (Option: INTEGER; State: BOOLEAN; Persist: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Option, arg[2]); CtlC.BoolVar(State, arg[1]); CtlC.BoolVar(Persist, arg[0]); CtlC.CallParMethod(this, 2044, arg, NIL); END SetOptionFlag; (* ---------- _Global, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Global) ActivePresentation* (): Presentation, NEW; BEGIN RETURN This_Presentation(CtlC.GetAny(this, 2001)) END ActivePresentation; PROCEDURE (this: _Global) ActiveWindow* (): DocumentWindow, NEW; BEGIN RETURN ThisDocumentWindow(CtlC.GetAny(this, 2002)) END ActiveWindow; PROCEDURE (this: _Global) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 2003)) END AddIns; PROCEDURE (this: _Global) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2004)) END Application; PROCEDURE (this: _Global) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 2005)) END Assistant; PROCEDURE (this: _Global) Dialogs* (): PPDialogs, NEW; BEGIN RETURN ThisPPDialogs(CtlC.GetAny(this, 2006)) END Dialogs; PROCEDURE (this: _Global) Presentations* (): Presentations, NEW; BEGIN RETURN ThisPresentations(CtlC.GetAny(this, 2007)) END Presentations; PROCEDURE (this: _Global) SlideShowWindows* (): SlideShowWindows, NEW; BEGIN RETURN ThisSlideShowWindows(CtlC.GetAny(this, 2008)) END SlideShowWindows; PROCEDURE (this: _Global) Windows* (): DocumentWindows, NEW; BEGIN RETURN ThisDocumentWindows(CtlC.GetAny(this, 2009)) END Windows; PROCEDURE (this: _Global) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 2010)) END CommandBars; PROCEDURE (this: _Global) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 2011)) END AnswerWizard; (* ---------- ColorFormat, dual, nonextensible ---------- *) PROCEDURE (this: ColorFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ColorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ColorFormat) RGB* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END RGB; PROCEDURE (this: ColorFormat) PUTRGB* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTRGB; PROCEDURE (this: ColorFormat) Type* (): CtlOffice.MsoColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Type; PROCEDURE (this: ColorFormat) SchemeColor* (): PpColorSchemeIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END SchemeColor; PROCEDURE (this: ColorFormat) PUTSchemeColor* (p1: PpColorSchemeIndex), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTSchemeColor; (* ---------- SlideShowWindow, dual, nonextensible ---------- *) PROCEDURE (this: SlideShowWindow) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideShowWindow) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideShowWindow) View* (): SlideShowView, NEW; BEGIN RETURN ThisSlideShowView(CtlC.GetAny(this, 2003)) END View; PROCEDURE (this: SlideShowWindow) Presentation* (): Presentation, NEW; BEGIN RETURN This_Presentation(CtlC.GetAny(this, 2004)) END Presentation; PROCEDURE (this: SlideShowWindow) IsFullScreen* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END IsFullScreen; PROCEDURE (this: SlideShowWindow) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2006) END Left; PROCEDURE (this: SlideShowWindow) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2006, p1) END PUTLeft; PROCEDURE (this: SlideShowWindow) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2007) END Top; PROCEDURE (this: SlideShowWindow) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2007, p1) END PUTTop; PROCEDURE (this: SlideShowWindow) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2008) END Width; PROCEDURE (this: SlideShowWindow) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2008, p1) END PUTWidth; PROCEDURE (this: SlideShowWindow) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END Height; PROCEDURE (this: SlideShowWindow) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2009, p1) END PUTHeight; PROCEDURE (this: SlideShowWindow) Active* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END Active; PROCEDURE (this: SlideShowWindow) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 2012, NIL); END Activate; (* ---------- Selection, dual, nonextensible ---------- *) PROCEDURE (this: Selection) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Selection) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Selection) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2003, NIL); END Cut; PROCEDURE (this: Selection) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2004, NIL); END Copy; PROCEDURE (this: Selection) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Delete; PROCEDURE (this: Selection) Unselect* (), NEW; BEGIN CtlC.CallMethod(this, 2006, NIL); END Unselect; PROCEDURE (this: Selection) Type* (): PpSelectionType, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END Type; PROCEDURE (this: Selection) SlideRange* (): SlideRange, NEW; BEGIN RETURN ThisSlideRange(CtlC.GetAny(this, 2008)) END SlideRange; PROCEDURE (this: Selection) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 2009)) END ShapeRange; PROCEDURE (this: Selection) TextRange* (): TextRange, NEW; BEGIN RETURN ThisTextRange(CtlC.GetAny(this, 2010)) END TextRange; (* ---------- DocumentWindows, dual, nonextensible ---------- *) PROCEDURE (this: DocumentWindows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: DocumentWindows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: DocumentWindows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: DocumentWindows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: DocumentWindows) Item* (index: INTEGER): DocumentWindow, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisDocumentWindow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: DocumentWindows) Arrange* (arrangeStyle: PpArrangeStyle), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(arrangeStyle, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Arrange; (* ---------- SlideShowWindows, dual, nonextensible ---------- *) PROCEDURE (this: SlideShowWindows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: SlideShowWindows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: SlideShowWindows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideShowWindows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideShowWindows) Item* (index: INTEGER): SlideShowWindow, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisSlideShowWindow(CtlC.VarAny(ret)) END Item; (* ---------- DocumentWindow, dual, nonextensible ---------- *) PROCEDURE (this: DocumentWindow) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: DocumentWindow) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: DocumentWindow) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 2003)) END Selection; PROCEDURE (this: DocumentWindow) View* (): View, NEW; BEGIN RETURN ThisView(CtlC.GetAny(this, 2004)) END View; PROCEDURE (this: DocumentWindow) Presentation* (): Presentation, NEW; BEGIN RETURN This_Presentation(CtlC.GetAny(this, 2005)) END Presentation; PROCEDURE (this: DocumentWindow) ViewType* (): PpViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END ViewType; PROCEDURE (this: DocumentWindow) PUTViewType* (p1: PpViewType), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTViewType; PROCEDURE (this: DocumentWindow) BlackAndWhite* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END BlackAndWhite; PROCEDURE (this: DocumentWindow) PUTBlackAndWhite* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTBlackAndWhite; PROCEDURE (this: DocumentWindow) Active* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END Active; PROCEDURE (this: DocumentWindow) WindowState* (): PpWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END WindowState; PROCEDURE (this: DocumentWindow) PUTWindowState* (p1: PpWindowState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTWindowState; PROCEDURE (this: DocumentWindow) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Caption; PROCEDURE (this: DocumentWindow) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2010) END Left; PROCEDURE (this: DocumentWindow) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2010, p1) END PUTLeft; PROCEDURE (this: DocumentWindow) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2011) END Top; PROCEDURE (this: DocumentWindow) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2011, p1) END PUTTop; PROCEDURE (this: DocumentWindow) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2012) END Width; PROCEDURE (this: DocumentWindow) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2012, p1) END PUTWidth; PROCEDURE (this: DocumentWindow) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2013) END Height; PROCEDURE (this: DocumentWindow) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2013, p1) END PUTHeight; PROCEDURE (this: DocumentWindow) FitToPage* (), NEW; BEGIN CtlC.CallMethod(this, 2014, NIL); END FitToPage; PROCEDURE (this: DocumentWindow) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 2015, NIL); END Activate; PROCEDURE (this: DocumentWindow) LargeScroll* (Down: INTEGER; Up: INTEGER; ToRight: INTEGER; ToLeft: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Down, arg[3]); CtlC.IntVar(Up, arg[2]); CtlC.IntVar(ToRight, arg[1]); CtlC.IntVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 2016, arg, NIL); END LargeScroll; PROCEDURE (this: DocumentWindow) SmallScroll* (Down: INTEGER; Up: INTEGER; ToRight: INTEGER; ToLeft: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Down, arg[3]); CtlC.IntVar(Up, arg[2]); CtlC.IntVar(ToRight, arg[1]); CtlC.IntVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 2017, arg, NIL); END SmallScroll; PROCEDURE (this: DocumentWindow) NewWindow* (): DocumentWindow, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2018, ret); RETURN ThisDocumentWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: DocumentWindow) Close* (), NEW; BEGIN CtlC.CallMethod(this, 2019, NIL); END Close; PROCEDURE (this: DocumentWindow) ActivePane* (): Pane, NEW; BEGIN RETURN ThisPane(CtlC.GetAny(this, 2021)) END ActivePane; PROCEDURE (this: DocumentWindow) Panes* (): Panes, NEW; BEGIN RETURN ThisPanes(CtlC.GetAny(this, 2022)) END Panes; PROCEDURE (this: DocumentWindow) SplitVertical* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2023) END SplitVertical; PROCEDURE (this: DocumentWindow) PUTSplitVertical* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2023, p1) END PUTSplitVertical; PROCEDURE (this: DocumentWindow) SplitHorizontal* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2024) END SplitHorizontal; PROCEDURE (this: DocumentWindow) PUTSplitHorizontal* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2024, p1) END PUTSplitHorizontal; PROCEDURE (this: DocumentWindow) RangeFromPoint* (X: INTEGER; Y: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(X, arg[1]); CtlC.IntVar(Y, arg[0]); CtlC.CallParMethod(this, 2025, arg, ret); RETURN CtlC.VarObj(ret) END RangeFromPoint; PROCEDURE (this: DocumentWindow) PointsToScreenPixelsX* (Points: SHORTREAL): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 2026, arg, ret); RETURN CtlC.VarInt(ret) END PointsToScreenPixelsX; PROCEDURE (this: DocumentWindow) PointsToScreenPixelsY* (Points: SHORTREAL): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 2027, arg, ret); RETURN CtlC.VarInt(ret) END PointsToScreenPixelsY; PROCEDURE (this: DocumentWindow) ScrollIntoView* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; Start: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.IntVar(Start, arg[0]); CtlC.CallParMethod(this, 2028, arg, NIL); END ScrollIntoView; (* ---------- View, dual, nonextensible ---------- *) PROCEDURE (this: View) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: View) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: View) Type* (): PpViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Type; PROCEDURE (this: View) Zoom* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END Zoom; PROCEDURE (this: View) PUTZoom* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTZoom; PROCEDURE (this: View) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Paste; PROCEDURE (this: View) Slide* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2006) END Slide; PROCEDURE (this: View) PUTSlide* (p1: CtlT.Object), NEW; BEGIN CtlC.PutObj(this, 2006, p1) END PUTSlide; PROCEDURE (this: View) GotoSlide* (index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2007, arg, NIL); END GotoSlide; PROCEDURE (this: View) DisplaySlideMiniature* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END DisplaySlideMiniature; PROCEDURE (this: View) PUTDisplaySlideMiniature* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTDisplaySlideMiniature; PROCEDURE (this: View) ZoomToFit* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END ZoomToFit; PROCEDURE (this: View) PUTZoomToFit* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTZoomToFit; (* ---------- SlideShowView, dual, nonextensible ---------- *) PROCEDURE (this: SlideShowView) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideShowView) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideShowView) Zoom* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Zoom; PROCEDURE (this: SlideShowView) Slide* (): Slide, NEW; BEGIN RETURN This_Slide(CtlC.GetAny(this, 2004)) END Slide; PROCEDURE (this: SlideShowView) PointerType* (): PpSlideShowPointerType, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END PointerType; PROCEDURE (this: SlideShowView) PUTPointerType* (p1: PpSlideShowPointerType), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTPointerType; PROCEDURE (this: SlideShowView) State* (): PpSlideShowState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END State; PROCEDURE (this: SlideShowView) PUTState* (p1: PpSlideShowState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTState; PROCEDURE (this: SlideShowView) AcceleratorsEnabled* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END AcceleratorsEnabled; PROCEDURE (this: SlideShowView) PUTAcceleratorsEnabled* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTAcceleratorsEnabled; PROCEDURE (this: SlideShowView) PresentationElapsedTime* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2008) END PresentationElapsedTime; PROCEDURE (this: SlideShowView) SlideElapsedTime* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END SlideElapsedTime; PROCEDURE (this: SlideShowView) PUTSlideElapsedTime* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2009, p1) END PUTSlideElapsedTime; PROCEDURE (this: SlideShowView) LastSlideViewed* (): Slide, NEW; BEGIN RETURN This_Slide(CtlC.GetAny(this, 2010)) END LastSlideViewed; PROCEDURE (this: SlideShowView) AdvanceMode* (): PpSlideShowAdvanceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END AdvanceMode; PROCEDURE (this: SlideShowView) PointerColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 2012)) END PointerColor; PROCEDURE (this: SlideShowView) IsNamedShow* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END IsNamedShow; PROCEDURE (this: SlideShowView) SlideShowName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2014) END SlideShowName; PROCEDURE (this: SlideShowView) DrawLine* (BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 2015, arg, NIL); END DrawLine; PROCEDURE (this: SlideShowView) EraseDrawing* (), NEW; BEGIN CtlC.CallMethod(this, 2016, NIL); END EraseDrawing; PROCEDURE (this: SlideShowView) First* (), NEW; BEGIN CtlC.CallMethod(this, 2017, NIL); END First; PROCEDURE (this: SlideShowView) Last* (), NEW; BEGIN CtlC.CallMethod(this, 2018, NIL); END Last; PROCEDURE (this: SlideShowView) Next* (), NEW; BEGIN CtlC.CallMethod(this, 2019, NIL); END Next; PROCEDURE (this: SlideShowView) Previous* (), NEW; BEGIN CtlC.CallMethod(this, 2020, NIL); END Previous; PROCEDURE (this: SlideShowView) GotoSlide* (index: INTEGER; ResetSlide: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.IntVar(ResetSlide, arg[0]); CtlC.CallParMethod(this, 2021, arg, NIL); END GotoSlide; PROCEDURE (this: SlideShowView) GotoNamedShow* (SlideShowName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(SlideShowName, arg[0]); CtlC.CallParMethod(this, 2022, arg, NIL); END GotoNamedShow; PROCEDURE (this: SlideShowView) EndNamedShow* (), NEW; BEGIN CtlC.CallMethod(this, 2023, NIL); END EndNamedShow; PROCEDURE (this: SlideShowView) ResetSlideTime* (), NEW; BEGIN CtlC.CallMethod(this, 2024, NIL); END ResetSlideTime; PROCEDURE (this: SlideShowView) Exit* (), NEW; BEGIN CtlC.CallMethod(this, 2025, NIL); END Exit; PROCEDURE (this: SlideShowView) InstallTracker* (pTracker: CtlT.IUnknown; Presenter: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntfceVar(pTracker, arg[1]); CtlC.IntVar(Presenter, arg[0]); CtlC.CallParMethod(this, 2026, arg, NIL); END InstallTracker; PROCEDURE (this: SlideShowView) CurrentShowPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2027) END CurrentShowPosition; (* ---------- SlideShowSettings, dual, nonextensible ---------- *) PROCEDURE (this: SlideShowSettings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideShowSettings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideShowSettings) PointerColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 2003)) END PointerColor; PROCEDURE (this: SlideShowSettings) NamedSlideShows* (): NamedSlideShows, NEW; BEGIN RETURN ThisNamedSlideShows(CtlC.GetAny(this, 2004)) END NamedSlideShows; PROCEDURE (this: SlideShowSettings) StartingSlide* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END StartingSlide; PROCEDURE (this: SlideShowSettings) PUTStartingSlide* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTStartingSlide; PROCEDURE (this: SlideShowSettings) EndingSlide* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END EndingSlide; PROCEDURE (this: SlideShowSettings) PUTEndingSlide* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTEndingSlide; PROCEDURE (this: SlideShowSettings) AdvanceMode* (): PpSlideShowAdvanceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END AdvanceMode; PROCEDURE (this: SlideShowSettings) PUTAdvanceMode* (p1: PpSlideShowAdvanceMode), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTAdvanceMode; PROCEDURE (this: SlideShowSettings) Run* (): SlideShowWindow, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2008, ret); RETURN ThisSlideShowWindow(CtlC.VarAny(ret)) END Run; PROCEDURE (this: SlideShowSettings) LoopUntilStopped* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END LoopUntilStopped; PROCEDURE (this: SlideShowSettings) PUTLoopUntilStopped* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTLoopUntilStopped; PROCEDURE (this: SlideShowSettings) ShowType* (): PpSlideShowType, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END ShowType; PROCEDURE (this: SlideShowSettings) PUTShowType* (p1: PpSlideShowType), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTShowType; PROCEDURE (this: SlideShowSettings) ShowWithNarration* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END ShowWithNarration; PROCEDURE (this: SlideShowSettings) PUTShowWithNarration* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTShowWithNarration; PROCEDURE (this: SlideShowSettings) ShowWithAnimation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END ShowWithAnimation; PROCEDURE (this: SlideShowSettings) PUTShowWithAnimation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2012, p1) END PUTShowWithAnimation; PROCEDURE (this: SlideShowSettings) SlideShowName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2013) END SlideShowName; PROCEDURE (this: SlideShowSettings) PUTSlideShowName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2013, p1) END PUTSlideShowName; PROCEDURE (this: SlideShowSettings) RangeType* (): PpSlideShowRangeType, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END RangeType; PROCEDURE (this: SlideShowSettings) PUTRangeType* (p1: PpSlideShowRangeType), NEW; BEGIN CtlC.PutInt(this, 2014, p1) END PUTRangeType; (* ---------- NamedSlideShows, dual, nonextensible ---------- *) PROCEDURE (this: NamedSlideShows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: NamedSlideShows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: NamedSlideShows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: NamedSlideShows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: NamedSlideShows) Item* (index: CtlT.Any): NamedSlideShow, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisNamedSlideShow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: NamedSlideShows) Add* (Name: ARRAY OF CHAR; safeArrayOfSlideIDs: CtlT.Any): NamedSlideShow, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(safeArrayOfSlideIDs, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisNamedSlideShow(CtlC.VarAny(ret)) END Add; (* ---------- NamedSlideShow, dual, nonextensible ---------- *) PROCEDURE (this: NamedSlideShow) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: NamedSlideShow) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: NamedSlideShow) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END Name; PROCEDURE (this: NamedSlideShow) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2004, NIL); END Delete; PROCEDURE (this: NamedSlideShow) SlideIDs* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 2005) END SlideIDs; PROCEDURE (this: NamedSlideShow) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END Count; (* ---------- PrintOptions, dual, nonextensible ---------- *) PROCEDURE (this: PrintOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PrintOptions) PrintColorType* (): PpPrintColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END PrintColorType; PROCEDURE (this: PrintOptions) PUTPrintColorType* (p1: PpPrintColorType), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTPrintColorType; PROCEDURE (this: PrintOptions) Collate* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Collate; PROCEDURE (this: PrintOptions) PUTCollate* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTCollate; PROCEDURE (this: PrintOptions) FitToPage* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END FitToPage; PROCEDURE (this: PrintOptions) PUTFitToPage* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTFitToPage; PROCEDURE (this: PrintOptions) FrameSlides* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END FrameSlides; PROCEDURE (this: PrintOptions) PUTFrameSlides* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTFrameSlides; PROCEDURE (this: PrintOptions) NumberOfCopies* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END NumberOfCopies; PROCEDURE (this: PrintOptions) PUTNumberOfCopies* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTNumberOfCopies; PROCEDURE (this: PrintOptions) OutputType* (): PpPrintOutputType, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END OutputType; PROCEDURE (this: PrintOptions) PUTOutputType* (p1: PpPrintOutputType), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTOutputType; PROCEDURE (this: PrintOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2008) END Parent; PROCEDURE (this: PrintOptions) PrintHiddenSlides* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END PrintHiddenSlides; PROCEDURE (this: PrintOptions) PUTPrintHiddenSlides* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTPrintHiddenSlides; PROCEDURE (this: PrintOptions) PrintInBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END PrintInBackground; PROCEDURE (this: PrintOptions) PUTPrintInBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTPrintInBackground; PROCEDURE (this: PrintOptions) RangeType* (): PpPrintRangeType, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END RangeType; PROCEDURE (this: PrintOptions) PUTRangeType* (p1: PpPrintRangeType), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTRangeType; PROCEDURE (this: PrintOptions) Ranges* (): PrintRanges, NEW; BEGIN RETURN ThisPrintRanges(CtlC.GetAny(this, 2012)) END Ranges; PROCEDURE (this: PrintOptions) PrintFontsAsGraphics* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END PrintFontsAsGraphics; PROCEDURE (this: PrintOptions) PUTPrintFontsAsGraphics* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2013, p1) END PUTPrintFontsAsGraphics; PROCEDURE (this: PrintOptions) SlideShowName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2014) END SlideShowName; PROCEDURE (this: PrintOptions) PUTSlideShowName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2014, p1) END PUTSlideShowName; PROCEDURE (this: PrintOptions) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2015) END ActivePrinter; PROCEDURE (this: PrintOptions) PUTActivePrinter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2015, p1) END PUTActivePrinter; PROCEDURE (this: PrintOptions) HandoutOrder* (): PpPrintHandoutOrder, NEW; BEGIN RETURN CtlC.GetInt(this, 2016) END HandoutOrder; PROCEDURE (this: PrintOptions) PUTHandoutOrder* (p1: PpPrintHandoutOrder), NEW; BEGIN CtlC.PutInt(this, 2016, p1) END PUTHandoutOrder; (* ---------- PrintRanges, dual, nonextensible ---------- *) PROCEDURE (this: PrintRanges) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PrintRanges) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PrintRanges) Add* (Start: INTEGER; End: INTEGER): PrintRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(End, arg[0]); CtlC.CallParMethod(this, 2001, arg, ret); RETURN ThisPrintRange(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PrintRanges) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2002)) END Application; PROCEDURE (this: PrintRanges) ClearAll* (), NEW; BEGIN CtlC.CallMethod(this, 2003, NIL); END ClearAll; PROCEDURE (this: PrintRanges) Item* (index: INTEGER): PrintRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPrintRange(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PrintRanges) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2004) END Parent; (* ---------- PrintRange, dual, nonextensible ---------- *) PROCEDURE (this: PrintRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PrintRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PrintRange) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Start; PROCEDURE (this: PrintRange) End* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END End; PROCEDURE (this: PrintRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Delete; (* ---------- AddIns, dual, nonextensible ---------- *) PROCEDURE (this: AddIns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AddIns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: AddIns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: AddIns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: AddIns) Item* (index: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AddIns) Add* (FileName: ARRAY OF CHAR): AddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AddIns) Remove* (index: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 2004, arg, NIL); END Remove; (* ---------- AddIn, dual, nonextensible ---------- *) PROCEDURE (this: AddIn) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: AddIn) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: AddIn) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END FullName; PROCEDURE (this: AddIn) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END Name; PROCEDURE (this: AddIn) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END Path; PROCEDURE (this: AddIn) Registered* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END Registered; PROCEDURE (this: AddIn) PUTRegistered* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTRegistered; PROCEDURE (this: AddIn) AutoLoad* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END AutoLoad; PROCEDURE (this: AddIn) PUTAutoLoad* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTAutoLoad; PROCEDURE (this: AddIn) Loaded* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END Loaded; PROCEDURE (this: AddIn) PUTLoaded* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTLoaded; PROCEDURE (this: AddIn) DisplayAlerts* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END DisplayAlerts; PROCEDURE (this: AddIn) PUTDisplayAlerts* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTDisplayAlerts; PROCEDURE (this: AddIn) RegisteredInHKLM* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END RegisteredInHKLM; (* ---------- Presentations, dual, nonextensible ---------- *) PROCEDURE (this: Presentations) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Presentations) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Presentations) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Presentations) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Presentations) Item* (index: CtlT.Any): Presentation, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Presentation(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Presentations) Add* (WithWindow: CtlOffice.MsoTriState): Presentation, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(WithWindow, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN This_Presentation(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Presentations) Open* (FileName: ARRAY OF CHAR; ReadOnly: CtlOffice.MsoTriState; Untitled: CtlOffice.MsoTriState; WithWindow: CtlOffice.MsoTriState): Presentation, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.IntVar(ReadOnly, arg[2]); CtlC.IntVar(Untitled, arg[1]); CtlC.IntVar(WithWindow, arg[0]); CtlC.CallParMethod(this, 2004, arg, ret); RETURN This_Presentation(CtlC.VarAny(ret)) END Open; (* ---------- Hyperlinks, dual, nonextensible ---------- *) PROCEDURE (this: Hyperlinks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Hyperlinks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Hyperlinks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Hyperlinks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Hyperlinks) Item* (index: INTEGER): Hyperlink, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END Item; (* ---------- Hyperlink, dual, nonextensible ---------- *) PROCEDURE (this: Hyperlink) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Hyperlink) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Hyperlink) Type* (): CtlOffice.MsoHyperlinkType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Type; PROCEDURE (this: Hyperlink) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END Address; PROCEDURE (this: Hyperlink) PUTAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTAddress; PROCEDURE (this: Hyperlink) SubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END SubAddress; PROCEDURE (this: Hyperlink) PUTSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2005, p1) END PUTSubAddress; PROCEDURE (this: Hyperlink) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 2006, NIL); END AddToFavorites; PROCEDURE (this: Hyperlink) EmailSubject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END EmailSubject; PROCEDURE (this: Hyperlink) PUTEmailSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTEmailSubject; PROCEDURE (this: Hyperlink) ScreenTip* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END ScreenTip; PROCEDURE (this: Hyperlink) PUTScreenTip* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2008, p1) END PUTScreenTip; PROCEDURE (this: Hyperlink) TextToDisplay* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2009) END TextToDisplay; PROCEDURE (this: Hyperlink) PUTTextToDisplay* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2009, p1) END PUTTextToDisplay; PROCEDURE (this: Hyperlink) ShowandReturn* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END ShowandReturn; PROCEDURE (this: Hyperlink) PUTShowandReturn* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTShowandReturn; PROCEDURE (this: Hyperlink) Follow* (), NEW; BEGIN CtlC.CallMethod(this, 2011, NIL); END Follow; PROCEDURE (this: Hyperlink) CreateNewDocument* (FileName: ARRAY OF CHAR; EditNow: CtlOffice.MsoTriState; Overwrite: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.IntVar(EditNow, arg[1]); CtlC.IntVar(Overwrite, arg[0]); CtlC.CallParMethod(this, 2012, arg, NIL); END CreateNewDocument; PROCEDURE (this: Hyperlink) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2013, NIL); END Delete; (* ---------- PageSetup, dual, nonextensible ---------- *) PROCEDURE (this: PageSetup) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PageSetup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PageSetup) FirstSlideNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END FirstSlideNumber; PROCEDURE (this: PageSetup) PUTFirstSlideNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTFirstSlideNumber; PROCEDURE (this: PageSetup) SlideHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2004) END SlideHeight; PROCEDURE (this: PageSetup) PUTSlideHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2004, p1) END PUTSlideHeight; PROCEDURE (this: PageSetup) SlideWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2005) END SlideWidth; PROCEDURE (this: PageSetup) PUTSlideWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2005, p1) END PUTSlideWidth; PROCEDURE (this: PageSetup) SlideSize* (): PpSlideSizeType, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END SlideSize; PROCEDURE (this: PageSetup) PUTSlideSize* (p1: PpSlideSizeType), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTSlideSize; PROCEDURE (this: PageSetup) NotesOrientation* (): CtlOffice.MsoOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END NotesOrientation; PROCEDURE (this: PageSetup) PUTNotesOrientation* (p1: CtlOffice.MsoOrientation), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTNotesOrientation; PROCEDURE (this: PageSetup) SlideOrientation* (): CtlOffice.MsoOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END SlideOrientation; PROCEDURE (this: PageSetup) PUTSlideOrientation* (p1: CtlOffice.MsoOrientation), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTSlideOrientation; (* ---------- Fonts, dual, nonextensible ---------- *) PROCEDURE (this: Fonts) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Fonts) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Fonts) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Fonts) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Fonts) Item* (index: CtlT.Any): Font, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFont(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Fonts) Replace* (Original: ARRAY OF CHAR; Replacement: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Original, arg[1]); CtlC.StrVar(Replacement, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Replace; (* ---------- ExtraColors, dual, nonextensible ---------- *) PROCEDURE (this: ExtraColors) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ExtraColors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: ExtraColors) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ExtraColors) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ExtraColors) Item* (index: INTEGER): CtlOffice.MsoRGBType, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarInt(ret) END Item; PROCEDURE (this: ExtraColors) Add* (Type: CtlOffice.MsoRGBType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Add; (* ---------- Slides, dual, nonextensible ---------- *) PROCEDURE (this: Slides) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Slides) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Slides) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Slides) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Slides) Item* (index: CtlT.Any): Slide, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Slide(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Slides) FindBySlideID* (SlideID: INTEGER): Slide, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SlideID, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN This_Slide(CtlC.VarAny(ret)) END FindBySlideID; PROCEDURE (this: Slides) Add* (index: INTEGER; Layout: PpSlideLayout): Slide, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.IntVar(Layout, arg[0]); CtlC.CallParMethod(this, 2004, arg, ret); RETURN This_Slide(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Slides) InsertFromFile* (FileName: ARRAY OF CHAR; index: INTEGER; SlideStart: INTEGER; SlideEnd: INTEGER): INTEGER, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.IntVar(index, arg[2]); CtlC.IntVar(SlideStart, arg[1]); CtlC.IntVar(SlideEnd, arg[0]); CtlC.CallParMethod(this, 2005, arg, ret); RETURN CtlC.VarInt(ret) END InsertFromFile; PROCEDURE (this: Slides) Range* ((* optional *) index: CtlT.Any): SlideRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 2006, arg, ret); RETURN ThisSlideRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Slides) Paste* (index: INTEGER): SlideRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2007, arg, ret); RETURN ThisSlideRange(CtlC.VarAny(ret)) END Paste; (* ---------- _Slide, dual, nonextensible ---------- *) PROCEDURE (this: _Slide) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: _Slide) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: _Slide) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 2003)) END Shapes; PROCEDURE (this: _Slide) HeadersFooters* (): HeadersFooters, NEW; BEGIN RETURN ThisHeadersFooters(CtlC.GetAny(this, 2004)) END HeadersFooters; PROCEDURE (this: _Slide) SlideShowTransition* (): SlideShowTransition, NEW; BEGIN RETURN ThisSlideShowTransition(CtlC.GetAny(this, 2005)) END SlideShowTransition; PROCEDURE (this: _Slide) ColorScheme* (): ColorScheme, NEW; BEGIN RETURN ThisColorScheme(CtlC.GetAny(this, 2006)) END ColorScheme; PROCEDURE (this: _Slide) PUTColorScheme* (p1: ColorScheme), NEW; BEGIN CtlC.PutObj(this, 2006, p1) END PUTColorScheme; PROCEDURE (this: _Slide) Background* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 2007)) END Background; PROCEDURE (this: _Slide) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END Name; PROCEDURE (this: _Slide) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2008, p1) END PUTName; PROCEDURE (this: _Slide) SlideID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END SlideID; PROCEDURE (this: _Slide) PrintSteps* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END PrintSteps; PROCEDURE (this: _Slide) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2011, NIL); END Select; PROCEDURE (this: _Slide) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2012, NIL); END Cut; PROCEDURE (this: _Slide) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2013, NIL); END Copy; PROCEDURE (this: _Slide) Layout* (): PpSlideLayout, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END Layout; PROCEDURE (this: _Slide) PUTLayout* (p1: PpSlideLayout), NEW; BEGIN CtlC.PutInt(this, 2014, p1) END PUTLayout; PROCEDURE (this: _Slide) Duplicate* (): SlideRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2015, ret); RETURN ThisSlideRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: _Slide) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2016, NIL); END Delete; PROCEDURE (this: _Slide) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2017)) END Tags; PROCEDURE (this: _Slide) SlideIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2018) END SlideIndex; PROCEDURE (this: _Slide) SlideNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2019) END SlideNumber; PROCEDURE (this: _Slide) DisplayMasterShapes* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2020) END DisplayMasterShapes; PROCEDURE (this: _Slide) PUTDisplayMasterShapes* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2020, p1) END PUTDisplayMasterShapes; PROCEDURE (this: _Slide) FollowMasterBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2021) END FollowMasterBackground; PROCEDURE (this: _Slide) PUTFollowMasterBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2021, p1) END PUTFollowMasterBackground; PROCEDURE (this: _Slide) NotesPage* (): SlideRange, NEW; BEGIN RETURN ThisSlideRange(CtlC.GetAny(this, 2022)) END NotesPage; PROCEDURE (this: _Slide) Master* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2023)) END Master; PROCEDURE (this: _Slide) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 2024)) END Hyperlinks; PROCEDURE (this: _Slide) Export* (FileName: ARRAY OF CHAR; FilterName: ARRAY OF CHAR; ScaleWidth: INTEGER; ScaleHeight: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.StrVar(FilterName, arg[2]); CtlC.IntVar(ScaleWidth, arg[1]); CtlC.IntVar(ScaleHeight, arg[0]); CtlC.CallParMethod(this, 2025, arg, NIL); END Export; PROCEDURE (this: _Slide) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 2026)) END Scripts; (* ---------- SlideRange, dual, nonextensible ---------- *) PROCEDURE (this: SlideRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideRange) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 2003)) END Shapes; PROCEDURE (this: SlideRange) HeadersFooters* (): HeadersFooters, NEW; BEGIN RETURN ThisHeadersFooters(CtlC.GetAny(this, 2004)) END HeadersFooters; PROCEDURE (this: SlideRange) SlideShowTransition* (): SlideShowTransition, NEW; BEGIN RETURN ThisSlideShowTransition(CtlC.GetAny(this, 2005)) END SlideShowTransition; PROCEDURE (this: SlideRange) ColorScheme* (): ColorScheme, NEW; BEGIN RETURN ThisColorScheme(CtlC.GetAny(this, 2006)) END ColorScheme; PROCEDURE (this: SlideRange) PUTColorScheme* (p1: ColorScheme), NEW; BEGIN CtlC.PutObj(this, 2006, p1) END PUTColorScheme; PROCEDURE (this: SlideRange) Background* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 2007)) END Background; PROCEDURE (this: SlideRange) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END Name; PROCEDURE (this: SlideRange) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2008, p1) END PUTName; PROCEDURE (this: SlideRange) SlideID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END SlideID; PROCEDURE (this: SlideRange) PrintSteps* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END PrintSteps; PROCEDURE (this: SlideRange) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2011, NIL); END Select; PROCEDURE (this: SlideRange) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2012, NIL); END Cut; PROCEDURE (this: SlideRange) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2013, NIL); END Copy; PROCEDURE (this: SlideRange) Layout* (): PpSlideLayout, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END Layout; PROCEDURE (this: SlideRange) PUTLayout* (p1: PpSlideLayout), NEW; BEGIN CtlC.PutInt(this, 2014, p1) END PUTLayout; PROCEDURE (this: SlideRange) Duplicate* (): SlideRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2015, ret); RETURN ThisSlideRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: SlideRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2016, NIL); END Delete; PROCEDURE (this: SlideRange) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2017)) END Tags; PROCEDURE (this: SlideRange) SlideIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2018) END SlideIndex; PROCEDURE (this: SlideRange) SlideNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2019) END SlideNumber; PROCEDURE (this: SlideRange) DisplayMasterShapes* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2020) END DisplayMasterShapes; PROCEDURE (this: SlideRange) PUTDisplayMasterShapes* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2020, p1) END PUTDisplayMasterShapes; PROCEDURE (this: SlideRange) FollowMasterBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2021) END FollowMasterBackground; PROCEDURE (this: SlideRange) PUTFollowMasterBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2021, p1) END PUTFollowMasterBackground; PROCEDURE (this: SlideRange) NotesPage* (): SlideRange, NEW; BEGIN RETURN ThisSlideRange(CtlC.GetAny(this, 2022)) END NotesPage; PROCEDURE (this: SlideRange) Master* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2023)) END Master; PROCEDURE (this: SlideRange) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 2024)) END Hyperlinks; PROCEDURE (this: SlideRange) Export* (FileName: ARRAY OF CHAR; FilterName: ARRAY OF CHAR; ScaleWidth: INTEGER; ScaleHeight: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.StrVar(FilterName, arg[2]); CtlC.IntVar(ScaleWidth, arg[1]); CtlC.IntVar(ScaleHeight, arg[0]); CtlC.CallParMethod(this, 2025, arg, NIL); END Export; PROCEDURE (this: SlideRange) Item* (index: CtlT.Any): Slide, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Slide(CtlC.VarAny(ret)) END Item; PROCEDURE (this: SlideRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: SlideRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: SlideRange) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 2026)) END Scripts; (* ---------- _Master, dual, nonextensible ---------- *) PROCEDURE (this: _Master) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: _Master) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: _Master) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 2003)) END Shapes; PROCEDURE (this: _Master) HeadersFooters* (): HeadersFooters, NEW; BEGIN RETURN ThisHeadersFooters(CtlC.GetAny(this, 2004)) END HeadersFooters; PROCEDURE (this: _Master) ColorScheme* (): ColorScheme, NEW; BEGIN RETURN ThisColorScheme(CtlC.GetAny(this, 2005)) END ColorScheme; PROCEDURE (this: _Master) PUTColorScheme* (p1: ColorScheme), NEW; BEGIN CtlC.PutObj(this, 2005, p1) END PUTColorScheme; PROCEDURE (this: _Master) Background* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 2006)) END Background; PROCEDURE (this: _Master) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END Name; PROCEDURE (this: _Master) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTName; PROCEDURE (this: _Master) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2008, NIL); END Delete; PROCEDURE (this: _Master) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END Height; PROCEDURE (this: _Master) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2010) END Width; PROCEDURE (this: _Master) TextStyles* (): TextStyles, NEW; BEGIN RETURN ThisTextStyles(CtlC.GetAny(this, 2011)) END TextStyles; PROCEDURE (this: _Master) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 2012)) END Hyperlinks; PROCEDURE (this: _Master) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 2013)) END Scripts; (* ---------- ColorSchemes, dual, nonextensible ---------- *) PROCEDURE (this: ColorSchemes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ColorSchemes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: ColorSchemes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ColorSchemes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ColorSchemes) Item* (index: INTEGER): ColorScheme, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisColorScheme(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ColorSchemes) Add* (Scheme: ColorScheme): ColorScheme, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Scheme, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisColorScheme(CtlC.VarAny(ret)) END Add; (* ---------- ColorScheme, dual, nonextensible ---------- *) PROCEDURE (this: ColorScheme) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ColorScheme) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: ColorScheme) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ColorScheme) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ColorScheme) Colors* (SchemeColor: PpColorSchemeIndex): RGBColor, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(SchemeColor, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRGBColor(CtlC.VarAny(ret)) END Colors; PROCEDURE (this: ColorScheme) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2003, NIL); END Delete; (* ---------- RGBColor, dual, nonextensible ---------- *) PROCEDURE (this: RGBColor) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: RGBColor) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: RGBColor) RGB* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END RGB; PROCEDURE (this: RGBColor) PUTRGB* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTRGB; (* ---------- SlideShowTransition, dual, nonextensible ---------- *) PROCEDURE (this: SlideShowTransition) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SlideShowTransition) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SlideShowTransition) AdvanceOnClick* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END AdvanceOnClick; PROCEDURE (this: SlideShowTransition) PUTAdvanceOnClick* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTAdvanceOnClick; PROCEDURE (this: SlideShowTransition) AdvanceOnTime* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END AdvanceOnTime; PROCEDURE (this: SlideShowTransition) PUTAdvanceOnTime* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTAdvanceOnTime; PROCEDURE (this: SlideShowTransition) AdvanceTime* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2005) END AdvanceTime; PROCEDURE (this: SlideShowTransition) PUTAdvanceTime* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2005, p1) END PUTAdvanceTime; PROCEDURE (this: SlideShowTransition) EntryEffect* (): PpEntryEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END EntryEffect; PROCEDURE (this: SlideShowTransition) PUTEntryEffect* (p1: PpEntryEffect), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTEntryEffect; PROCEDURE (this: SlideShowTransition) Hidden* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END Hidden; PROCEDURE (this: SlideShowTransition) PUTHidden* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTHidden; PROCEDURE (this: SlideShowTransition) LoopSoundUntilNext* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END LoopSoundUntilNext; PROCEDURE (this: SlideShowTransition) PUTLoopSoundUntilNext* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTLoopSoundUntilNext; PROCEDURE (this: SlideShowTransition) SoundEffect* (): SoundEffect, NEW; BEGIN RETURN ThisSoundEffect(CtlC.GetAny(this, 2009)) END SoundEffect; PROCEDURE (this: SlideShowTransition) Speed* (): PpTransitionSpeed, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END Speed; PROCEDURE (this: SlideShowTransition) PUTSpeed* (p1: PpTransitionSpeed), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTSpeed; (* ---------- SoundEffect, dual, nonextensible ---------- *) PROCEDURE (this: SoundEffect) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: SoundEffect) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: SoundEffect) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END Name; PROCEDURE (this: SoundEffect) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTName; PROCEDURE (this: SoundEffect) Type* (): PpSoundEffectType, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END Type; PROCEDURE (this: SoundEffect) PUTType* (p1: PpSoundEffectType), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTType; PROCEDURE (this: SoundEffect) ImportFromFile* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2005, arg, NIL); END ImportFromFile; PROCEDURE (this: SoundEffect) Play* (), NEW; BEGIN CtlC.CallMethod(this, 2006, NIL); END Play; (* ---------- SoundFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: SoundFormat) Play* (), NEW; BEGIN CtlC.CallMethod(this, 2000, NIL); END Play; PROCEDURE (this: SoundFormat) Import* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2001, arg, NIL); END Import; PROCEDURE (this: SoundFormat) Export* (FileName: ARRAY OF CHAR): PpSoundFormatType, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2002, arg, ret); RETURN CtlC.VarInt(ret) END Export; PROCEDURE (this: SoundFormat) Type* (): PpSoundFormatType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Type; PROCEDURE (this: SoundFormat) SourceFullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END SourceFullName; (* ---------- HeadersFooters, dual, nonextensible ---------- *) PROCEDURE (this: HeadersFooters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: HeadersFooters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: HeadersFooters) DateAndTime* (): HeaderFooter, NEW; BEGIN RETURN ThisHeaderFooter(CtlC.GetAny(this, 2003)) END DateAndTime; PROCEDURE (this: HeadersFooters) SlideNumber* (): HeaderFooter, NEW; BEGIN RETURN ThisHeaderFooter(CtlC.GetAny(this, 2004)) END SlideNumber; PROCEDURE (this: HeadersFooters) Header* (): HeaderFooter, NEW; BEGIN RETURN ThisHeaderFooter(CtlC.GetAny(this, 2005)) END Header; PROCEDURE (this: HeadersFooters) Footer* (): HeaderFooter, NEW; BEGIN RETURN ThisHeaderFooter(CtlC.GetAny(this, 2006)) END Footer; PROCEDURE (this: HeadersFooters) DisplayOnTitleSlide* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END DisplayOnTitleSlide; PROCEDURE (this: HeadersFooters) PUTDisplayOnTitleSlide* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTDisplayOnTitleSlide; PROCEDURE (this: HeadersFooters) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 2008, NIL); END Clear; (* ---------- Shapes, dual, nonextensible ---------- *) PROCEDURE (this: Shapes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: Shapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: Shapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Shapes) Item* (index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Shapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Shapes) AddCallout* (Type: CtlOffice.MsoCalloutType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCallout; PROCEDURE (this: Shapes) AddConnector* (Type: CtlOffice.MsoConnectorType; BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddConnector; PROCEDURE (this: Shapes) AddCurve* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCurve; PROCEDURE (this: Shapes) AddLabel* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLabel; PROCEDURE (this: Shapes) AddLine* (BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLine; PROCEDURE (this: Shapes) AddPicture* (FileName: ARRAY OF CHAR; LinkToFile: CtlOffice.MsoTriState; SaveWithDocument: CtlOffice.MsoTriState; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 7 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[6]); CtlC.IntVar(LinkToFile, arg[5]); CtlC.IntVar(SaveWithDocument, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPicture; PROCEDURE (this: Shapes) AddPolyline* (SafeArrayOfPoints: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPolyline; PROCEDURE (this: Shapes) AddShape* (Type: CtlOffice.MsoAutoShapeType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 17, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddShape; PROCEDURE (this: Shapes) AddTextEffect* (PresetTextEffect: CtlOffice.MsoPresetTextEffect; Text: ARRAY OF CHAR; FontName: ARRAY OF CHAR; FontSize: SHORTREAL; FontBold: CtlOffice.MsoTriState; FontItalic: CtlOffice.MsoTriState; Left: SHORTREAL; Top: SHORTREAL): Shape, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(PresetTextEffect, arg[7]); CtlC.StrVar(Text, arg[6]); CtlC.StrVar(FontName, arg[5]); CtlC.SRealVar(FontSize, arg[4]); CtlC.IntVar(FontBold, arg[3]); CtlC.IntVar(FontItalic, arg[2]); CtlC.SRealVar(Left, arg[1]); CtlC.SRealVar(Top, arg[0]); CtlC.CallParMethod(this, 18, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextEffect; PROCEDURE (this: Shapes) AddTextbox* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextbox; PROCEDURE (this: Shapes) BuildFreeform* (EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL): FreeformBuilder, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(EditingType, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 20, arg, ret); RETURN ThisFreeformBuilder(CtlC.VarAny(ret)) END BuildFreeform; PROCEDURE (this: Shapes) SelectAll* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SelectAll; PROCEDURE (this: Shapes) Range* ((* optional *) index: CtlT.Any): ShapeRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Shapes) HasTitle* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END HasTitle; PROCEDURE (this: Shapes) AddTitle* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2005, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTitle; PROCEDURE (this: Shapes) Title* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 2006)) END Title; PROCEDURE (this: Shapes) Placeholders* (): Placeholders, NEW; BEGIN RETURN ThisPlaceholders(CtlC.GetAny(this, 2007)) END Placeholders; PROCEDURE (this: Shapes) AddOLEObject* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; ClassName: ARRAY OF CHAR; FileName: ARRAY OF CHAR; DisplayAsIcon: CtlOffice.MsoTriState; IconFileName: ARRAY OF CHAR; IconIndex: INTEGER; IconLabel: ARRAY OF CHAR; Link: CtlOffice.MsoTriState): Shape, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[10]); CtlC.SRealVar(Top, arg[9]); CtlC.SRealVar(Width, arg[8]); CtlC.SRealVar(Height, arg[7]); CtlC.StrVar(ClassName, arg[6]); CtlC.StrVar(FileName, arg[5]); CtlC.IntVar(DisplayAsIcon, arg[4]); CtlC.StrVar(IconFileName, arg[3]); CtlC.IntVar(IconIndex, arg[2]); CtlC.StrVar(IconLabel, arg[1]); CtlC.IntVar(Link, arg[0]); CtlC.CallParMethod(this, 2008, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddOLEObject; PROCEDURE (this: Shapes) AddComment* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2009, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddComment; PROCEDURE (this: Shapes) AddPlaceholder* (Type: PpPlaceholderType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2010, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPlaceholder; PROCEDURE (this: Shapes) AddMediaObject* (FileName: ARRAY OF CHAR; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2011, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddMediaObject; PROCEDURE (this: Shapes) Paste* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2012, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Paste; PROCEDURE (this: Shapes) AddTable* (NumRows: INTEGER; NumColumns: INTEGER; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(NumRows, arg[5]); CtlC.IntVar(NumColumns, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2013, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTable; (* ---------- Placeholders, dual, nonextensible ---------- *) PROCEDURE (this: Placeholders) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Placeholders) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Placeholders) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Placeholders) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Placeholders) Item* (index: INTEGER): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; (* ---------- PlaceholderFormat, dual, nonextensible ---------- *) PROCEDURE (this: PlaceholderFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PlaceholderFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PlaceholderFormat) Type* (): PpPlaceholderType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Type; (* ---------- FreeformBuilder, dual, nonextensible ---------- *) PROCEDURE (this: FreeformBuilder) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: FreeformBuilder) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: FreeformBuilder) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FreeformBuilder) AddNodes* (SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END AddNodes; PROCEDURE (this: FreeformBuilder) ConvertToShape* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 11, ret); RETURN ThisShape(CtlC.VarAny(ret)) END ConvertToShape; (* ---------- Shape, dual, nonextensible ---------- *) PROCEDURE (this: Shape) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: Shape) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: Shape) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shape) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Apply; PROCEDURE (this: Shape) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; PROCEDURE (this: Shape) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Flip; PROCEDURE (this: Shape) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END IncrementLeft; PROCEDURE (this: Shape) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END IncrementRotation; PROCEDURE (this: Shape) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementTop; PROCEDURE (this: Shape) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 17, NIL); END PickUp; PROCEDURE (this: Shape) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 18, NIL); END RerouteConnections; PROCEDURE (this: Shape) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; fScale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 19, arg, NIL); END ScaleHeight; PROCEDURE (this: Shape) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; fScale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 20, arg, NIL); END ScaleWidth; PROCEDURE (this: Shape) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SetShapesDefaultProperties; PROCEDURE (this: Shape) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 23, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: Shape) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ZOrder; PROCEDURE (this: Shape) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: Shape) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: Shape) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: Shape) BlackWhiteMode* (): CtlOffice.MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BlackWhiteMode; PROCEDURE (this: Shape) PUTBlackWhiteMode* (p1: CtlOffice.MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBlackWhiteMode; PROCEDURE (this: Shape) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: Shape) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: Shape) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: Shape) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: Shape) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: Shape) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: Shape) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: Shape) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: Shape) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: Shape) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: Shape) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: Shape) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: Shape) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: Shape) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: Shape) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: Shape) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: Shape) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: Shape) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: Shape) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: Shape) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: Shape) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: Shape) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: Shape) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: Shape) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: Shape) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: Shape) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: Shape) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: Shape) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: Shape) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: Shape) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: Shape) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: Shape) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: Shape) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: Shape) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: Shape) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 2003)) END OLEFormat; PROCEDURE (this: Shape) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 2004)) END LinkFormat; PROCEDURE (this: Shape) PlaceholderFormat* (): PlaceholderFormat, NEW; BEGIN RETURN ThisPlaceholderFormat(CtlC.GetAny(this, 2005)) END PlaceholderFormat; PROCEDURE (this: Shape) AnimationSettings* (): AnimationSettings, NEW; BEGIN RETURN ThisAnimationSettings(CtlC.GetAny(this, 2006)) END AnimationSettings; PROCEDURE (this: Shape) ActionSettings* (): ActionSettings, NEW; BEGIN RETURN ThisActionSettings(CtlC.GetAny(this, 2007)) END ActionSettings; PROCEDURE (this: Shape) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2008)) END Tags; PROCEDURE (this: Shape) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2009, NIL); END Cut; PROCEDURE (this: Shape) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2010, NIL); END Copy; PROCEDURE (this: Shape) Select* (Replace: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Replace, arg[0]); CtlC.CallParMethod(this, 2011, arg, NIL); END Select; PROCEDURE (this: Shape) Duplicate* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2012, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: Shape) MediaType* (): PpMediaType, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END MediaType; PROCEDURE (this: Shape) HasTextFrame* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END HasTextFrame; PROCEDURE (this: Shape) SoundFormat* (): SoundFormat, NEW; BEGIN RETURN ThisSoundFormat(CtlC.GetAny(this, 2015)) END SoundFormat; PROCEDURE (this: Shape) Script* (): CtlOffice.Script, NEW; BEGIN RETURN CtlOffice.ThisScript(CtlC.GetAny(this, 130)) END Script; PROCEDURE (this: Shape) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: Shape) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; PROCEDURE (this: Shape) HasTable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2016) END HasTable; PROCEDURE (this: Shape) Table* (): Table, NEW; BEGIN RETURN ThisTable(CtlC.GetAny(this, 2017)) END Table; PROCEDURE (this: Shape) Export* (PathName: ARRAY OF CHAR; Filter: PpShapeFormat; ScaleWidth: INTEGER; ScaleHeight: INTEGER; ExportMode: PpExportMode), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(PathName, arg[4]); CtlC.IntVar(Filter, arg[3]); CtlC.IntVar(ScaleWidth, arg[2]); CtlC.IntVar(ScaleHeight, arg[1]); CtlC.IntVar(ExportMode, arg[0]); CtlC.CallParMethod(this, 2018, arg, NIL); END Export; (* ---------- ShapeRange, dual, nonextensible ---------- *) PROCEDURE (this: ShapeRange) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ShapeRange) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ShapeRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeRange) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Apply; PROCEDURE (this: ShapeRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; PROCEDURE (this: ShapeRange) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Flip; PROCEDURE (this: ShapeRange) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END IncrementLeft; PROCEDURE (this: ShapeRange) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END IncrementRotation; PROCEDURE (this: ShapeRange) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementTop; PROCEDURE (this: ShapeRange) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 17, NIL); END PickUp; PROCEDURE (this: ShapeRange) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 18, NIL); END RerouteConnections; PROCEDURE (this: ShapeRange) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; fScale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 19, arg, NIL); END ScaleHeight; PROCEDURE (this: ShapeRange) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; fScale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(fScale, arg[0]); CtlC.CallParMethod(this, 20, arg, NIL); END ScaleWidth; PROCEDURE (this: ShapeRange) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SetShapesDefaultProperties; PROCEDURE (this: ShapeRange) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 23, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: ShapeRange) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ZOrder; PROCEDURE (this: ShapeRange) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: ShapeRange) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: ShapeRange) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: ShapeRange) BlackWhiteMode* (): CtlOffice.MsoBlackWhiteMode, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BlackWhiteMode; PROCEDURE (this: ShapeRange) PUTBlackWhiteMode* (p1: CtlOffice.MsoBlackWhiteMode), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBlackWhiteMode; PROCEDURE (this: ShapeRange) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: ShapeRange) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: ShapeRange) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: ShapeRange) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: ShapeRange) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: ShapeRange) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: ShapeRange) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: ShapeRange) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: ShapeRange) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: ShapeRange) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: ShapeRange) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: ShapeRange) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: ShapeRange) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: ShapeRange) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: ShapeRange) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: ShapeRange) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: ShapeRange) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: ShapeRange) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: ShapeRange) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: ShapeRange) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: ShapeRange) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: ShapeRange) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: ShapeRange) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: ShapeRange) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: ShapeRange) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: ShapeRange) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: ShapeRange) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: ShapeRange) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: ShapeRange) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: ShapeRange) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: ShapeRange) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: ShapeRange) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: ShapeRange) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: ShapeRange) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: ShapeRange) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 2003)) END OLEFormat; PROCEDURE (this: ShapeRange) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 2004)) END LinkFormat; PROCEDURE (this: ShapeRange) PlaceholderFormat* (): PlaceholderFormat, NEW; BEGIN RETURN ThisPlaceholderFormat(CtlC.GetAny(this, 2005)) END PlaceholderFormat; PROCEDURE (this: ShapeRange) AnimationSettings* (): AnimationSettings, NEW; BEGIN RETURN ThisAnimationSettings(CtlC.GetAny(this, 2006)) END AnimationSettings; PROCEDURE (this: ShapeRange) ActionSettings* (): ActionSettings, NEW; BEGIN RETURN ThisActionSettings(CtlC.GetAny(this, 2007)) END ActionSettings; PROCEDURE (this: ShapeRange) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2008)) END Tags; PROCEDURE (this: ShapeRange) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2009, NIL); END Cut; PROCEDURE (this: ShapeRange) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2010, NIL); END Copy; PROCEDURE (this: ShapeRange) Select* (Replace: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Replace, arg[0]); CtlC.CallParMethod(this, 2011, arg, NIL); END Select; PROCEDURE (this: ShapeRange) Duplicate* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2012, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: ShapeRange) MediaType* (): PpMediaType, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END MediaType; PROCEDURE (this: ShapeRange) HasTextFrame* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END HasTextFrame; PROCEDURE (this: ShapeRange) SoundFormat* (): SoundFormat, NEW; BEGIN RETURN ThisSoundFormat(CtlC.GetAny(this, 2015)) END SoundFormat; PROCEDURE (this: ShapeRange) Item* (index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END Count; PROCEDURE (this: ShapeRange) Group* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2016, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ShapeRange) Regroup* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2017, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Regroup; PROCEDURE (this: ShapeRange) Align* (AlignCmd: CtlOffice.MsoAlignCmd; RelativeTo: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(AlignCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 2018, arg, NIL); END Align; PROCEDURE (this: ShapeRange) Distribute* (DistributeCmd: CtlOffice.MsoDistributeCmd; RelativeTo: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(DistributeCmd, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 2019, arg, NIL); END Distribute; PROCEDURE (this: ShapeRange) Script* (): CtlOffice.Script, NEW; BEGIN RETURN CtlOffice.ThisScript(CtlC.GetAny(this, 130)) END Script; PROCEDURE (this: ShapeRange) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: ShapeRange) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; PROCEDURE (this: ShapeRange) HasTable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2021) END HasTable; PROCEDURE (this: ShapeRange) Table* (): Table, NEW; BEGIN RETURN ThisTable(CtlC.GetAny(this, 2022)) END Table; PROCEDURE (this: ShapeRange) Export* (PathName: ARRAY OF CHAR; Filter: PpShapeFormat; ScaleWidth: INTEGER; ScaleHeight: INTEGER; ExportMode: PpExportMode), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(PathName, arg[4]); CtlC.IntVar(Filter, arg[3]); CtlC.IntVar(ScaleWidth, arg[2]); CtlC.IntVar(ScaleHeight, arg[1]); CtlC.IntVar(ExportMode, arg[0]); CtlC.CallParMethod(this, 2023, arg, NIL); END Export; (* ---------- GroupShapes, dual, nonextensible ---------- *) PROCEDURE (this: GroupShapes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: GroupShapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: GroupShapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: GroupShapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: GroupShapes) Item* (index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: GroupShapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; (* ---------- Adjustments, dual, nonextensible ---------- *) PROCEDURE (this: Adjustments) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: Adjustments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: Adjustments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Adjustments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Adjustments) Item* (index: INTEGER): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarSReal(ret) END Item; PROCEDURE (this: Adjustments) PUTItem* (index: INTEGER; p2: SHORTREAL), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.SRealVar(p2, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUTItem; (* ---------- PictureFormat, dual, nonextensible ---------- *) PROCEDURE (this: PictureFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: PictureFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: PictureFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: PictureFormat) IncrementBrightness* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementBrightness; PROCEDURE (this: PictureFormat) IncrementContrast* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementContrast; PROCEDURE (this: PictureFormat) Brightness* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Brightness; PROCEDURE (this: PictureFormat) PUTBrightness* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTBrightness; PROCEDURE (this: PictureFormat) ColorType* (): CtlOffice.MsoPictureColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END ColorType; PROCEDURE (this: PictureFormat) PUTColorType* (p1: CtlOffice.MsoPictureColorType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTColorType; PROCEDURE (this: PictureFormat) Contrast* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Contrast; PROCEDURE (this: PictureFormat) PUTContrast* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTContrast; PROCEDURE (this: PictureFormat) CropBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END CropBottom; PROCEDURE (this: PictureFormat) PUTCropBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTCropBottom; PROCEDURE (this: PictureFormat) CropLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END CropLeft; PROCEDURE (this: PictureFormat) PUTCropLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTCropLeft; PROCEDURE (this: PictureFormat) CropRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END CropRight; PROCEDURE (this: PictureFormat) PUTCropRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTCropRight; PROCEDURE (this: PictureFormat) CropTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END CropTop; PROCEDURE (this: PictureFormat) PUTCropTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTCropTop; PROCEDURE (this: PictureFormat) TransparencyColor* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END TransparencyColor; PROCEDURE (this: PictureFormat) PUTTransparencyColor* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTTransparencyColor; PROCEDURE (this: PictureFormat) TransparentBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END TransparentBackground; PROCEDURE (this: PictureFormat) PUTTransparentBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTTransparentBackground; (* ---------- FillFormat, dual, nonextensible ---------- *) PROCEDURE (this: FillFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: FillFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: FillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FillFormat) Background* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Background; PROCEDURE (this: FillFormat) OneColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END OneColorGradient; PROCEDURE (this: FillFormat) Patterned* (Pattern: CtlOffice.MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Patterned; PROCEDURE (this: FillFormat) PresetGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; PresetGradientType: CtlOffice.MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetGradient; PROCEDURE (this: FillFormat) PresetTextured* (PresetTexture: CtlOffice.MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END PresetTextured; PROCEDURE (this: FillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 15, NIL); END Solid; PROCEDURE (this: FillFormat) TwoColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END TwoColorGradient; PROCEDURE (this: FillFormat) UserPicture* (PictureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PictureFile, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END UserPicture; PROCEDURE (this: FillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END UserTextured; PROCEDURE (this: FillFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: FillFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: FillFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ForeColor; PROCEDURE (this: FillFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 101, p1) END PUTForeColor; PROCEDURE (this: FillFormat) GradientColorType* (): CtlOffice.MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END GradientColorType; PROCEDURE (this: FillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END GradientDegree; PROCEDURE (this: FillFormat) GradientStyle* (): CtlOffice.MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END GradientStyle; PROCEDURE (this: FillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END GradientVariant; PROCEDURE (this: FillFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Pattern; PROCEDURE (this: FillFormat) PresetGradientType* (): CtlOffice.MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetGradientType; PROCEDURE (this: FillFormat) PresetTexture* (): CtlOffice.MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTexture; PROCEDURE (this: FillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END TextureName; PROCEDURE (this: FillFormat) TextureType* (): CtlOffice.MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END TextureType; PROCEDURE (this: FillFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: FillFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: FillFormat) Type* (): CtlOffice.MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Type; PROCEDURE (this: FillFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Visible; PROCEDURE (this: FillFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTVisible; (* ---------- LineFormat, dual, nonextensible ---------- *) PROCEDURE (this: LineFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: LineFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: LineFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: LineFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: LineFormat) PUTBackColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTBackColor; PROCEDURE (this: LineFormat) BeginArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END BeginArrowheadLength; PROCEDURE (this: LineFormat) PUTBeginArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTBeginArrowheadLength; PROCEDURE (this: LineFormat) BeginArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginArrowheadStyle; PROCEDURE (this: LineFormat) PUTBeginArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBeginArrowheadStyle; PROCEDURE (this: LineFormat) BeginArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END BeginArrowheadWidth; PROCEDURE (this: LineFormat) PUTBeginArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTBeginArrowheadWidth; PROCEDURE (this: LineFormat) DashStyle* (): CtlOffice.MsoLineDashStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END DashStyle; PROCEDURE (this: LineFormat) PUTDashStyle* (p1: CtlOffice.MsoLineDashStyle), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTDashStyle; PROCEDURE (this: LineFormat) EndArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndArrowheadLength; PROCEDURE (this: LineFormat) PUTEndArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTEndArrowheadLength; PROCEDURE (this: LineFormat) EndArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END EndArrowheadStyle; PROCEDURE (this: LineFormat) PUTEndArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTEndArrowheadStyle; PROCEDURE (this: LineFormat) EndArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END EndArrowheadWidth; PROCEDURE (this: LineFormat) PUTEndArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTEndArrowheadWidth; PROCEDURE (this: LineFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 108)) END ForeColor; PROCEDURE (this: LineFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 108, p1) END PUTForeColor; PROCEDURE (this: LineFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Pattern; PROCEDURE (this: LineFormat) PUTPattern* (p1: CtlOffice.MsoPatternType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTPattern; PROCEDURE (this: LineFormat) Style* (): CtlOffice.MsoLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END Style; PROCEDURE (this: LineFormat) PUTStyle* (p1: CtlOffice.MsoLineStyle), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTStyle; PROCEDURE (this: LineFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: LineFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: LineFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Visible; PROCEDURE (this: LineFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 112, p1) END PUTVisible; PROCEDURE (this: LineFormat) Weight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END Weight; PROCEDURE (this: LineFormat) PUTWeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTWeight; (* ---------- ShadowFormat, dual, nonextensible ---------- *) PROCEDURE (this: ShadowFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ShadowFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ShadowFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShadowFormat) IncrementOffsetX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementOffsetX; PROCEDURE (this: ShadowFormat) IncrementOffsetY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementOffsetY; PROCEDURE (this: ShadowFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END ForeColor; PROCEDURE (this: ShadowFormat) PUTForeColor* (p1: ColorFormat), NEW; BEGIN CtlC.PutObj(this, 100, p1) END PUTForeColor; PROCEDURE (this: ShadowFormat) Obscured* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Obscured; PROCEDURE (this: ShadowFormat) PUTObscured* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTObscured; PROCEDURE (this: ShadowFormat) OffsetX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END OffsetX; PROCEDURE (this: ShadowFormat) PUTOffsetX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTOffsetX; PROCEDURE (this: ShadowFormat) OffsetY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END OffsetY; PROCEDURE (this: ShadowFormat) PUTOffsetY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTOffsetY; PROCEDURE (this: ShadowFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END Transparency; PROCEDURE (this: ShadowFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTTransparency; PROCEDURE (this: ShadowFormat) Type* (): CtlOffice.MsoShadowType, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Type; PROCEDURE (this: ShadowFormat) PUTType* (p1: CtlOffice.MsoShadowType), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTType; PROCEDURE (this: ShadowFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Visible; PROCEDURE (this: ShadowFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTVisible; (* ---------- ConnectorFormat, dual, nonextensible ---------- *) PROCEDURE (this: ConnectorFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ConnectorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ConnectorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ConnectorFormat) BeginConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END BeginConnect; PROCEDURE (this: ConnectorFormat) BeginDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END BeginDisconnect; PROCEDURE (this: ConnectorFormat) EndConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END EndConnect; PROCEDURE (this: ConnectorFormat) EndDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 13, NIL); END EndDisconnect; PROCEDURE (this: ConnectorFormat) BeginConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END BeginConnected; PROCEDURE (this: ConnectorFormat) BeginConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 101)) END BeginConnectedShape; PROCEDURE (this: ConnectorFormat) BeginConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginConnectionSite; PROCEDURE (this: ConnectorFormat) EndConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END EndConnected; PROCEDURE (this: ConnectorFormat) EndConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 104)) END EndConnectedShape; PROCEDURE (this: ConnectorFormat) EndConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndConnectionSite; PROCEDURE (this: ConnectorFormat) Type* (): CtlOffice.MsoConnectorType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Type; PROCEDURE (this: ConnectorFormat) PUTType* (p1: CtlOffice.MsoConnectorType), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTType; (* ---------- TextEffectFormat, dual, nonextensible ---------- *) PROCEDURE (this: TextEffectFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: TextEffectFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: TextEffectFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextEffectFormat) ToggleVerticalText* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END ToggleVerticalText; PROCEDURE (this: TextEffectFormat) Alignment* (): CtlOffice.MsoTextEffectAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Alignment; PROCEDURE (this: TextEffectFormat) PUTAlignment* (p1: CtlOffice.MsoTextEffectAlignment), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAlignment; PROCEDURE (this: TextEffectFormat) FontBold* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END FontBold; PROCEDURE (this: TextEffectFormat) PUTFontBold* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTFontBold; PROCEDURE (this: TextEffectFormat) FontItalic* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END FontItalic; PROCEDURE (this: TextEffectFormat) PUTFontItalic* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTFontItalic; PROCEDURE (this: TextEffectFormat) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END FontName; PROCEDURE (this: TextEffectFormat) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTFontName; PROCEDURE (this: TextEffectFormat) FontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END FontSize; PROCEDURE (this: TextEffectFormat) PUTFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTFontSize; PROCEDURE (this: TextEffectFormat) KernedPairs* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END KernedPairs; PROCEDURE (this: TextEffectFormat) PUTKernedPairs* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTKernedPairs; PROCEDURE (this: TextEffectFormat) NormalizedHeight* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END NormalizedHeight; PROCEDURE (this: TextEffectFormat) PUTNormalizedHeight* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTNormalizedHeight; PROCEDURE (this: TextEffectFormat) PresetShape* (): CtlOffice.MsoPresetTextEffectShape, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetShape; PROCEDURE (this: TextEffectFormat) PUTPresetShape* (p1: CtlOffice.MsoPresetTextEffectShape), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetShape; PROCEDURE (this: TextEffectFormat) PresetTextEffect* (): CtlOffice.MsoPresetTextEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTextEffect; PROCEDURE (this: TextEffectFormat) PUTPresetTextEffect* (p1: CtlOffice.MsoPresetTextEffect), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTPresetTextEffect; PROCEDURE (this: TextEffectFormat) RotatedChars* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END RotatedChars; PROCEDURE (this: TextEffectFormat) PUTRotatedChars* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTRotatedChars; PROCEDURE (this: TextEffectFormat) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Text; PROCEDURE (this: TextEffectFormat) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTText; PROCEDURE (this: TextEffectFormat) Tracking* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Tracking; PROCEDURE (this: TextEffectFormat) PUTTracking* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTracking; (* ---------- ThreeDFormat, dual, nonextensible ---------- *) PROCEDURE (this: ThreeDFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ThreeDFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ThreeDFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ThreeDFormat) IncrementRotationX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementRotationX; PROCEDURE (this: ThreeDFormat) IncrementRotationY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementRotationY; PROCEDURE (this: ThreeDFormat) ResetRotation* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END ResetRotation; PROCEDURE (this: ThreeDFormat) SetThreeDFormat* (PresetThreeDFormat: CtlOffice.MsoPresetThreeDFormat), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetThreeDFormat, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetThreeDFormat; PROCEDURE (this: ThreeDFormat) SetExtrusionDirection* (PresetExtrusionDirection: CtlOffice.MsoPresetExtrusionDirection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetExtrusionDirection, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetExtrusionDirection; PROCEDURE (this: ThreeDFormat) Depth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Depth; PROCEDURE (this: ThreeDFormat) PUTDepth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTDepth; PROCEDURE (this: ThreeDFormat) ExtrusionColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ExtrusionColor; PROCEDURE (this: ThreeDFormat) ExtrusionColorType* (): CtlOffice.MsoExtrusionColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END ExtrusionColorType; PROCEDURE (this: ThreeDFormat) PUTExtrusionColorType* (p1: CtlOffice.MsoExtrusionColorType), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTExtrusionColorType; PROCEDURE (this: ThreeDFormat) Perspective* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END Perspective; PROCEDURE (this: ThreeDFormat) PUTPerspective* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTPerspective; PROCEDURE (this: ThreeDFormat) PresetExtrusionDirection* (): CtlOffice.MsoPresetExtrusionDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PresetExtrusionDirection; PROCEDURE (this: ThreeDFormat) PresetLightingDirection* (): CtlOffice.MsoPresetLightingDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END PresetLightingDirection; PROCEDURE (this: ThreeDFormat) PUTPresetLightingDirection* (p1: CtlOffice.MsoPresetLightingDirection), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTPresetLightingDirection; PROCEDURE (this: ThreeDFormat) PresetLightingSoftness* (): CtlOffice.MsoPresetLightingSoftness, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END PresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PUTPresetLightingSoftness* (p1: CtlOffice.MsoPresetLightingSoftness), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTPresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PresetMaterial* (): CtlOffice.MsoPresetMaterial, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetMaterial; PROCEDURE (this: ThreeDFormat) PUTPresetMaterial* (p1: CtlOffice.MsoPresetMaterial), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetMaterial; PROCEDURE (this: ThreeDFormat) PresetThreeDFormat* (): CtlOffice.MsoPresetThreeDFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetThreeDFormat; PROCEDURE (this: ThreeDFormat) RotationX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END RotationX; PROCEDURE (this: ThreeDFormat) PUTRotationX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTRotationX; PROCEDURE (this: ThreeDFormat) RotationY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 110) END RotationY; PROCEDURE (this: ThreeDFormat) PUTRotationY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 110, p1) END PUTRotationY; PROCEDURE (this: ThreeDFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END Visible; PROCEDURE (this: ThreeDFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTVisible; (* ---------- TextFrame, dual, nonextensible ---------- *) PROCEDURE (this: TextFrame) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: TextFrame) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: TextFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextFrame) MarginBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END MarginBottom; PROCEDURE (this: TextFrame) PUTMarginBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTMarginBottom; PROCEDURE (this: TextFrame) MarginLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 101) END MarginLeft; PROCEDURE (this: TextFrame) PUTMarginLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 101, p1) END PUTMarginLeft; PROCEDURE (this: TextFrame) MarginRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END MarginRight; PROCEDURE (this: TextFrame) PUTMarginRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTMarginRight; PROCEDURE (this: TextFrame) MarginTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END MarginTop; PROCEDURE (this: TextFrame) PUTMarginTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTMarginTop; PROCEDURE (this: TextFrame) Orientation* (): CtlOffice.MsoTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Orientation; PROCEDURE (this: TextFrame) PUTOrientation* (p1: CtlOffice.MsoTextOrientation), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTOrientation; PROCEDURE (this: TextFrame) HasText* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END HasText; PROCEDURE (this: TextFrame) TextRange* (): TextRange, NEW; BEGIN RETURN ThisTextRange(CtlC.GetAny(this, 2004)) END TextRange; PROCEDURE (this: TextFrame) Ruler* (): Ruler, NEW; BEGIN RETURN ThisRuler(CtlC.GetAny(this, 2005)) END Ruler; PROCEDURE (this: TextFrame) HorizontalAnchor* (): CtlOffice.MsoHorizontalAnchor, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END HorizontalAnchor; PROCEDURE (this: TextFrame) PUTHorizontalAnchor* (p1: CtlOffice.MsoHorizontalAnchor), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTHorizontalAnchor; PROCEDURE (this: TextFrame) VerticalAnchor* (): CtlOffice.MsoVerticalAnchor, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END VerticalAnchor; PROCEDURE (this: TextFrame) PUTVerticalAnchor* (p1: CtlOffice.MsoVerticalAnchor), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTVerticalAnchor; PROCEDURE (this: TextFrame) AutoSize* (): PpAutoSize, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END AutoSize; PROCEDURE (this: TextFrame) PUTAutoSize* (p1: PpAutoSize), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTAutoSize; PROCEDURE (this: TextFrame) WordWrap* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END WordWrap; PROCEDURE (this: TextFrame) PUTWordWrap* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTWordWrap; PROCEDURE (this: TextFrame) DeleteText* (), NEW; BEGIN CtlC.CallMethod(this, 2010, NIL); END DeleteText; (* ---------- CalloutFormat, dual, nonextensible ---------- *) PROCEDURE (this: CalloutFormat) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: CalloutFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: CalloutFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: CalloutFormat) AutomaticLength* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END AutomaticLength; PROCEDURE (this: CalloutFormat) CustomDrop* (Drop: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Drop, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END CustomDrop; PROCEDURE (this: CalloutFormat) CustomLength* (Length: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Length, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END CustomLength; PROCEDURE (this: CalloutFormat) PresetDrop* (DropType: CtlOffice.MsoCalloutDropType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(DropType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetDrop; PROCEDURE (this: CalloutFormat) Accent* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Accent; PROCEDURE (this: CalloutFormat) PUTAccent* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAccent; PROCEDURE (this: CalloutFormat) Angle* (): CtlOffice.MsoCalloutAngleType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Angle; PROCEDURE (this: CalloutFormat) PUTAngle* (p1: CtlOffice.MsoCalloutAngleType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAngle; PROCEDURE (this: CalloutFormat) AutoAttach* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END AutoAttach; PROCEDURE (this: CalloutFormat) PUTAutoAttach* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTAutoAttach; PROCEDURE (this: CalloutFormat) AutoLength* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END AutoLength; PROCEDURE (this: CalloutFormat) Border* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Border; PROCEDURE (this: CalloutFormat) PUTBorder* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTBorder; PROCEDURE (this: CalloutFormat) Drop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END Drop; PROCEDURE (this: CalloutFormat) DropType* (): CtlOffice.MsoCalloutDropType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END DropType; PROCEDURE (this: CalloutFormat) Gap* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END Gap; PROCEDURE (this: CalloutFormat) PUTGap* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTGap; PROCEDURE (this: CalloutFormat) Length* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END Length; PROCEDURE (this: CalloutFormat) Type* (): CtlOffice.MsoCalloutType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Type; PROCEDURE (this: CalloutFormat) PUTType* (p1: CtlOffice.MsoCalloutType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTType; (* ---------- ShapeNodes, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNodes) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ShapeNodes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ShapeNodes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNodes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeNodes) Item* (index: CtlT.Any): ShapeNode, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShapeNode(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeNodes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeNodes) Delete* (index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Delete; PROCEDURE (this: ShapeNodes) Insert* (index: INTEGER; SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[8]); CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Insert; PROCEDURE (this: ShapeNodes) SetEditingType* (index: INTEGER; EditingType: CtlOffice.MsoEditingType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.IntVar(EditingType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetEditingType; PROCEDURE (this: ShapeNodes) SetPosition* (index: INTEGER; X1: SHORTREAL; Y1: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetPosition; PROCEDURE (this: ShapeNodes) SetSegmentType* (index: INTEGER; SegmentType: CtlOffice.MsoSegmentType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.IntVar(SegmentType, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END SetSegmentType; (* ---------- ShapeNode, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNode) Application* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2001) END Application; PROCEDURE (this: ShapeNode) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Creator; PROCEDURE (this: ShapeNode) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNode) EditingType* (): CtlOffice.MsoEditingType, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EditingType; PROCEDURE (this: ShapeNode) Points* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Points; PROCEDURE (this: ShapeNode) SegmentType* (): CtlOffice.MsoSegmentType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SegmentType; (* ---------- OLEFormat, dual, nonextensible ---------- *) PROCEDURE (this: OLEFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: OLEFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: OLEFormat) ObjectVerbs* (): ObjectVerbs, NEW; BEGIN RETURN ThisObjectVerbs(CtlC.GetAny(this, 2003)) END ObjectVerbs; PROCEDURE (this: OLEFormat) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2004) END Object; PROCEDURE (this: OLEFormat) ProgID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END ProgID; PROCEDURE (this: OLEFormat) FollowColors* (): PpFollowColors, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END FollowColors; PROCEDURE (this: OLEFormat) PUTFollowColors* (p1: PpFollowColors), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTFollowColors; PROCEDURE (this: OLEFormat) DoVerb* (index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2007, arg, NIL); END DoVerb; PROCEDURE (this: OLEFormat) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 2008, NIL); END Activate; (* ---------- LinkFormat, dual, nonextensible ---------- *) PROCEDURE (this: LinkFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: LinkFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: LinkFormat) SourceFullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END SourceFullName; PROCEDURE (this: LinkFormat) PUTSourceFullName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTSourceFullName; PROCEDURE (this: LinkFormat) AutoUpdate* (): PpUpdateOption, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END AutoUpdate; PROCEDURE (this: LinkFormat) PUTAutoUpdate* (p1: PpUpdateOption), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTAutoUpdate; PROCEDURE (this: LinkFormat) Update* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Update; (* ---------- ObjectVerbs, dual, nonextensible ---------- *) PROCEDURE (this: ObjectVerbs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ObjectVerbs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: ObjectVerbs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ObjectVerbs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ObjectVerbs) Item* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; (* ---------- AnimationSettings, dual, nonextensible ---------- *) PROCEDURE (this: AnimationSettings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: AnimationSettings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: AnimationSettings) DimColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 2003)) END DimColor; PROCEDURE (this: AnimationSettings) SoundEffect* (): SoundEffect, NEW; BEGIN RETURN ThisSoundEffect(CtlC.GetAny(this, 2004)) END SoundEffect; PROCEDURE (this: AnimationSettings) EntryEffect* (): PpEntryEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END EntryEffect; PROCEDURE (this: AnimationSettings) PUTEntryEffect* (p1: PpEntryEffect), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTEntryEffect; PROCEDURE (this: AnimationSettings) AfterEffect* (): PpAfterEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END AfterEffect; PROCEDURE (this: AnimationSettings) PUTAfterEffect* (p1: PpAfterEffect), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTAfterEffect; PROCEDURE (this: AnimationSettings) AnimationOrder* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END AnimationOrder; PROCEDURE (this: AnimationSettings) PUTAnimationOrder* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTAnimationOrder; PROCEDURE (this: AnimationSettings) AdvanceMode* (): PpAdvanceMode, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END AdvanceMode; PROCEDURE (this: AnimationSettings) PUTAdvanceMode* (p1: PpAdvanceMode), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTAdvanceMode; PROCEDURE (this: AnimationSettings) AdvanceTime* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END AdvanceTime; PROCEDURE (this: AnimationSettings) PUTAdvanceTime* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2009, p1) END PUTAdvanceTime; PROCEDURE (this: AnimationSettings) PlaySettings* (): PlaySettings, NEW; BEGIN RETURN ThisPlaySettings(CtlC.GetAny(this, 2010)) END PlaySettings; PROCEDURE (this: AnimationSettings) TextLevelEffect* (): PpTextLevelEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END TextLevelEffect; PROCEDURE (this: AnimationSettings) PUTTextLevelEffect* (p1: PpTextLevelEffect), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTTextLevelEffect; PROCEDURE (this: AnimationSettings) TextUnitEffect* (): PpTextUnitEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END TextUnitEffect; PROCEDURE (this: AnimationSettings) PUTTextUnitEffect* (p1: PpTextUnitEffect), NEW; BEGIN CtlC.PutInt(this, 2012, p1) END PUTTextUnitEffect; PROCEDURE (this: AnimationSettings) Animate* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END Animate; PROCEDURE (this: AnimationSettings) PUTAnimate* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2013, p1) END PUTAnimate; PROCEDURE (this: AnimationSettings) AnimateBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END AnimateBackground; PROCEDURE (this: AnimationSettings) PUTAnimateBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2014, p1) END PUTAnimateBackground; PROCEDURE (this: AnimationSettings) AnimateTextInReverse* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2015) END AnimateTextInReverse; PROCEDURE (this: AnimationSettings) PUTAnimateTextInReverse* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2015, p1) END PUTAnimateTextInReverse; PROCEDURE (this: AnimationSettings) ChartUnitEffect* (): PpChartUnitEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 2016) END ChartUnitEffect; PROCEDURE (this: AnimationSettings) PUTChartUnitEffect* (p1: PpChartUnitEffect), NEW; BEGIN CtlC.PutInt(this, 2016, p1) END PUTChartUnitEffect; (* ---------- ActionSettings, dual, nonextensible ---------- *) PROCEDURE (this: ActionSettings) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ActionSettings) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: ActionSettings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ActionSettings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ActionSettings) Item* (index: PpMouseActivation): ActionSetting, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisActionSetting(CtlC.VarAny(ret)) END Item; (* ---------- ActionSetting, dual, nonextensible ---------- *) PROCEDURE (this: ActionSetting) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ActionSetting) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ActionSetting) Action* (): PpActionType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Action; PROCEDURE (this: ActionSetting) PUTAction* (p1: PpActionType), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTAction; PROCEDURE (this: ActionSetting) ActionVerb* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END ActionVerb; PROCEDURE (this: ActionSetting) PUTActionVerb* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTActionVerb; PROCEDURE (this: ActionSetting) AnimateAction* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END AnimateAction; PROCEDURE (this: ActionSetting) PUTAnimateAction* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTAnimateAction; PROCEDURE (this: ActionSetting) Run* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2006) END Run; PROCEDURE (this: ActionSetting) PUTRun* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2006, p1) END PUTRun; PROCEDURE (this: ActionSetting) SlideShowName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END SlideShowName; PROCEDURE (this: ActionSetting) PUTSlideShowName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTSlideShowName; PROCEDURE (this: ActionSetting) Hyperlink* (): Hyperlink, NEW; BEGIN RETURN ThisHyperlink(CtlC.GetAny(this, 2008)) END Hyperlink; PROCEDURE (this: ActionSetting) SoundEffect* (): SoundEffect, NEW; BEGIN RETURN ThisSoundEffect(CtlC.GetAny(this, 2009)) END SoundEffect; PROCEDURE (this: ActionSetting) ShowandReturn* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END ShowandReturn; PROCEDURE (this: ActionSetting) PUTShowandReturn* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTShowandReturn; (* ---------- PlaySettings, dual, nonextensible ---------- *) PROCEDURE (this: PlaySettings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PlaySettings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PlaySettings) ActionVerb* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END ActionVerb; PROCEDURE (this: PlaySettings) PUTActionVerb* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTActionVerb; PROCEDURE (this: PlaySettings) HideWhileNotPlaying* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END HideWhileNotPlaying; PROCEDURE (this: PlaySettings) PUTHideWhileNotPlaying* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTHideWhileNotPlaying; PROCEDURE (this: PlaySettings) LoopUntilStopped* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END LoopUntilStopped; PROCEDURE (this: PlaySettings) PUTLoopUntilStopped* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTLoopUntilStopped; PROCEDURE (this: PlaySettings) PlayOnEntry* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END PlayOnEntry; PROCEDURE (this: PlaySettings) PUTPlayOnEntry* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTPlayOnEntry; PROCEDURE (this: PlaySettings) RewindMovie* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END RewindMovie; PROCEDURE (this: PlaySettings) PUTRewindMovie* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTRewindMovie; PROCEDURE (this: PlaySettings) PauseAnimation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END PauseAnimation; PROCEDURE (this: PlaySettings) PUTPauseAnimation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTPauseAnimation; PROCEDURE (this: PlaySettings) StopAfterSlides* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END StopAfterSlides; PROCEDURE (this: PlaySettings) PUTStopAfterSlides* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTStopAfterSlides; (* ---------- TextRange, dual, nonextensible ---------- *) PROCEDURE (this: TextRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TextRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: TextRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TextRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TextRange) ActionSettings* (): ActionSettings, NEW; BEGIN RETURN ThisActionSettings(CtlC.GetAny(this, 2003)) END ActionSettings; PROCEDURE (this: TextRange) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END Start; PROCEDURE (this: TextRange) Length* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END Length; PROCEDURE (this: TextRange) BoundLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2006) END BoundLeft; PROCEDURE (this: TextRange) BoundTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2007) END BoundTop; PROCEDURE (this: TextRange) BoundWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2008) END BoundWidth; PROCEDURE (this: TextRange) BoundHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END BoundHeight; PROCEDURE (this: TextRange) Paragraphs* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2010, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Paragraphs; PROCEDURE (this: TextRange) Sentences* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2011, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Sentences; PROCEDURE (this: TextRange) Words* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2012, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Words; PROCEDURE (this: TextRange) Characters* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2013, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Characters; PROCEDURE (this: TextRange) Lines* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2014, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Lines; PROCEDURE (this: TextRange) Runs* (Start: INTEGER; Length: INTEGER): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(Length, arg[0]); CtlC.CallParMethod(this, 2015, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Runs; PROCEDURE (this: TextRange) TrimText* (): TextRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2016, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END TrimText; PROCEDURE (this: TextRange) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Text; PROCEDURE (this: TextRange) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTText; PROCEDURE (this: TextRange) InsertAfter* (NewText: ARRAY OF CHAR): TextRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(NewText, arg[0]); CtlC.CallParMethod(this, 2017, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END InsertAfter; PROCEDURE (this: TextRange) InsertBefore* (NewText: ARRAY OF CHAR): TextRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(NewText, arg[0]); CtlC.CallParMethod(this, 2018, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END InsertBefore; PROCEDURE (this: TextRange) InsertDateTime* (DateTimeFormat: PpDateTimeFormat; InsertAsField: CtlOffice.MsoTriState): TextRange, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(DateTimeFormat, arg[1]); CtlC.IntVar(InsertAsField, arg[0]); CtlC.CallParMethod(this, 2019, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END InsertDateTime; PROCEDURE (this: TextRange) InsertSlideNumber* (): TextRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2020, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END InsertSlideNumber; PROCEDURE (this: TextRange) InsertSymbol* (FontName: ARRAY OF CHAR; CharNumber: INTEGER; Unicode: CtlOffice.MsoTriState): TextRange, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FontName, arg[2]); CtlC.IntVar(CharNumber, arg[1]); CtlC.IntVar(Unicode, arg[0]); CtlC.CallParMethod(this, 2021, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END InsertSymbol; PROCEDURE (this: TextRange) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 2022)) END Font; PROCEDURE (this: TextRange) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN ThisParagraphFormat(CtlC.GetAny(this, 2023)) END ParagraphFormat; PROCEDURE (this: TextRange) IndentLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2024) END IndentLevel; PROCEDURE (this: TextRange) PUTIndentLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2024, p1) END PUTIndentLevel; PROCEDURE (this: TextRange) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2025, NIL); END Select; PROCEDURE (this: TextRange) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 2026, NIL); END Cut; PROCEDURE (this: TextRange) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 2027, NIL); END Copy; PROCEDURE (this: TextRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2028, NIL); END Delete; PROCEDURE (this: TextRange) Paste* (): TextRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2029, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Paste; PROCEDURE (this: TextRange) ChangeCase* (Type: PpChangeCase), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 2030, arg, NIL); END ChangeCase; PROCEDURE (this: TextRange) AddPeriods* (), NEW; BEGIN CtlC.CallMethod(this, 2031, NIL); END AddPeriods; PROCEDURE (this: TextRange) RemovePeriods* (), NEW; BEGIN CtlC.CallMethod(this, 2032, NIL); END RemovePeriods; PROCEDURE (this: TextRange) Find* (FindWhat: ARRAY OF CHAR; After: INTEGER; MatchCase: CtlOffice.MsoTriState; WholeWords: CtlOffice.MsoTriState): TextRange, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FindWhat, arg[3]); CtlC.IntVar(After, arg[2]); CtlC.IntVar(MatchCase, arg[1]); CtlC.IntVar(WholeWords, arg[0]); CtlC.CallParMethod(this, 2033, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Find; PROCEDURE (this: TextRange) Replace* (FindWhat: ARRAY OF CHAR; ReplaceWhat: ARRAY OF CHAR; After: INTEGER; MatchCase: CtlOffice.MsoTriState; WholeWords: CtlOffice.MsoTriState): TextRange, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FindWhat, arg[4]); CtlC.StrVar(ReplaceWhat, arg[3]); CtlC.IntVar(After, arg[2]); CtlC.IntVar(MatchCase, arg[1]); CtlC.IntVar(WholeWords, arg[0]); CtlC.CallParMethod(this, 2034, arg, ret); RETURN ThisTextRange(CtlC.VarAny(ret)) END Replace; PROCEDURE (this: TextRange) RotatedBounds* (OUT X1: SHORTREAL; OUT Y1: SHORTREAL; OUT X2: SHORTREAL; OUT Y2: SHORTREAL; OUT X3: SHORTREAL; OUT Y3: SHORTREAL; OUT x4: SHORTREAL; OUT y4: SHORTREAL), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.RefSRealVar(X1, arg[7]); CtlC.RefSRealVar(Y1, arg[6]); CtlC.RefSRealVar(X2, arg[5]); CtlC.RefSRealVar(Y2, arg[4]); CtlC.RefSRealVar(X3, arg[3]); CtlC.RefSRealVar(Y3, arg[2]); CtlC.RefSRealVar(x4, arg[1]); CtlC.RefSRealVar(y4, arg[0]); CtlC.CallParMethod(this, 2035, arg, NIL); END RotatedBounds; PROCEDURE (this: TextRange) LanguageID* (): CtlOffice.MsoLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 2036) END LanguageID; PROCEDURE (this: TextRange) PUTLanguageID* (p1: CtlOffice.MsoLanguageID), NEW; BEGIN CtlC.PutInt(this, 2036, p1) END PUTLanguageID; PROCEDURE (this: TextRange) RtlRun* (), NEW; BEGIN CtlC.CallMethod(this, 2037, NIL); END RtlRun; PROCEDURE (this: TextRange) LtrRun* (), NEW; BEGIN CtlC.CallMethod(this, 2038, NIL); END LtrRun; (* ---------- Ruler, dual, nonextensible ---------- *) PROCEDURE (this: Ruler) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Ruler) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Ruler) TabStops* (): TabStops, NEW; BEGIN RETURN ThisTabStops(CtlC.GetAny(this, 2003)) END TabStops; PROCEDURE (this: Ruler) Levels* (): RulerLevels, NEW; BEGIN RETURN ThisRulerLevels(CtlC.GetAny(this, 2004)) END Levels; (* ---------- RulerLevels, dual, nonextensible ---------- *) PROCEDURE (this: RulerLevels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: RulerLevels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: RulerLevels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: RulerLevels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: RulerLevels) Item* (index: INTEGER): RulerLevel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRulerLevel(CtlC.VarAny(ret)) END Item; (* ---------- RulerLevel, dual, nonextensible ---------- *) PROCEDURE (this: RulerLevel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: RulerLevel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: RulerLevel) FirstMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2003) END FirstMargin; PROCEDURE (this: RulerLevel) PUTFirstMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2003, p1) END PUTFirstMargin; PROCEDURE (this: RulerLevel) LeftMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2004) END LeftMargin; PROCEDURE (this: RulerLevel) PUTLeftMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2004, p1) END PUTLeftMargin; (* ---------- TabStops, dual, nonextensible ---------- *) PROCEDURE (this: TabStops) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TabStops) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: TabStops) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TabStops) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TabStops) Item* (index: INTEGER): TabStop, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TabStops) DefaultSpacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2003) END DefaultSpacing; PROCEDURE (this: TabStops) PUTDefaultSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2003, p1) END PUTDefaultSpacing; PROCEDURE (this: TabStops) Add* (Type: PpTabStopType; Position: SHORTREAL): TabStop, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.SRealVar(Position, arg[0]); CtlC.CallParMethod(this, 2004, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END Add; (* ---------- TabStop, dual, nonextensible ---------- *) PROCEDURE (this: TabStop) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TabStop) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TabStop) Type* (): PpTabStopType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Type; PROCEDURE (this: TabStop) PUTType* (p1: PpTabStopType), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTType; PROCEDURE (this: TabStop) Position* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2004) END Position; PROCEDURE (this: TabStop) PUTPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2004, p1) END PUTPosition; PROCEDURE (this: TabStop) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Clear; (* ---------- Font, dual, nonextensible ---------- *) PROCEDURE (this: Font) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Font) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Font) Color* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 2003)) END Color; PROCEDURE (this: Font) Bold* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END Bold; PROCEDURE (this: Font) PUTBold* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTBold; PROCEDURE (this: Font) Italic* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END Italic; PROCEDURE (this: Font) PUTItalic* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTItalic; PROCEDURE (this: Font) Shadow* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END Shadow; PROCEDURE (this: Font) PUTShadow* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTShadow; PROCEDURE (this: Font) Emboss* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END Emboss; PROCEDURE (this: Font) PUTEmboss* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTEmboss; PROCEDURE (this: Font) Underline* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END Underline; PROCEDURE (this: Font) PUTUnderline* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTUnderline; PROCEDURE (this: Font) Subscript* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END Subscript; PROCEDURE (this: Font) PUTSubscript* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTSubscript; PROCEDURE (this: Font) Superscript* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END Superscript; PROCEDURE (this: Font) PUTSuperscript* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTSuperscript; PROCEDURE (this: Font) BaselineOffset* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2011) END BaselineOffset; PROCEDURE (this: Font) PUTBaselineOffset* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2011, p1) END PUTBaselineOffset; PROCEDURE (this: Font) Embedded* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END Embedded; PROCEDURE (this: Font) Embeddable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END Embeddable; PROCEDURE (this: Font) Size* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2014) END Size; PROCEDURE (this: Font) PUTSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2014, p1) END PUTSize; PROCEDURE (this: Font) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2015) END Name; PROCEDURE (this: Font) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2015, p1) END PUTName; PROCEDURE (this: Font) NameFarEast* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2016) END NameFarEast; PROCEDURE (this: Font) PUTNameFarEast* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2016, p1) END PUTNameFarEast; PROCEDURE (this: Font) NameAscii* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2017) END NameAscii; PROCEDURE (this: Font) PUTNameAscii* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2017, p1) END PUTNameAscii; PROCEDURE (this: Font) AutoRotateNumbers* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2018) END AutoRotateNumbers; PROCEDURE (this: Font) PUTAutoRotateNumbers* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2018, p1) END PUTAutoRotateNumbers; PROCEDURE (this: Font) NameOther* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2019) END NameOther; PROCEDURE (this: Font) PUTNameOther* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2019, p1) END PUTNameOther; PROCEDURE (this: Font) NameComplexScript* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2020) END NameComplexScript; PROCEDURE (this: Font) PUTNameComplexScript* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2020, p1) END PUTNameComplexScript; (* ---------- ParagraphFormat, dual, nonextensible ---------- *) PROCEDURE (this: ParagraphFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: ParagraphFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: ParagraphFormat) Alignment* (): PpParagraphAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Alignment; PROCEDURE (this: ParagraphFormat) PUTAlignment* (p1: PpParagraphAlignment), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTAlignment; PROCEDURE (this: ParagraphFormat) Bullet* (): BulletFormat, NEW; BEGIN RETURN ThisBulletFormat(CtlC.GetAny(this, 2004)) END Bullet; PROCEDURE (this: ParagraphFormat) LineRuleBefore* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END LineRuleBefore; PROCEDURE (this: ParagraphFormat) PUTLineRuleBefore* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTLineRuleBefore; PROCEDURE (this: ParagraphFormat) LineRuleAfter* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END LineRuleAfter; PROCEDURE (this: ParagraphFormat) PUTLineRuleAfter* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTLineRuleAfter; PROCEDURE (this: ParagraphFormat) LineRuleWithin* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END LineRuleWithin; PROCEDURE (this: ParagraphFormat) PUTLineRuleWithin* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTLineRuleWithin; PROCEDURE (this: ParagraphFormat) SpaceBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2008) END SpaceBefore; PROCEDURE (this: ParagraphFormat) PUTSpaceBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2008, p1) END PUTSpaceBefore; PROCEDURE (this: ParagraphFormat) SpaceAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END SpaceAfter; PROCEDURE (this: ParagraphFormat) PUTSpaceAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2009, p1) END PUTSpaceAfter; PROCEDURE (this: ParagraphFormat) SpaceWithin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2010) END SpaceWithin; PROCEDURE (this: ParagraphFormat) PUTSpaceWithin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2010, p1) END PUTSpaceWithin; PROCEDURE (this: ParagraphFormat) BaseLineAlignment* (): PpBaselineAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END BaseLineAlignment; PROCEDURE (this: ParagraphFormat) PUTBaseLineAlignment* (p1: PpBaselineAlignment), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTBaseLineAlignment; PROCEDURE (this: ParagraphFormat) FarEastLineBreakControl* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END FarEastLineBreakControl; PROCEDURE (this: ParagraphFormat) PUTFarEastLineBreakControl* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2012, p1) END PUTFarEastLineBreakControl; PROCEDURE (this: ParagraphFormat) WordWrap* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END WordWrap; PROCEDURE (this: ParagraphFormat) PUTWordWrap* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2013, p1) END PUTWordWrap; PROCEDURE (this: ParagraphFormat) HangingPunctuation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2014) END HangingPunctuation; PROCEDURE (this: ParagraphFormat) PUTHangingPunctuation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2014, p1) END PUTHangingPunctuation; PROCEDURE (this: ParagraphFormat) TextDirection* (): PpDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 2015) END TextDirection; PROCEDURE (this: ParagraphFormat) PUTTextDirection* (p1: PpDirection), NEW; BEGIN CtlC.PutInt(this, 2015, p1) END PUTTextDirection; (* ---------- BulletFormat, dual, nonextensible ---------- *) PROCEDURE (this: BulletFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: BulletFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: BulletFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Visible; PROCEDURE (this: BulletFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTVisible; PROCEDURE (this: BulletFormat) Character* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Character; PROCEDURE (this: BulletFormat) PUTCharacter* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTCharacter; PROCEDURE (this: BulletFormat) RelativeSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2004) END RelativeSize; PROCEDURE (this: BulletFormat) PUTRelativeSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2004, p1) END PUTRelativeSize; PROCEDURE (this: BulletFormat) UseTextColor* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END UseTextColor; PROCEDURE (this: BulletFormat) PUTUseTextColor* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTUseTextColor; PROCEDURE (this: BulletFormat) UseTextFont* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END UseTextFont; PROCEDURE (this: BulletFormat) PUTUseTextFont* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTUseTextFont; PROCEDURE (this: BulletFormat) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 2007)) END Font; PROCEDURE (this: BulletFormat) Type* (): PpBulletType, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END Type; PROCEDURE (this: BulletFormat) PUTType* (p1: PpBulletType), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTType; PROCEDURE (this: BulletFormat) Style* (): PpNumberedBulletStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END Style; PROCEDURE (this: BulletFormat) PUTStyle* (p1: PpNumberedBulletStyle), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTStyle; PROCEDURE (this: BulletFormat) StartValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END StartValue; PROCEDURE (this: BulletFormat) PUTStartValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTStartValue; PROCEDURE (this: BulletFormat) Picture* (Picture: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Picture, arg[0]); CtlC.CallParMethod(this, 2011, arg, NIL); END Picture; PROCEDURE (this: BulletFormat) Number* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END Number; (* ---------- TextStyles, dual, nonextensible ---------- *) PROCEDURE (this: TextStyles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TextStyles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: TextStyles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TextStyles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TextStyles) Item* (Type: PpTextStyleType): TextStyle, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTextStyle(CtlC.VarAny(ret)) END Item; (* ---------- TextStyle, dual, nonextensible ---------- *) PROCEDURE (this: TextStyle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TextStyle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TextStyle) Ruler* (): Ruler, NEW; BEGIN RETURN ThisRuler(CtlC.GetAny(this, 2003)) END Ruler; PROCEDURE (this: TextStyle) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 2004)) END TextFrame; PROCEDURE (this: TextStyle) Levels* (): TextStyleLevels, NEW; BEGIN RETURN ThisTextStyleLevels(CtlC.GetAny(this, 2005)) END Levels; (* ---------- TextStyleLevels, dual, nonextensible ---------- *) PROCEDURE (this: TextStyleLevels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TextStyleLevels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: TextStyleLevels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TextStyleLevels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TextStyleLevels) Item* (Level: INTEGER): TextStyleLevel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Level, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTextStyleLevel(CtlC.VarAny(ret)) END Item; (* ---------- TextStyleLevel, dual, nonextensible ---------- *) PROCEDURE (this: TextStyleLevel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: TextStyleLevel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: TextStyleLevel) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN ThisParagraphFormat(CtlC.GetAny(this, 2003)) END ParagraphFormat; PROCEDURE (this: TextStyleLevel) Font* (): Font, NEW; BEGIN RETURN ThisFont(CtlC.GetAny(this, 2004)) END Font; (* ---------- HeaderFooter, dual, nonextensible ---------- *) PROCEDURE (this: HeaderFooter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: HeaderFooter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: HeaderFooter) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Visible; PROCEDURE (this: HeaderFooter) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTVisible; PROCEDURE (this: HeaderFooter) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END Text; PROCEDURE (this: HeaderFooter) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTText; PROCEDURE (this: HeaderFooter) UseFormat* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END UseFormat; PROCEDURE (this: HeaderFooter) PUTUseFormat* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTUseFormat; PROCEDURE (this: HeaderFooter) Format* (): PpDateTimeFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END Format; PROCEDURE (this: HeaderFooter) PUTFormat* (p1: PpDateTimeFormat), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTFormat; (* ---------- _Presentation, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Presentation) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: _Presentation) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: _Presentation) SlideMaster* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2003)) END SlideMaster; PROCEDURE (this: _Presentation) TitleMaster* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2004)) END TitleMaster; PROCEDURE (this: _Presentation) HasTitleMaster* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END HasTitleMaster; PROCEDURE (this: _Presentation) AddTitleMaster* (): _Master, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2006, ret); RETURN This_Master(CtlC.VarAny(ret)) END AddTitleMaster; PROCEDURE (this: _Presentation) ApplyTemplate* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2007, arg, NIL); END ApplyTemplate; PROCEDURE (this: _Presentation) TemplateName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END TemplateName; PROCEDURE (this: _Presentation) NotesMaster* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2009)) END NotesMaster; PROCEDURE (this: _Presentation) HandoutMaster* (): _Master, NEW; BEGIN RETURN This_Master(CtlC.GetAny(this, 2010)) END HandoutMaster; PROCEDURE (this: _Presentation) Slides* (): Slides, NEW; BEGIN RETURN ThisSlides(CtlC.GetAny(this, 2011)) END Slides; PROCEDURE (this: _Presentation) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 2012)) END PageSetup; PROCEDURE (this: _Presentation) ColorSchemes* (): ColorSchemes, NEW; BEGIN RETURN ThisColorSchemes(CtlC.GetAny(this, 2013)) END ColorSchemes; PROCEDURE (this: _Presentation) ExtraColors* (): ExtraColors, NEW; BEGIN RETURN ThisExtraColors(CtlC.GetAny(this, 2014)) END ExtraColors; PROCEDURE (this: _Presentation) SlideShowSettings* (): SlideShowSettings, NEW; BEGIN RETURN ThisSlideShowSettings(CtlC.GetAny(this, 2015)) END SlideShowSettings; PROCEDURE (this: _Presentation) Fonts* (): Fonts, NEW; BEGIN RETURN ThisFonts(CtlC.GetAny(this, 2016)) END Fonts; PROCEDURE (this: _Presentation) Windows* (): DocumentWindows, NEW; BEGIN RETURN ThisDocumentWindows(CtlC.GetAny(this, 2017)) END Windows; PROCEDURE (this: _Presentation) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2018)) END Tags; PROCEDURE (this: _Presentation) DefaultShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 2019)) END DefaultShape; PROCEDURE (this: _Presentation) BuiltInDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2020) END BuiltInDocumentProperties; PROCEDURE (this: _Presentation) CustomDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2021) END CustomDocumentProperties; PROCEDURE (this: _Presentation) VBProject* (): CtlVBIDE.VBProject, NEW; BEGIN RETURN CtlVBIDE.This_VBProject(CtlC.GetAny(this, 2022)) END VBProject; PROCEDURE (this: _Presentation) ReadOnly* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2023) END ReadOnly; PROCEDURE (this: _Presentation) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2024) END FullName; PROCEDURE (this: _Presentation) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2025) END Name; PROCEDURE (this: _Presentation) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2026) END Path; PROCEDURE (this: _Presentation) Saved* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2027) END Saved; PROCEDURE (this: _Presentation) PUTSaved* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2027, p1) END PUTSaved; PROCEDURE (this: _Presentation) LayoutDirection* (): PpDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 2028) END LayoutDirection; PROCEDURE (this: _Presentation) PUTLayoutDirection* (p1: PpDirection), NEW; BEGIN CtlC.PutInt(this, 2028, p1) END PUTLayoutDirection; PROCEDURE (this: _Presentation) NewWindow* (): DocumentWindow, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2029, ret); RETURN ThisDocumentWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: _Presentation) FollowHyperlink* (Address: ARRAY OF CHAR; SubAddress: ARRAY OF CHAR; NewWindow: BOOLEAN; AddHistory: BOOLEAN; ExtraInfo: ARRAY OF CHAR; Method: CtlOffice.MsoExtraInfoMethod; HeaderInfo: ARRAY OF CHAR), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.StrVar(Address, arg[6]); CtlC.StrVar(SubAddress, arg[5]); CtlC.BoolVar(NewWindow, arg[4]); CtlC.BoolVar(AddHistory, arg[3]); CtlC.StrVar(ExtraInfo, arg[2]); CtlC.IntVar(Method, arg[1]); CtlC.StrVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 2030, arg, NIL); END FollowHyperlink; PROCEDURE (this: _Presentation) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 2031, NIL); END AddToFavorites; PROCEDURE (this: _Presentation) PrintOptions* (): PrintOptions, NEW; BEGIN RETURN ThisPrintOptions(CtlC.GetAny(this, 2033)) END PrintOptions; PROCEDURE (this: _Presentation) PrintOut* (From: INTEGER; To: INTEGER; PrintToFile: ARRAY OF CHAR; Copies: INTEGER; Collate: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.IntVar(From, arg[4]); CtlC.IntVar(To, arg[3]); CtlC.StrVar(PrintToFile, arg[2]); CtlC.IntVar(Copies, arg[1]); CtlC.IntVar(Collate, arg[0]); CtlC.CallParMethod(this, 2034, arg, NIL); END PrintOut; PROCEDURE (this: _Presentation) Save* (), NEW; BEGIN CtlC.CallMethod(this, 2035, NIL); END Save; PROCEDURE (this: _Presentation) SaveAs* (FileName: ARRAY OF CHAR; FileFormat: PpSaveAsFileType; EmbedTrueTypeFonts: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.IntVar(FileFormat, arg[1]); CtlC.IntVar(EmbedTrueTypeFonts, arg[0]); CtlC.CallParMethod(this, 2036, arg, NIL); END SaveAs; PROCEDURE (this: _Presentation) SaveCopyAs* (FileName: ARRAY OF CHAR; FileFormat: PpSaveAsFileType; EmbedTrueTypeFonts: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.IntVar(FileFormat, arg[1]); CtlC.IntVar(EmbedTrueTypeFonts, arg[0]); CtlC.CallParMethod(this, 2037, arg, NIL); END SaveCopyAs; PROCEDURE (this: _Presentation) Export* (Path: ARRAY OF CHAR; FilterName: ARRAY OF CHAR; ScaleWidth: INTEGER; ScaleHeight: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[3]); CtlC.StrVar(FilterName, arg[2]); CtlC.IntVar(ScaleWidth, arg[1]); CtlC.IntVar(ScaleHeight, arg[0]); CtlC.CallParMethod(this, 2038, arg, NIL); END Export; PROCEDURE (this: _Presentation) Close* (), NEW; BEGIN CtlC.CallMethod(this, 2039, NIL); END Close; PROCEDURE (this: _Presentation) SetUndoText* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 2040, arg, NIL); END SetUndoText; PROCEDURE (this: _Presentation) Container* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2041) END Container; PROCEDURE (this: _Presentation) DisplayComments* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2042) END DisplayComments; PROCEDURE (this: _Presentation) PUTDisplayComments* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2042, p1) END PUTDisplayComments; PROCEDURE (this: _Presentation) FarEastLineBreakLevel* (): PpFarEastLineBreakLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 2043) END FarEastLineBreakLevel; PROCEDURE (this: _Presentation) PUTFarEastLineBreakLevel* (p1: PpFarEastLineBreakLevel), NEW; BEGIN CtlC.PutInt(this, 2043, p1) END PUTFarEastLineBreakLevel; PROCEDURE (this: _Presentation) NoLineBreakBefore* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2044) END NoLineBreakBefore; PROCEDURE (this: _Presentation) PUTNoLineBreakBefore* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2044, p1) END PUTNoLineBreakBefore; PROCEDURE (this: _Presentation) NoLineBreakAfter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2045) END NoLineBreakAfter; PROCEDURE (this: _Presentation) PUTNoLineBreakAfter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2045, p1) END PUTNoLineBreakAfter; PROCEDURE (this: _Presentation) UpdateLinks* (), NEW; BEGIN CtlC.CallMethod(this, 2046, NIL); END UpdateLinks; PROCEDURE (this: _Presentation) SlideShowWindow* (): SlideShowWindow, NEW; BEGIN RETURN ThisSlideShowWindow(CtlC.GetAny(this, 2047)) END SlideShowWindow; PROCEDURE (this: _Presentation) FarEastLineBreakLanguage* (): CtlOffice.MsoFarEastLineBreakLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 2048) END FarEastLineBreakLanguage; PROCEDURE (this: _Presentation) PUTFarEastLineBreakLanguage* (p1: CtlOffice.MsoFarEastLineBreakLanguageID), NEW; BEGIN CtlC.PutInt(this, 2048, p1) END PUTFarEastLineBreakLanguage; PROCEDURE (this: _Presentation) WebPagePreview* (), NEW; BEGIN CtlC.CallMethod(this, 2049, NIL); END WebPagePreview; PROCEDURE (this: _Presentation) DefaultLanguageID* (): CtlOffice.MsoLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 2050) END DefaultLanguageID; PROCEDURE (this: _Presentation) PUTDefaultLanguageID* (p1: CtlOffice.MsoLanguageID), NEW; BEGIN CtlC.PutInt(this, 2050, p1) END PUTDefaultLanguageID; PROCEDURE (this: _Presentation) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 2051)) END CommandBars; PROCEDURE (this: _Presentation) PublishObjects* (): PublishObjects, NEW; BEGIN RETURN ThisPublishObjects(CtlC.GetAny(this, 2052)) END PublishObjects; PROCEDURE (this: _Presentation) WebOptions* (): WebOptions, NEW; BEGIN RETURN ThisWebOptions(CtlC.GetAny(this, 2053)) END WebOptions; PROCEDURE (this: _Presentation) HTMLProject* (): CtlOffice.HTMLProject, NEW; BEGIN RETURN CtlOffice.ThisHTMLProject(CtlC.GetAny(this, 2054)) END HTMLProject; PROCEDURE (this: _Presentation) ReloadAs* (cp: CtlOffice.MsoEncoding), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(cp, arg[0]); CtlC.CallParMethod(this, 2055, arg, NIL); END ReloadAs; PROCEDURE (this: _Presentation) MakeIntoTemplate* (IsDesignTemplate: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(IsDesignTemplate, arg[0]); CtlC.CallParMethod(this, 2056, arg, NIL); END MakeIntoTemplate; PROCEDURE (this: _Presentation) EnvelopeVisible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2057) END EnvelopeVisible; PROCEDURE (this: _Presentation) PUTEnvelopeVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2057, p1) END PUTEnvelopeVisible; PROCEDURE (this: _Presentation) sblt* (s: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(s, arg[0]); CtlC.CallParMethod(this, 2058, arg, NIL); END sblt; PROCEDURE (this: _Presentation) VBASigned* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2059) END VBASigned; (* ---------- PPDialogs, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPDialogs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PPDialogs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PPDialogs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PPDialogs) Item* (index: CtlT.Any): PPDialog, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPPDialog(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PPDialogs) AddDialog* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; Modal: CtlOffice.MsoTriState; ParentWindow: CtlT.IUnknown; Position: PpDialogPositioning; DisplayHelp: CtlOffice.MsoTriState): PPDialog, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[7]); CtlC.SRealVar(Top, arg[6]); CtlC.SRealVar(Width, arg[5]); CtlC.SRealVar(Height, arg[4]); CtlC.IntVar(Modal, arg[3]); CtlC.IntfceVar(ParentWindow, arg[2]); CtlC.IntVar(Position, arg[1]); CtlC.IntVar(DisplayHelp, arg[0]); CtlC.CallParMethod(this, 2002, arg, ret); RETURN ThisPPDialog(CtlC.VarAny(ret)) END AddDialog; PROCEDURE (this: PPDialogs) AddTabDialog* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; Modal: CtlOffice.MsoTriState; ParentWindow: CtlT.IUnknown; Position: PpDialogPositioning; DisplayHelp: CtlOffice.MsoTriState): PPDialog, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[7]); CtlC.SRealVar(Top, arg[6]); CtlC.SRealVar(Width, arg[5]); CtlC.SRealVar(Height, arg[4]); CtlC.IntVar(Modal, arg[3]); CtlC.IntfceVar(ParentWindow, arg[2]); CtlC.IntVar(Position, arg[1]); CtlC.IntVar(DisplayHelp, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisPPDialog(CtlC.VarAny(ret)) END AddTabDialog; PROCEDURE (this: PPDialogs) LoadDialog* (resourceDLL: ARRAY OF CHAR; nResID: INTEGER; bModal: CtlOffice.MsoTriState; ParentWindow: CtlT.IUnknown; Position: PpDialogPositioning): PPDialog, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(resourceDLL, arg[4]); CtlC.IntVar(nResID, arg[3]); CtlC.IntVar(bModal, arg[2]); CtlC.IntfceVar(ParentWindow, arg[1]); CtlC.IntVar(Position, arg[0]); CtlC.CallParMethod(this, 2004, arg, ret); RETURN ThisPPDialog(CtlC.VarAny(ret)) END LoadDialog; PROCEDURE (this: PPDialogs) AddAlert* (): PPAlert, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 2005, ret); RETURN ThisPPAlert(CtlC.VarAny(ret)) END AddAlert; PROCEDURE (this: PPDialogs) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2006)) END Tags; PROCEDURE (this: PPDialogs) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END Name; PROCEDURE (this: PPDialogs) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTName; PROCEDURE (this: PPDialogs) RunCharacterAlert* (Text: ARRAY OF CHAR; Type: PpAlertType; icon: PpAlertIcon; ParentWindow: CtlT.IUnknown): PpAlertButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[3]); CtlC.IntVar(Type, arg[2]); CtlC.IntVar(icon, arg[1]); CtlC.IntfceVar(ParentWindow, arg[0]); CtlC.CallParMethod(this, 2008, arg, ret); RETURN CtlC.VarInt(ret) END RunCharacterAlert; (* ---------- PPAlert, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPAlert) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PPAlert) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PPAlert) Run* (Title: ARRAY OF CHAR; Type: INTEGER; Text: ARRAY OF CHAR; leftBtn: ARRAY OF CHAR; middleBtn: ARRAY OF CHAR; rightBtn: ARRAY OF CHAR), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.StrVar(Title, arg[5]); CtlC.IntVar(Type, arg[4]); CtlC.StrVar(Text, arg[3]); CtlC.StrVar(leftBtn, arg[2]); CtlC.StrVar(middleBtn, arg[1]); CtlC.StrVar(rightBtn, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Run; PROCEDURE (this: PPAlert) PressedButton* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END PressedButton; PROCEDURE (this: PPAlert) OnButton* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END OnButton; PROCEDURE (this: PPAlert) PUTOnButton* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2005, p1) END PUTOnButton; (* ---------- PPDialog, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPDialog) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PPDialog) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PPDialog) Style* (): PpDialogStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Style; PROCEDURE (this: PPDialog) Mode* (): PpDialogMode, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END Mode; PROCEDURE (this: PPDialog) PUTMode* (p1: PpDialogMode), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTMode; PROCEDURE (this: PPDialog) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END HelpId; PROCEDURE (this: PPDialog) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTHelpId; PROCEDURE (this: PPDialog) HideOnIdle* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END HideOnIdle; PROCEDURE (this: PPDialog) PUTHideOnIdle* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTHideOnIdle; PROCEDURE (this: PPDialog) resourceDLL* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END resourceDLL; PROCEDURE (this: PPDialog) PUTresourceDLL* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTresourceDLL; PROCEDURE (this: PPDialog) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2008) END Caption; PROCEDURE (this: PPDialog) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2008, p1) END PUTCaption; PROCEDURE (this: PPDialog) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2009) END Left; PROCEDURE (this: PPDialog) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2009, p1) END PUTLeft; PROCEDURE (this: PPDialog) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2010) END Top; PROCEDURE (this: PPDialog) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2010, p1) END PUTTop; PROCEDURE (this: PPDialog) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2011) END Width; PROCEDURE (this: PPDialog) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2011, p1) END PUTWidth; PROCEDURE (this: PPDialog) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2012) END Height; PROCEDURE (this: PPDialog) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2012, p1) END PUTHeight; PROCEDURE (this: PPDialog) ClientLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2013) END ClientLeft; PROCEDURE (this: PPDialog) ClientTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2014) END ClientTop; PROCEDURE (this: PPDialog) ClientWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2015) END ClientWidth; PROCEDURE (this: PPDialog) ClientHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2016) END ClientHeight; PROCEDURE (this: PPDialog) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2017) END Visible; PROCEDURE (this: PPDialog) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2017, p1) END PUTVisible; PROCEDURE (this: PPDialog) Controls* (): PPControls, NEW; BEGIN RETURN ThisPPControls(CtlC.GetAny(this, 2018)) END Controls; PROCEDURE (this: PPDialog) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2019)) END Tags; PROCEDURE (this: PPDialog) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2020) END Name; PROCEDURE (this: PPDialog) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2020, p1) END PUTName; PROCEDURE (this: PPDialog) Sheets* (): PPTabSheets, NEW; BEGIN RETURN ThisPPTabSheets(CtlC.GetAny(this, 2021)) END Sheets; PROCEDURE (this: PPDialog) TabControl* (): PPTabControl, NEW; BEGIN RETURN ThisPPTabControl(CtlC.GetAny(this, 2022)) END TabControl; PROCEDURE (this: PPDialog) DelayTime* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2023) END DelayTime; PROCEDURE (this: PPDialog) PUTDelayTime* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2023, p1) END PUTDelayTime; PROCEDURE (this: PPDialog) SaveDialog* (FileName: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 2024, arg, ret); RETURN CtlC.VarInt(ret) END SaveDialog; PROCEDURE (this: PPDialog) Terminate* (), NEW; BEGIN CtlC.CallMethod(this, 2025, NIL); END Terminate; PROCEDURE (this: PPDialog) OnTerminate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2027) END OnTerminate; PROCEDURE (this: PPDialog) PUTOnTerminate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2027, p1) END PUTOnTerminate; PROCEDURE (this: PPDialog) OnIdle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2028) END OnIdle; PROCEDURE (this: PPDialog) PUTOnIdle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2028, p1) END PUTOnIdle; PROCEDURE (this: PPDialog) OnMouseDown* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2029) END OnMouseDown; PROCEDURE (this: PPDialog) PUTOnMouseDown* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2029, p1) END PUTOnMouseDown; PROCEDURE (this: PPDialog) OnMouseUp* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2030) END OnMouseUp; PROCEDURE (this: PPDialog) PUTOnMouseUp* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2030, p1) END PUTOnMouseUp; PROCEDURE (this: PPDialog) OnKeyPressed* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2031) END OnKeyPressed; PROCEDURE (this: PPDialog) PUTOnKeyPressed* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2031, p1) END PUTOnKeyPressed; PROCEDURE (this: PPDialog) OnTimer* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2032) END OnTimer; PROCEDURE (this: PPDialog) PUTOnTimer* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2032, p1) END PUTOnTimer; PROCEDURE (this: PPDialog) OnActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2033) END OnActivate; PROCEDURE (this: PPDialog) PUTOnActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2033, p1) END PUTOnActivate; (* ---------- PPTabSheet, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPTabSheet) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PPTabSheet) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PPTabSheet) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END Name; PROCEDURE (this: PPTabSheet) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTName; PROCEDURE (this: PPTabSheet) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2004, NIL); END Select; PROCEDURE (this: PPTabSheet) ClientLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2005) END ClientLeft; PROCEDURE (this: PPTabSheet) ClientTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2006) END ClientTop; PROCEDURE (this: PPTabSheet) ClientWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2007) END ClientWidth; PROCEDURE (this: PPTabSheet) ClientHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2008) END ClientHeight; PROCEDURE (this: PPTabSheet) Controls* (): PPControls, NEW; BEGIN RETURN ThisPPControls(CtlC.GetAny(this, 2009)) END Controls; PROCEDURE (this: PPTabSheet) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 2010)) END Tags; PROCEDURE (this: PPTabSheet) OnActivate* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2011) END OnActivate; PROCEDURE (this: PPTabSheet) PUTOnActivate* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2011, p1) END PUTOnActivate; (* ---------- PPControls, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPControls) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PPControls) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PPControls) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PPControls) Item* (index: CtlT.Any): PPControl, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPPControl(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PPControls) AddPushButton* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPPushButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2002, arg, ret); RETURN ThisPPPushButton(CtlC.VarAny(ret)) END AddPushButton; PROCEDURE (this: PPControls) AddToggleButton* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPToggleButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisPPToggleButton(CtlC.VarAny(ret)) END AddToggleButton; PROCEDURE (this: PPControls) AddBitmapButton* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPBitmapButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2004, arg, ret); RETURN ThisPPBitmapButton(CtlC.VarAny(ret)) END AddBitmapButton; PROCEDURE (this: PPControls) AddListBox* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPListBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2005, arg, ret); RETURN ThisPPListBox(CtlC.VarAny(ret)) END AddListBox; PROCEDURE (this: PPControls) AddCheckBox* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPCheckBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2006, arg, ret); RETURN ThisPPCheckBox(CtlC.VarAny(ret)) END AddCheckBox; PROCEDURE (this: PPControls) AddRadioCluster* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPRadioCluster, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2007, arg, ret); RETURN ThisPPRadioCluster(CtlC.VarAny(ret)) END AddRadioCluster; PROCEDURE (this: PPControls) AddStaticText* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPStaticText, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2008, arg, ret); RETURN ThisPPStaticText(CtlC.VarAny(ret)) END AddStaticText; PROCEDURE (this: PPControls) AddEditText* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; (* optional *) VerticalScrollBar: CtlT.Any): PPEditText, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.AnyVar(VerticalScrollBar, arg[0]); CtlC.CallParMethod(this, 2009, arg, ret); RETURN ThisPPEditText(CtlC.VarAny(ret)) END AddEditText; PROCEDURE (this: PPControls) AddIcon* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPIcon, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2010, arg, ret); RETURN ThisPPIcon(CtlC.VarAny(ret)) END AddIcon; PROCEDURE (this: PPControls) AddBitmap* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPBitmap, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2011, arg, ret); RETURN ThisPPBitmap(CtlC.VarAny(ret)) END AddBitmap; PROCEDURE (this: PPControls) AddSpinner* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPSpinner, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2012, arg, ret); RETURN ThisPPSpinner(CtlC.VarAny(ret)) END AddSpinner; PROCEDURE (this: PPControls) AddScrollBar* (Style: PpScrollBarStyle; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPScrollBar, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[4]); CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2013, arg, ret); RETURN ThisPPScrollBar(CtlC.VarAny(ret)) END AddScrollBar; PROCEDURE (this: PPControls) AddGroupBox* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPGroupBox, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2014, arg, ret); RETURN ThisPPGroupBox(CtlC.VarAny(ret)) END AddGroupBox; PROCEDURE (this: PPControls) AddDropDown* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPDropDown, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2015, arg, ret); RETURN ThisPPDropDown(CtlC.VarAny(ret)) END AddDropDown; PROCEDURE (this: PPControls) AddDropDownEdit* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPDropDownEdit, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2016, arg, ret); RETURN ThisPPDropDownEdit(CtlC.VarAny(ret)) END AddDropDownEdit; PROCEDURE (this: PPControls) AddMiniature* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPSlideMiniature, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2017, arg, ret); RETURN ThisPPSlideMiniature(CtlC.VarAny(ret)) END AddMiniature; PROCEDURE (this: PPControls) AddFrame* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPFrame, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2018, arg, ret); RETURN ThisPPFrame(CtlC.VarAny(ret)) END AddFrame; PROCEDURE (this: PPControls) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2019) END Visible; PROCEDURE (this: PPControls) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2019, p1) END PUTVisible; (* ---------- PPTabSheets, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPTabSheets) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PPTabSheets) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PPTabSheets) Item* (index: CtlT.Any): PPTabSheet, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPPTabSheet(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PPTabSheets) Add* (Name: ARRAY OF CHAR): PPTabSheet, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 2001, arg, ret); RETURN ThisPPTabSheet(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PPTabSheets) ActiveSheet* (): PPTabSheet, NEW; BEGIN RETURN ThisPPTabSheet(CtlC.GetAny(this, 2002)) END ActiveSheet; PROCEDURE (this: PPTabSheets) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END Name; PROCEDURE (this: PPTabSheets) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTName; (* ---------- PPControl, hidden, dual ---------- *) PROCEDURE (this: PPControl) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPControl) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPControl) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPControl) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPControl) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPControl) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPControl) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPControl) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPControl) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPControl) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPControl) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPControl) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPControl) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPControl) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPControl) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPControl) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPControl) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPControl) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPControl) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPControl) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPControl) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPControl) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPControl) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPControl) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; (* ---------- PPPushButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPPushButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPPushButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPPushButton) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPPushButton) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPPushButton) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPPushButton) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPPushButton) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPPushButton) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPPushButton) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPPushButton) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPPushButton) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPPushButton) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPPushButton) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPPushButton) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPPushButton) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPPushButton) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPPushButton) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPPushButton) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPPushButton) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPPushButton) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPPushButton) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPPushButton) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPPushButton) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPPushButton) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPPushButton) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPPushButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPPushButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPPushButton) Click* (), NEW; BEGIN CtlC.CallMethod(this, 2001, NIL); END Click; PROCEDURE (this: PPPushButton) IsDefault* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END IsDefault; PROCEDURE (this: PPPushButton) PUTIsDefault* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTIsDefault; PROCEDURE (this: PPPushButton) IsEscape* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END IsEscape; PROCEDURE (this: PPPushButton) PUTIsEscape* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTIsEscape; PROCEDURE (this: PPPushButton) OnPressed* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnPressed; PROCEDURE (this: PPPushButton) PUTOnPressed* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnPressed; (* ---------- PPToggleButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPToggleButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPToggleButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPToggleButton) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPToggleButton) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPToggleButton) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPToggleButton) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPToggleButton) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPToggleButton) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPToggleButton) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPToggleButton) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPToggleButton) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPToggleButton) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPToggleButton) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPToggleButton) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPToggleButton) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPToggleButton) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPToggleButton) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPToggleButton) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPToggleButton) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPToggleButton) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPToggleButton) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPToggleButton) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPToggleButton) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPToggleButton) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPToggleButton) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPToggleButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPToggleButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPToggleButton) State* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END State; PROCEDURE (this: PPToggleButton) PUTState* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTState; PROCEDURE (this: PPToggleButton) ResourceID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END ResourceID; PROCEDURE (this: PPToggleButton) PUTResourceID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTResourceID; PROCEDURE (this: PPToggleButton) Click* (), NEW; BEGIN CtlC.CallMethod(this, 2003, NIL); END Click; PROCEDURE (this: PPToggleButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnClick; PROCEDURE (this: PPToggleButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnClick; (* ---------- PPBitmapButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPBitmapButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPBitmapButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPBitmapButton) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPBitmapButton) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPBitmapButton) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPBitmapButton) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPBitmapButton) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPBitmapButton) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPBitmapButton) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPBitmapButton) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPBitmapButton) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPBitmapButton) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPBitmapButton) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPBitmapButton) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPBitmapButton) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPBitmapButton) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPBitmapButton) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPBitmapButton) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPBitmapButton) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPBitmapButton) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPBitmapButton) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPBitmapButton) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPBitmapButton) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPBitmapButton) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPBitmapButton) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPBitmapButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPBitmapButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPBitmapButton) Click* (), NEW; BEGIN CtlC.CallMethod(this, 2001, NIL); END Click; PROCEDURE (this: PPBitmapButton) ResourceID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END ResourceID; PROCEDURE (this: PPBitmapButton) PUTResourceID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTResourceID; PROCEDURE (this: PPBitmapButton) OnPressed* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END OnPressed; PROCEDURE (this: PPBitmapButton) PUTOnPressed* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTOnPressed; PROCEDURE (this: PPBitmapButton) IsDefault* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END IsDefault; PROCEDURE (this: PPBitmapButton) PUTIsDefault* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTIsDefault; PROCEDURE (this: PPBitmapButton) IsEscape* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END IsEscape; PROCEDURE (this: PPBitmapButton) PUTIsEscape* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTIsEscape; (* ---------- PPListBox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPListBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPListBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPListBox) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPListBox) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPListBox) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPListBox) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPListBox) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPListBox) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPListBox) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPListBox) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPListBox) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPListBox) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPListBox) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPListBox) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPListBox) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPListBox) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPListBox) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPListBox) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPListBox) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPListBox) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPListBox) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPListBox) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPListBox) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPListBox) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPListBox) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPListBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPListBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPListBox) Strings* (): PPStrings, NEW; BEGIN RETURN ThisPPStrings(CtlC.GetAny(this, 2001)) END Strings; PROCEDURE (this: PPListBox) SelectionStyle* (): PpListBoxSelectionStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END SelectionStyle; PROCEDURE (this: PPListBox) PUTSelectionStyle* (p1: PpListBoxSelectionStyle), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTSelectionStyle; PROCEDURE (this: PPListBox) SetTabStops* (safeArrayTabStops: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(safeArrayTabStops, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END SetTabStops; PROCEDURE (this: PPListBox) FocusItem* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END FocusItem; PROCEDURE (this: PPListBox) PUTFocusItem* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTFocusItem; PROCEDURE (this: PPListBox) TopItem* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END TopItem; PROCEDURE (this: PPListBox) OnSelectionChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2006) END OnSelectionChange; PROCEDURE (this: PPListBox) PUTOnSelectionChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2006, p1) END PUTOnSelectionChange; PROCEDURE (this: PPListBox) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END OnDoubleClick; PROCEDURE (this: PPListBox) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTOnDoubleClick; PROCEDURE (this: PPListBox) IsSelected* (index: INTEGER): CtlOffice.MsoTriState, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallGetMethod(this, 999, arg, ret); RETURN CtlC.VarInt(ret) END IsSelected; PROCEDURE (this: PPListBox) PUTIsSelected* (index: INTEGER; p2: CtlOffice.MsoTriState), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[1]); CtlC.IntVar(p2, arg[0]); CtlC.CallPutMethod(this, 999, arg, NIL); END PUTIsSelected; PROCEDURE (this: PPListBox) Abbreviate* (Style: PpListBoxAbbreviationStyle), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[0]); CtlC.CallParMethod(this, 2008, arg, NIL); END Abbreviate; PROCEDURE (this: PPListBox) IsAbbreviated* (): PpListBoxAbbreviationStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END IsAbbreviated; (* ---------- PPStrings, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPStrings) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PPStrings) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PPStrings) Item* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: PPStrings) Add* (String: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 2001, arg, ret); RETURN CtlC.VarStr(ret) END Add; PROCEDURE (this: PPStrings) Insert* (String: ARRAY OF CHAR; Position: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(String, arg[1]); CtlC.IntVar(Position, arg[0]); CtlC.CallParMethod(this, 2002, arg, NIL); END Insert; PROCEDURE (this: PPStrings) Delete* (index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Delete; (* ---------- PPCheckBox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPCheckBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPCheckBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPCheckBox) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPCheckBox) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPCheckBox) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPCheckBox) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPCheckBox) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPCheckBox) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPCheckBox) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPCheckBox) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPCheckBox) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPCheckBox) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPCheckBox) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPCheckBox) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPCheckBox) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPCheckBox) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPCheckBox) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPCheckBox) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPCheckBox) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPCheckBox) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPCheckBox) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPCheckBox) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPCheckBox) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPCheckBox) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPCheckBox) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPCheckBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPCheckBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPCheckBox) State* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END State; PROCEDURE (this: PPCheckBox) PUTState* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTState; PROCEDURE (this: PPCheckBox) Click* (), NEW; BEGIN CtlC.CallMethod(this, 2002, NIL); END Click; PROCEDURE (this: PPCheckBox) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END OnClick; PROCEDURE (this: PPCheckBox) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTOnClick; (* ---------- PPRadioCluster, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPRadioCluster) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPRadioCluster) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPRadioCluster) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPRadioCluster) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPRadioCluster) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPRadioCluster) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPRadioCluster) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPRadioCluster) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPRadioCluster) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPRadioCluster) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPRadioCluster) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPRadioCluster) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPRadioCluster) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPRadioCluster) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPRadioCluster) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPRadioCluster) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPRadioCluster) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPRadioCluster) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPRadioCluster) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPRadioCluster) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPRadioCluster) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPRadioCluster) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPRadioCluster) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPRadioCluster) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPRadioCluster) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPRadioCluster) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPRadioCluster) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPRadioCluster) Item* (index: CtlT.Any): PPRadioButton, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPPRadioButton(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PPRadioCluster) Add* (Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL): PPRadioButton, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Left, arg[3]); CtlC.SRealVar(Top, arg[2]); CtlC.SRealVar(Width, arg[1]); CtlC.SRealVar(Height, arg[0]); CtlC.CallParMethod(this, 2001, arg, ret); RETURN ThisPPRadioButton(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PPRadioCluster) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Count; PROCEDURE (this: PPRadioCluster) Selected* (): PPRadioButton, NEW; BEGIN RETURN ThisPPRadioButton(CtlC.GetAny(this, 2003)) END Selected; PROCEDURE (this: PPRadioCluster) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnClick; PROCEDURE (this: PPRadioCluster) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnClick; (* ---------- PPStaticText, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPStaticText) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPStaticText) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPStaticText) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPStaticText) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPStaticText) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPStaticText) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPStaticText) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPStaticText) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPStaticText) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPStaticText) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPStaticText) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPStaticText) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPStaticText) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPStaticText) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPStaticText) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPStaticText) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPStaticText) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPStaticText) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPStaticText) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPStaticText) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPStaticText) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPStaticText) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPStaticText) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPStaticText) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPStaticText) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPStaticText) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPStaticText) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPStaticText) UseForegroundColor* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END UseForegroundColor; PROCEDURE (this: PPStaticText) PUTUseForegroundColor* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTUseForegroundColor; PROCEDURE (this: PPStaticText) UseBackgroundColor* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END UseBackgroundColor; PROCEDURE (this: PPStaticText) PUTUseBackgroundColor* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTUseBackgroundColor; PROCEDURE (this: PPStaticText) ForegroundColor* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END ForegroundColor; PROCEDURE (this: PPStaticText) PUTForegroundColor* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTForegroundColor; PROCEDURE (this: PPStaticText) BackgroundColor* (): CtlOffice.MsoRGBType, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END BackgroundColor; PROCEDURE (this: PPStaticText) PUTBackgroundColor* (p1: CtlOffice.MsoRGBType), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTBackgroundColor; (* ---------- PPEditText, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPEditText) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPEditText) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPEditText) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPEditText) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPEditText) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPEditText) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPEditText) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPEditText) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPEditText) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPEditText) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPEditText) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPEditText) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPEditText) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPEditText) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPEditText) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPEditText) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPEditText) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPEditText) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPEditText) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPEditText) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPEditText) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPEditText) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPEditText) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPEditText) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPEditText) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPEditText) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPEditText) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPEditText) MultiLine* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END MultiLine; PROCEDURE (this: PPEditText) PUTMultiLine* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTMultiLine; PROCEDURE (this: PPEditText) VerticalScrollBar* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END VerticalScrollBar; PROCEDURE (this: PPEditText) PUTVerticalScrollBar* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTVerticalScrollBar; PROCEDURE (this: PPEditText) WordWrap* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END WordWrap; PROCEDURE (this: PPEditText) PUTWordWrap* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTWordWrap; PROCEDURE (this: PPEditText) ReadOnly* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END ReadOnly; PROCEDURE (this: PPEditText) PUTReadOnly* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTReadOnly; PROCEDURE (this: PPEditText) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END Text; PROCEDURE (this: PPEditText) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2005, p1) END PUTText; PROCEDURE (this: PPEditText) MaxLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END MaxLength; PROCEDURE (this: PPEditText) PUTMaxLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTMaxLength; PROCEDURE (this: PPEditText) OnAChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END OnAChange; PROCEDURE (this: PPEditText) PUTOnAChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTOnAChange; (* ---------- PPIcon, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPIcon) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPIcon) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPIcon) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPIcon) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPIcon) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPIcon) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPIcon) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPIcon) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPIcon) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPIcon) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPIcon) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPIcon) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPIcon) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPIcon) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPIcon) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPIcon) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPIcon) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPIcon) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPIcon) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPIcon) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPIcon) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPIcon) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPIcon) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPIcon) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPIcon) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPIcon) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPIcon) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPIcon) ResourceID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END ResourceID; PROCEDURE (this: PPIcon) PUTResourceID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTResourceID; (* ---------- PPBitmap, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPBitmap) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPBitmap) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPBitmap) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPBitmap) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPBitmap) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPBitmap) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPBitmap) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPBitmap) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPBitmap) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPBitmap) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPBitmap) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPBitmap) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPBitmap) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPBitmap) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPBitmap) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPBitmap) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPBitmap) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPBitmap) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPBitmap) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPBitmap) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPBitmap) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPBitmap) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPBitmap) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPBitmap) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPBitmap) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPBitmap) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPBitmap) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPBitmap) ResourceID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2000) END ResourceID; PROCEDURE (this: PPBitmap) PUTResourceID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2000, p1) END PUTResourceID; PROCEDURE (this: PPBitmap) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2001) END OnClick; PROCEDURE (this: PPBitmap) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2001, p1) END PUTOnClick; (* ---------- PPSpinner, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPSpinner) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPSpinner) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPSpinner) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPSpinner) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPSpinner) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPSpinner) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPSpinner) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPSpinner) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPSpinner) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPSpinner) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPSpinner) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPSpinner) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPSpinner) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPSpinner) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPSpinner) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPSpinner) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPSpinner) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPSpinner) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPSpinner) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPSpinner) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPSpinner) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPSpinner) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPSpinner) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPSpinner) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPSpinner) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPSpinner) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPSpinner) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPSpinner) Minimum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Minimum; PROCEDURE (this: PPSpinner) PUTMinimum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTMinimum; PROCEDURE (this: PPSpinner) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Maximum; PROCEDURE (this: PPSpinner) PUTMaximum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTMaximum; PROCEDURE (this: PPSpinner) Increment* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Increment; PROCEDURE (this: PPSpinner) PUTIncrement* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTIncrement; PROCEDURE (this: PPSpinner) PageChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END PageChange; PROCEDURE (this: PPSpinner) PUTPageChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTPageChange; PROCEDURE (this: PPSpinner) CurrentValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END CurrentValue; PROCEDURE (this: PPSpinner) PUTCurrentValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTCurrentValue; PROCEDURE (this: PPSpinner) OnAChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2006) END OnAChange; PROCEDURE (this: PPSpinner) PUTOnAChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2006, p1) END PUTOnAChange; (* ---------- PPScrollBar, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPScrollBar) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPScrollBar) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPScrollBar) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPScrollBar) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPScrollBar) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPScrollBar) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPScrollBar) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPScrollBar) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPScrollBar) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPScrollBar) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPScrollBar) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPScrollBar) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPScrollBar) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPScrollBar) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPScrollBar) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPScrollBar) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPScrollBar) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPScrollBar) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPScrollBar) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPScrollBar) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPScrollBar) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPScrollBar) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPScrollBar) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPScrollBar) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPScrollBar) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPScrollBar) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPScrollBar) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPScrollBar) Minimum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END Minimum; PROCEDURE (this: PPScrollBar) PUTMinimum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTMinimum; PROCEDURE (this: PPScrollBar) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Maximum; PROCEDURE (this: PPScrollBar) PUTMaximum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTMaximum; PROCEDURE (this: PPScrollBar) Increment* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END Increment; PROCEDURE (this: PPScrollBar) PUTIncrement* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTIncrement; PROCEDURE (this: PPScrollBar) PageChange* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END PageChange; PROCEDURE (this: PPScrollBar) PUTPageChange* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTPageChange; PROCEDURE (this: PPScrollBar) CurrentValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END CurrentValue; PROCEDURE (this: PPScrollBar) PUTCurrentValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTCurrentValue; PROCEDURE (this: PPScrollBar) OnScroll* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2006) END OnScroll; PROCEDURE (this: PPScrollBar) PUTOnScroll* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2006, p1) END PUTOnScroll; (* ---------- PPGroupBox, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPGroupBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPGroupBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPGroupBox) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPGroupBox) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPGroupBox) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPGroupBox) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPGroupBox) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPGroupBox) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPGroupBox) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPGroupBox) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPGroupBox) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPGroupBox) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPGroupBox) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPGroupBox) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPGroupBox) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPGroupBox) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPGroupBox) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPGroupBox) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPGroupBox) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPGroupBox) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPGroupBox) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPGroupBox) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPGroupBox) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPGroupBox) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPGroupBox) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPGroupBox) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPGroupBox) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; (* ---------- PPFrame, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPFrame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPFrame) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPFrame) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPFrame) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPFrame) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPFrame) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPFrame) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPFrame) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPFrame) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPFrame) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPFrame) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPFrame) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPFrame) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPFrame) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPFrame) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPFrame) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPFrame) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPFrame) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPFrame) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPFrame) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPFrame) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPFrame) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPFrame) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPFrame) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPFrame) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPFrame) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; (* ---------- PPTabControl, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPTabControl) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPTabControl) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPTabControl) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPTabControl) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPTabControl) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPTabControl) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPTabControl) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPTabControl) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPTabControl) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPTabControl) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPTabControl) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPTabControl) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPTabControl) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPTabControl) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPTabControl) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPTabControl) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPTabControl) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPTabControl) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPTabControl) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPTabControl) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPTabControl) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPTabControl) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPTabControl) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPTabControl) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPTabControl) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPTabControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPTabControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; (* ---------- PPDropDown, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPDropDown) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPDropDown) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPDropDown) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPDropDown) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPDropDown) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPDropDown) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPDropDown) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPDropDown) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPDropDown) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPDropDown) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPDropDown) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPDropDown) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPDropDown) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPDropDown) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPDropDown) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPDropDown) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPDropDown) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPDropDown) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPDropDown) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPDropDown) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPDropDown) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPDropDown) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPDropDown) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPDropDown) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPDropDown) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPDropDown) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPDropDown) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPDropDown) Strings* (): PPStrings, NEW; BEGIN RETURN ThisPPStrings(CtlC.GetAny(this, 2001)) END Strings; PROCEDURE (this: PPDropDown) FocusItem* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END FocusItem; PROCEDURE (this: PPDropDown) PUTFocusItem* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTFocusItem; PROCEDURE (this: PPDropDown) OnSelectionChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END OnSelectionChange; PROCEDURE (this: PPDropDown) PUTOnSelectionChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTOnSelectionChange; (* ---------- PPDropDownEdit, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPDropDownEdit) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPDropDownEdit) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPDropDownEdit) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPDropDownEdit) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPDropDownEdit) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPDropDownEdit) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPDropDownEdit) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPDropDownEdit) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPDropDownEdit) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPDropDownEdit) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPDropDownEdit) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPDropDownEdit) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPDropDownEdit) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPDropDownEdit) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPDropDownEdit) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPDropDownEdit) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPDropDownEdit) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPDropDownEdit) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPDropDownEdit) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPDropDownEdit) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPDropDownEdit) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPDropDownEdit) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPDropDownEdit) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPDropDownEdit) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPDropDownEdit) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPDropDownEdit) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPDropDownEdit) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPDropDownEdit) Strings* (): PPStrings, NEW; BEGIN RETURN ThisPPStrings(CtlC.GetAny(this, 2001)) END Strings; PROCEDURE (this: PPDropDownEdit) FocusItem* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END FocusItem; PROCEDURE (this: PPDropDownEdit) PUTFocusItem* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTFocusItem; PROCEDURE (this: PPDropDownEdit) OnSelectionChange* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END OnSelectionChange; PROCEDURE (this: PPDropDownEdit) PUTOnSelectionChange* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTOnSelectionChange; PROCEDURE (this: PPDropDownEdit) OnEdit* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnEdit; PROCEDURE (this: PPDropDownEdit) PUTOnEdit* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnEdit; (* ---------- PPSlideMiniature, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPSlideMiniature) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPSlideMiniature) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPSlideMiniature) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPSlideMiniature) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPSlideMiniature) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPSlideMiniature) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPSlideMiniature) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPSlideMiniature) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPSlideMiniature) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPSlideMiniature) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPSlideMiniature) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPSlideMiniature) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPSlideMiniature) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPSlideMiniature) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPSlideMiniature) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPSlideMiniature) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPSlideMiniature) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPSlideMiniature) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPSlideMiniature) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPSlideMiniature) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPSlideMiniature) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPSlideMiniature) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPSlideMiniature) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPSlideMiniature) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPSlideMiniature) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPSlideMiniature) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPSlideMiniature) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPSlideMiniature) SetImage* (slide: Slide), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(slide, arg[0]); CtlC.CallParMethod(this, 2001, arg, NIL); END SetImage; PROCEDURE (this: PPSlideMiniature) Selected* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Selected; PROCEDURE (this: PPSlideMiniature) PUTSelected* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTSelected; PROCEDURE (this: PPSlideMiniature) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END OnClick; PROCEDURE (this: PPSlideMiniature) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTOnClick; PROCEDURE (this: PPSlideMiniature) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnDoubleClick; PROCEDURE (this: PPSlideMiniature) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnDoubleClick; (* ---------- PPRadioButton, hidden, dual, nonextensible ---------- *) PROCEDURE (this: PPRadioButton) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1001)) END Application; PROCEDURE (this: PPRadioButton) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PPRadioButton) Enable* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1003) END Enable; PROCEDURE (this: PPRadioButton) PUTEnable* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1003, p1) END PUTEnable; PROCEDURE (this: PPRadioButton) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1004) END Visible; PROCEDURE (this: PPRadioButton) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1004, p1) END PUTVisible; PROCEDURE (this: PPRadioButton) Focus* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Focus; PROCEDURE (this: PPRadioButton) PUTFocus* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTFocus; PROCEDURE (this: PPRadioButton) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1006) END Label; PROCEDURE (this: PPRadioButton) PUTLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1006, p1) END PUTLabel; PROCEDURE (this: PPRadioButton) HelpId* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1007) END HelpId; PROCEDURE (this: PPRadioButton) PUTHelpId* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1007, p1) END PUTHelpId; PROCEDURE (this: PPRadioButton) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END Left; PROCEDURE (this: PPRadioButton) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTLeft; PROCEDURE (this: PPRadioButton) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1009) END Top; PROCEDURE (this: PPRadioButton) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1009, p1) END PUTTop; PROCEDURE (this: PPRadioButton) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1010) END Width; PROCEDURE (this: PPRadioButton) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1010, p1) END PUTWidth; PROCEDURE (this: PPRadioButton) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1011) END Height; PROCEDURE (this: PPRadioButton) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1011, p1) END PUTHeight; PROCEDURE (this: PPRadioButton) OnSetFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END OnSetFocus; PROCEDURE (this: PPRadioButton) PUTOnSetFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTOnSetFocus; PROCEDURE (this: PPRadioButton) OnKillFocus* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1014) END OnKillFocus; PROCEDURE (this: PPRadioButton) PUTOnKillFocus* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1014, p1) END PUTOnKillFocus; PROCEDURE (this: PPRadioButton) Tags* (): Tags, NEW; BEGIN RETURN ThisTags(CtlC.GetAny(this, 1015)) END Tags; PROCEDURE (this: PPRadioButton) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1016) END Name; PROCEDURE (this: PPRadioButton) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1016, p1) END PUTName; PROCEDURE (this: PPRadioButton) State* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END State; PROCEDURE (this: PPRadioButton) PUTState* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTState; PROCEDURE (this: PPRadioButton) Click* (), NEW; BEGIN CtlC.CallMethod(this, 2002, NIL); END Click; PROCEDURE (this: PPRadioButton) DoubleClick* (), NEW; BEGIN CtlC.CallMethod(this, 2003, NIL); END DoubleClick; PROCEDURE (this: PPRadioButton) OnClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END OnClick; PROCEDURE (this: PPRadioButton) PUTOnClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTOnClick; PROCEDURE (this: PPRadioButton) OnDoubleClick* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END OnDoubleClick; PROCEDURE (this: PPRadioButton) PUTOnDoubleClick* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2005, p1) END PUTOnDoubleClick; (* ---------- Tags, dual, nonextensible ---------- *) PROCEDURE (this: Tags) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Tags) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Tags) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Tags) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Tags) Item* (Name: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: Tags) Add* (Name: ARRAY OF CHAR; Value: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(Value, arg[0]); CtlC.CallParMethod(this, 2003, arg, NIL); END Add; PROCEDURE (this: Tags) Delete* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 2004, arg, NIL); END Delete; PROCEDURE (this: Tags) AddBinary* (Name: ARRAY OF CHAR; FilePath: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(FilePath, arg[0]); CtlC.CallParMethod(this, 2005, arg, NIL); END AddBinary; PROCEDURE (this: Tags) BinaryValue* (Name: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 2006, arg, ret); RETURN CtlC.VarInt(ret) END BinaryValue; PROCEDURE (this: Tags) Name* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2007, arg, ret); RETURN CtlC.VarStr(ret) END Name; PROCEDURE (this: Tags) Value* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2008, arg, ret); RETURN CtlC.VarStr(ret) END Value; (* ---------- FileDialogFileList, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FileDialogFileList) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FileDialogFileList) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: FileDialogFileList) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: FileDialogFileList) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: FileDialogFileList) Item* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; PROCEDURE (this: FileDialogFileList) DisplayName* (index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN CtlC.VarStr(ret) END DisplayName; (* ---------- FileDialogExtension, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FileDialogExtension) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: FileDialogExtension) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: FileDialogExtension) Extensions* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2003) END Extensions; PROCEDURE (this: FileDialogExtension) PUTExtensions* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2003, p1) END PUTExtensions; PROCEDURE (this: FileDialogExtension) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END Description; PROCEDURE (this: FileDialogExtension) PUTDescription* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTDescription; (* ---------- FileDialogExtensionList, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FileDialogExtensionList) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FileDialogExtensionList) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: FileDialogExtensionList) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: FileDialogExtensionList) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: FileDialogExtensionList) Item* (index: INTEGER): FileDialogExtension, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFileDialogExtension(CtlC.VarAny(ret)) END Item; PROCEDURE (this: FileDialogExtensionList) Add* (Extension: ARRAY OF CHAR; Description: ARRAY OF CHAR): FileDialogExtension, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Extension, arg[1]); CtlC.StrVar(Description, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisFileDialogExtension(CtlC.VarAny(ret)) END Add; (* ---------- FileDialog, hidden, dual, nonextensible ---------- *) PROCEDURE (this: FileDialog) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: FileDialog) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: FileDialog) Extensions* (): FileDialogExtensionList, NEW; BEGIN RETURN ThisFileDialogExtensionList(CtlC.GetAny(this, 2003)) END Extensions; PROCEDURE (this: FileDialog) DefaultDirectoryRegKey* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2004) END DefaultDirectoryRegKey; PROCEDURE (this: FileDialog) PUTDefaultDirectoryRegKey* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2004, p1) END PUTDefaultDirectoryRegKey; PROCEDURE (this: FileDialog) DialogTitle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2005) END DialogTitle; PROCEDURE (this: FileDialog) PUTDialogTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2005, p1) END PUTDialogTitle; PROCEDURE (this: FileDialog) ActionButtonName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2006) END ActionButtonName; PROCEDURE (this: FileDialog) PUTActionButtonName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2006, p1) END PUTActionButtonName; PROCEDURE (this: FileDialog) IsMultiSelect* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END IsMultiSelect; PROCEDURE (this: FileDialog) PUTIsMultiSelect* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTIsMultiSelect; PROCEDURE (this: FileDialog) IsPrintEnabled* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END IsPrintEnabled; PROCEDURE (this: FileDialog) PUTIsPrintEnabled* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTIsPrintEnabled; PROCEDURE (this: FileDialog) IsReadOnlyEnabled* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END IsReadOnlyEnabled; PROCEDURE (this: FileDialog) PUTIsReadOnlyEnabled* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTIsReadOnlyEnabled; PROCEDURE (this: FileDialog) DirectoriesOnly* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END DirectoriesOnly; PROCEDURE (this: FileDialog) PUTDirectoriesOnly* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTDirectoriesOnly; PROCEDURE (this: FileDialog) InitialView* (): PpFileDialogView, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END InitialView; PROCEDURE (this: FileDialog) PUTInitialView* (p1: PpFileDialogView), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTInitialView; PROCEDURE (this: FileDialog) Launch* (pUnk: CtlT.IUnknown), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntfceVar(pUnk, arg[0]); CtlC.CallParMethod(this, 2012, arg, NIL); END Launch; PROCEDURE (this: FileDialog) OnAction* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2013) END OnAction; PROCEDURE (this: FileDialog) PUTOnAction* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2013, p1) END PUTOnAction; PROCEDURE (this: FileDialog) Files* (): FileDialogFileList, NEW; BEGIN RETURN ThisFileDialogFileList(CtlC.GetAny(this, 2014)) END Files; PROCEDURE (this: FileDialog) UseODMADlgs* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2015) END UseODMADlgs; PROCEDURE (this: FileDialog) PUTUseODMADlgs* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2015, p1) END PUTUseODMADlgs; (* ---------- OCXExtender, hidden, dual, nonextensible ---------- *) PROCEDURE (this: OCXExtender) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, -2147418105) END Visible; PROCEDURE (this: OCXExtender) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, -2147418105, p1) END PUTVisible; PROCEDURE (this: OCXExtender) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418109) END Left; PROCEDURE (this: OCXExtender) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418109, p1) END PUTLeft; PROCEDURE (this: OCXExtender) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418108) END Top; PROCEDURE (this: OCXExtender) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418108, p1) END PUTTop; PROCEDURE (this: OCXExtender) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418107) END Height; PROCEDURE (this: OCXExtender) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418107, p1) END PUTHeight; PROCEDURE (this: OCXExtender) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147418106) END Width; PROCEDURE (this: OCXExtender) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147418106, p1) END PUTWidth; PROCEDURE (this: OCXExtender) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, -2147417882) END ZOrderPosition; PROCEDURE (this: OCXExtender) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: OCXExtender) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: OCXExtender) AltHTML* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147417881) END AltHTML; PROCEDURE (this: OCXExtender) PUTAltHTML* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147417881, p1) END PUTAltHTML; (* ---------- Table, dual, nonextensible ---------- *) PROCEDURE (this: Table) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Table) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Table) Columns* (): Columns, NEW; BEGIN RETURN ThisColumns(CtlC.GetAny(this, 2003)) END Columns; PROCEDURE (this: Table) Rows* (): Rows, NEW; BEGIN RETURN ThisRows(CtlC.GetAny(this, 2004)) END Rows; PROCEDURE (this: Table) Cell* (Row: INTEGER; Column: INTEGER): Cell, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Row, arg[1]); CtlC.IntVar(Column, arg[0]); CtlC.CallParMethod(this, 2005, arg, ret); RETURN ThisCell(CtlC.VarAny(ret)) END Cell; PROCEDURE (this: Table) TableDirection* (): PpDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END TableDirection; PROCEDURE (this: Table) PUTTableDirection* (p1: PpDirection), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTTableDirection; PROCEDURE (this: Table) MergeBorders* (), NEW; BEGIN CtlC.CallMethod(this, 2007, NIL); END MergeBorders; (* ---------- Columns, dual, nonextensible ---------- *) PROCEDURE (this: Columns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Columns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Columns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Columns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Columns) Item* (index: INTEGER): Column, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisColumn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Columns) Add* (BeforeColumn: INTEGER): Column, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(BeforeColumn, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisColumn(CtlC.VarAny(ret)) END Add; (* ---------- Column, dual, nonextensible ---------- *) PROCEDURE (this: Column) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Column) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Column) Cells* (): CellRange, NEW; BEGIN RETURN ThisCellRange(CtlC.GetAny(this, 2003)) END Cells; PROCEDURE (this: Column) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2004, NIL); END Select; PROCEDURE (this: Column) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Delete; PROCEDURE (this: Column) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2006) END Width; PROCEDURE (this: Column) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2006, p1) END PUTWidth; (* ---------- Rows, dual, nonextensible ---------- *) PROCEDURE (this: Rows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Rows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Rows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Rows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Rows) Item* (index: INTEGER): Row, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Rows) Add* (BeforeRow: INTEGER): Row, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(BeforeRow, arg[0]); CtlC.CallParMethod(this, 2003, arg, ret); RETURN ThisRow(CtlC.VarAny(ret)) END Add; (* ---------- Row, dual, nonextensible ---------- *) PROCEDURE (this: Row) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Row) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Row) Cells* (): CellRange, NEW; BEGIN RETURN ThisCellRange(CtlC.GetAny(this, 2003)) END Cells; PROCEDURE (this: Row) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2004, NIL); END Select; PROCEDURE (this: Row) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 2005, NIL); END Delete; PROCEDURE (this: Row) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2006) END Height; PROCEDURE (this: Row) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2006, p1) END PUTHeight; (* ---------- CellRange, dual, nonextensible ---------- *) PROCEDURE (this: CellRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: CellRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: CellRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: CellRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: CellRange) Item* (index: INTEGER): Cell, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisCell(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CellRange) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 2003)) END Borders; (* ---------- Cell, dual, nonextensible ---------- *) PROCEDURE (this: Cell) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Cell) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Cell) Shape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 2003)) END Shape; PROCEDURE (this: Cell) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 2004)) END Borders; PROCEDURE (this: Cell) Merge* (MergeTo: Cell), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(MergeTo, arg[0]); CtlC.CallParMethod(this, 2005, arg, NIL); END Merge; PROCEDURE (this: Cell) Split* (NumRows: INTEGER; NumColumns: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(NumRows, arg[1]); CtlC.IntVar(NumColumns, arg[0]); CtlC.CallParMethod(this, 2006, arg, NIL); END Split; PROCEDURE (this: Cell) Select* (), NEW; BEGIN CtlC.CallMethod(this, 2007, NIL); END Select; PROCEDURE (this: Cell) Selected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2008) END Selected; (* ---------- Borders, dual, nonextensible ---------- *) PROCEDURE (this: Borders) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Borders) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Borders) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Borders) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: Borders) Item* (BorderType: PpBorderType): LineFormat, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(BorderType, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisLineFormat(CtlC.VarAny(ret)) END Item; (* ---------- Panes, dual, nonextensible ---------- *) PROCEDURE (this: Panes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Panes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: Panes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: Panes) Item* (index: INTEGER): Pane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPane(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Panes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; (* ---------- Pane, dual, nonextensible ---------- *) PROCEDURE (this: Pane) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2000) END Parent; PROCEDURE (this: Pane) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 2001, NIL); END Activate; PROCEDURE (this: Pane) Active* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Active; PROCEDURE (this: Pane) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2003)) END Application; PROCEDURE (this: Pane) ViewType* (): PpViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END ViewType; (* ---------- DefaultWebOptions, dual, nonextensible ---------- *) PROCEDURE (this: DefaultWebOptions) IncludeNavigation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END IncludeNavigation; PROCEDURE (this: DefaultWebOptions) PUTIncludeNavigation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTIncludeNavigation; PROCEDURE (this: DefaultWebOptions) FrameColors* (): PpFrameColors, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END FrameColors; PROCEDURE (this: DefaultWebOptions) PUTFrameColors* (p1: PpFrameColors), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTFrameColors; PROCEDURE (this: DefaultWebOptions) ResizeGraphics* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END ResizeGraphics; PROCEDURE (this: DefaultWebOptions) PUTResizeGraphics* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTResizeGraphics; PROCEDURE (this: DefaultWebOptions) ShowSlideAnimation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END ShowSlideAnimation; PROCEDURE (this: DefaultWebOptions) PUTShowSlideAnimation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTShowSlideAnimation; PROCEDURE (this: DefaultWebOptions) OrganizeInFolder* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END OrganizeInFolder; PROCEDURE (this: DefaultWebOptions) PUTOrganizeInFolder* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTOrganizeInFolder; PROCEDURE (this: DefaultWebOptions) UseLongFileNames* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END UseLongFileNames; PROCEDURE (this: DefaultWebOptions) PUTUseLongFileNames* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTUseLongFileNames; PROCEDURE (this: DefaultWebOptions) RelyOnVML* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END RelyOnVML; PROCEDURE (this: DefaultWebOptions) PUTRelyOnVML* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTRelyOnVML; PROCEDURE (this: DefaultWebOptions) AllowPNG* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END AllowPNG; PROCEDURE (this: DefaultWebOptions) PUTAllowPNG* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTAllowPNG; PROCEDURE (this: DefaultWebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END ScreenSize; PROCEDURE (this: DefaultWebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTScreenSize; PROCEDURE (this: DefaultWebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END Encoding; PROCEDURE (this: DefaultWebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTEncoding; PROCEDURE (this: DefaultWebOptions) UpdateLinksOnSave* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2011) END UpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) PUTUpdateLinksOnSave* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2011, p1) END PUTUpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) CheckIfOfficeIsHTMLEditor* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2012) END CheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) PUTCheckIfOfficeIsHTMLEditor* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2012, p1) END PUTCheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) AlwaysSaveInDefaultEncoding* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2013) END AlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) PUTAlwaysSaveInDefaultEncoding* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2013, p1) END PUTAlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) Fonts* (): CtlOffice.WebPageFonts, NEW; BEGIN RETURN CtlOffice.ThisWebPageFonts(CtlC.GetAny(this, 2014)) END Fonts; PROCEDURE (this: DefaultWebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2015) END FolderSuffix; (* ---------- WebOptions, dual, nonextensible ---------- *) PROCEDURE (this: WebOptions) IncludeNavigation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END IncludeNavigation; PROCEDURE (this: WebOptions) PUTIncludeNavigation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTIncludeNavigation; PROCEDURE (this: WebOptions) FrameColors* (): PpFrameColors, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END FrameColors; PROCEDURE (this: WebOptions) PUTFrameColors* (p1: PpFrameColors), NEW; BEGIN CtlC.PutInt(this, 2002, p1) END PUTFrameColors; PROCEDURE (this: WebOptions) ResizeGraphics* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END ResizeGraphics; PROCEDURE (this: WebOptions) PUTResizeGraphics* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTResizeGraphics; PROCEDURE (this: WebOptions) ShowSlideAnimation* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END ShowSlideAnimation; PROCEDURE (this: WebOptions) PUTShowSlideAnimation* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTShowSlideAnimation; PROCEDURE (this: WebOptions) OrganizeInFolder* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END OrganizeInFolder; PROCEDURE (this: WebOptions) PUTOrganizeInFolder* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTOrganizeInFolder; PROCEDURE (this: WebOptions) UseLongFileNames* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END UseLongFileNames; PROCEDURE (this: WebOptions) PUTUseLongFileNames* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTUseLongFileNames; PROCEDURE (this: WebOptions) RelyOnVML* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2007) END RelyOnVML; PROCEDURE (this: WebOptions) PUTRelyOnVML* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2007, p1) END PUTRelyOnVML; PROCEDURE (this: WebOptions) AllowPNG* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END AllowPNG; PROCEDURE (this: WebOptions) PUTAllowPNG* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTAllowPNG; PROCEDURE (this: WebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 2009) END ScreenSize; PROCEDURE (this: WebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 2009, p1) END PUTScreenSize; PROCEDURE (this: WebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 2010) END Encoding; PROCEDURE (this: WebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 2010, p1) END PUTEncoding; PROCEDURE (this: WebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2011) END FolderSuffix; PROCEDURE (this: WebOptions) UseDefaultFolderSuffix* (), NEW; BEGIN CtlC.CallMethod(this, 2012, NIL); END UseDefaultFolderSuffix; (* ---------- PublishObjects, dual, nonextensible ---------- *) PROCEDURE (this: PublishObjects) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PublishObjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END Count; PROCEDURE (this: PublishObjects) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PublishObjects) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PublishObjects) Item* (index: INTEGER): PublishObject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPublishObject(CtlC.VarAny(ret)) END Item; (* ---------- PublishObject, dual, nonextensible ---------- *) PROCEDURE (this: PublishObject) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 2001)) END Application; PROCEDURE (this: PublishObject) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2002) END Parent; PROCEDURE (this: PublishObject) HTMLVersion* (): PpHTMLVersion, NEW; BEGIN RETURN CtlC.GetInt(this, 2003) END HTMLVersion; PROCEDURE (this: PublishObject) PUTHTMLVersion* (p1: PpHTMLVersion), NEW; BEGIN CtlC.PutInt(this, 2003, p1) END PUTHTMLVersion; PROCEDURE (this: PublishObject) SourceType* (): PpPublishSourceType, NEW; BEGIN RETURN CtlC.GetInt(this, 2004) END SourceType; PROCEDURE (this: PublishObject) PUTSourceType* (p1: PpPublishSourceType), NEW; BEGIN CtlC.PutInt(this, 2004, p1) END PUTSourceType; PROCEDURE (this: PublishObject) RangeStart* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2005) END RangeStart; PROCEDURE (this: PublishObject) PUTRangeStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2005, p1) END PUTRangeStart; PROCEDURE (this: PublishObject) RangeEnd* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2006) END RangeEnd; PROCEDURE (this: PublishObject) PUTRangeEnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2006, p1) END PUTRangeEnd; PROCEDURE (this: PublishObject) SlideShowName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2007) END SlideShowName; PROCEDURE (this: PublishObject) PUTSlideShowName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2007, p1) END PUTSlideShowName; PROCEDURE (this: PublishObject) SpeakerNotes* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 2008) END SpeakerNotes; PROCEDURE (this: PublishObject) PUTSpeakerNotes* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 2008, p1) END PUTSpeakerNotes; PROCEDURE (this: PublishObject) FileName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2009) END FileName; PROCEDURE (this: PublishObject) PUTFileName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2009, p1) END PUTFileName; PROCEDURE (this: PublishObject) Publish* (), NEW; BEGIN CtlC.CallMethod(this, 2010, NIL); END Publish; (* ---------- Marker, hidden, dual, nonextensible ---------- *) PROCEDURE (this: Marker) MarkerType* (): PpMarkerType, NEW; BEGIN RETURN CtlC.GetInt(this, 2001) END MarkerType; PROCEDURE (this: Marker) PUTMarkerType* (p1: PpMarkerType), NEW; BEGIN CtlC.PutInt(this, 2001, p1) END PUTMarkerType; PROCEDURE (this: Marker) Time* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2002) END Time; PROCEDURE NewApplication* (): _Application; BEGIN RETURN This_Application(CtlC.NewObj("{91493441-5A91-11CF-8700-00AA0060263B}")) END NewApplication; PROCEDURE NewGlobal* (): _Global; BEGIN RETURN This_Global(CtlC.NewObj("{91493443-5A91-11CF-8700-00AA0060263B}")) END NewGlobal; PROCEDURE NewPresentation* (): _Presentation; BEGIN RETURN This_Presentation(CtlC.NewObj("{91493444-5A91-11CF-8700-00AA0060263B}")) END NewPresentation; PROCEDURE NewSlide* (): _Slide; BEGIN RETURN This_Slide(CtlC.NewObj("{91493445-5A91-11CF-8700-00AA0060263B}")) END NewSlide; PROCEDURE NewOLEControl* (): OCXExtender; BEGIN RETURN ThisOCXExtender(CtlC.NewObj("{91493446-5A91-11CF-8700-00AA0060263B}")) END NewOLEControl; PROCEDURE NewMaster* (): _Master; BEGIN RETURN This_Master(CtlC.NewObj("{91493447-5A91-11CF-8700-00AA0060263B}")) END NewMaster; END CtlPowerPoint9.

Ctl/Mod/PowerPoint9.odc

MODULE CtlStdType; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Standard OLE Types, help: , id: 0 *) (* guid: {BEF6E001-A874-101A-8BBA-00AA00300CAB}, lcid: 0, syskind: win32, version: 2.0 *) IMPORT CtlT, CtlC; CONST (* OLE_TRISTATE *) Unchecked* = 0; Checked* = 1; Gray* = 2; TYPE OLE_COLOR* = INTEGER; OLE_XPOS_PIXELS* = INTEGER; OLE_YPOS_PIXELS* = INTEGER; OLE_XSIZE_PIXELS* = INTEGER; OLE_YSIZE_PIXELS* = INTEGER; OLE_XPOS_HIMETRIC* = INTEGER; OLE_YPOS_HIMETRIC* = INTEGER; OLE_XSIZE_HIMETRIC* = INTEGER; OLE_YSIZE_HIMETRIC* = INTEGER; OLE_XPOS_CONTAINER* = SHORTREAL; OLE_YPOS_CONTAINER* = SHORTREAL; OLE_XSIZE_CONTAINER* = SHORTREAL; OLE_YSIZE_CONTAINER* = SHORTREAL; OLE_HANDLE* = INTEGER; OLE_OPTEXCLUSIVE* = BOOLEAN; OLE_CANCELBOOL* = BOOLEAN; OLE_ENABLEDEFAULTBOOL* = BOOLEAN; OLE_TRISTATE* = INTEGER; FONTNAME* = CtlT.Strg; FONTSIZE* = CtlT.OleCy; FONTBOLD* = BOOLEAN; FONTITALIC* = BOOLEAN; FONTUNDERSCORE* = BOOLEAN; FONTSTRIKETHROUGH* = BOOLEAN; Font* = POINTER TO RECORD (CtlT.Object) END; IFontDisp* = Font; StdFont* = Font; Picture* = POINTER TO RECORD (CtlT.Object) END; IPictureDisp* = Picture; StdPicture* = Picture; PROCEDURE ThisFont* (v: CtlT.Any): Font; VAR new: Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{BEF6E003-A874-101A-8BBA-00AA00300CAB}"); RETURN new ELSE RETURN NIL END END ThisFont; PROCEDURE IsFont* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{BEF6E003-A874-101A-8BBA-00AA00300CAB}") END IsFont; PROCEDURE ThisPicture* (v: CtlT.Any): Picture; VAR new: Picture; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{7BF80981-BF32-101A-8BBB-00AA00300CAB}"); RETURN new ELSE RETURN NIL END END ThisPicture; PROCEDURE IsPicture* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{7BF80981-BF32-101A-8BBB-00AA00300CAB}") END IsPicture; (* ---------- Font ---------- *) PROCEDURE (this: Font) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Font) PUTName* (val: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, val) END PUTName; PROCEDURE (this: Font) Size* (): CtlT.OleCy, NEW; BEGIN RETURN CtlC.GetCy(this, 2) END Size; PROCEDURE (this: Font) PUTSize* (val: CtlT.OleCy), NEW; BEGIN CtlC.PutCy(this, 2, val) END PUTSize; PROCEDURE (this: Font) Bold* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END Bold; PROCEDURE (this: Font) PUTBold* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, val) END PUTBold; PROCEDURE (this: Font) Italic* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END Italic; PROCEDURE (this: Font) PUTItalic* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, val) END PUTItalic; PROCEDURE (this: Font) Underline* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Underline; PROCEDURE (this: Font) PUTUnderline* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, val) END PUTUnderline; PROCEDURE (this: Font) Strikethrough* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Strikethrough; PROCEDURE (this: Font) PUTStrikethrough* (val: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, val) END PUTStrikethrough; PROCEDURE (this: Font) Weight* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 7) END Weight; PROCEDURE (this: Font) PUTWeight* (val: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 7, val) END PUTWeight; PROCEDURE (this: Font) Charset* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 8) END Charset; PROCEDURE (this: Font) PUTCharset* (val: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 8, val) END PUTCharset; (* ---------- Picture ---------- *) PROCEDURE (this: Picture) Handle* (): OLE_HANDLE, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Handle; PROCEDURE (this: Picture) hPal* (): OLE_HANDLE, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END hPal; PROCEDURE (this: Picture) PUThPal* (val: OLE_HANDLE), NEW; BEGIN CtlC.PutInt(this, 2, val) END PUThPal; PROCEDURE (this: Picture) Type* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 3) END Type; PROCEDURE (this: Picture) Width* (): OLE_XSIZE_HIMETRIC, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Width; PROCEDURE (this: Picture) Height* (): OLE_YSIZE_HIMETRIC, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Height; PROCEDURE (this: Picture) Render* (hdc: INTEGER; x: INTEGER; y: INTEGER; cx: INTEGER; cy: INTEGER; xSrc: OLE_XPOS_HIMETRIC; ySrc: OLE_YPOS_HIMETRIC; cxSrc: OLE_XSIZE_HIMETRIC; cySrc: OLE_YSIZE_HIMETRIC; lprcWBounds: CtlT.PtrVoid), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.IntVar(hdc, arg[9]); CtlC.IntVar(x, arg[8]); CtlC.IntVar(y, arg[7]); CtlC.IntVar(cx, arg[6]); CtlC.IntVar(cy, arg[5]); CtlC.IntVar(xSrc, arg[4]); CtlC.IntVar(ySrc, arg[3]); CtlC.IntVar(cxSrc, arg[2]); CtlC.IntVar(cySrc, arg[1]); CtlC.IntVar(lprcWBounds, arg[0]); CtlC.CallParMethod(this, 6, arg, NIL); END Render; PROCEDURE NewStdFont* (): Font; BEGIN RETURN ThisFont(CtlC.NewObj("{0BE35203-8F91-11CE-9DE3-00AA004BB851}")) END NewStdFont; PROCEDURE NewStdPicture* (): Picture; BEGIN RETURN ThisPicture(CtlC.NewObj("{0BE35204-8F91-11CE-9DE3-00AA004BB851}")) END NewStdPicture; END CtlStdType.

Ctl/Mod/StdType.odc

MODULE CtlT; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" purpose = "ole automation controller variant types and conversion tools" changes = " - 20151012, center #76, NIL option for parameters 'par' and 'ret' in CtlT.OutObject.Invoke added " issues = " - ... " **) IMPORT SYSTEM, COM, WinApi, WinOle, WinOleAut, Dates; (* trap 10: execution error *) (* trap 13: not connectable *) (* trap 14: already connected *) (* trap 19: memory error *) CONST (* variant type constants *) byte* = WinOle.VT_UI1; shortint* = WinOle.VT_I2; integer* = WinOle.VT_I4; shortreal* = WinOle.VT_R4; real* = WinOle.VT_R8; boolean* = WinOle.VT_BOOL; result* = WinOle.VT_ERROR; currency* = WinOle.VT_CY; date* = WinOle.VT_DATE; string* = WinOle.VT_BSTR; object* = WinOle.VT_DISPATCH; interface* = WinOle.VT_UNKNOWN; enumerator* = -1; any* = WinOle.VT_VARIANT; TYPE (* basic types *) Strg* = POINTER TO ARRAY OF CHAR; OleCy* = LONGINT; (* scaled by 10000 *) OleDate* = REAL; (* fractional days, 2.0 = 1.1.1900 *) PtrVoid* = INTEGER; IUnknown* = COM.IUnknown; IDispatch* = WinOleAut.IDispatch; RESULT* = INTEGER; GUID* = COM.GUID; Variant* = WinOleAut.VARIANT; ParList* = ARRAY [untagged] OF Variant; (* variant types *) Any* = POINTER TO ABSTRACT RECORD typeId*: SHORTINT; dim*: SHORTINT (* array dimension *) END; Object* = POINTER TO ABSTRACT RECORD (Any) disp*: IDispatch END; OutObject* = POINTER TO ABSTRACT RECORD (Object) source*: Object; cookie: INTEGER END; ByteT* = POINTER TO RECORD (Any) val*: BYTE END; ShortInt* = POINTER TO RECORD (Any) val*: SHORTINT END; Integer* = POINTER TO RECORD (Any) val*: INTEGER END; ShortReal* = POINTER TO RECORD (Any) val*: SHORTREAL END; RealT* = POINTER TO RECORD (Any) val*: REAL END; Boolean* = POINTER TO RECORD (Any) val*: BOOLEAN END; Result* = POINTER TO RECORD (Any) val*: RESULT END; Currency* = POINTER TO RECORD (Any) val*: OleCy END; DateT* = POINTER TO RECORD (Any) val*: OleDate END; String* = POINTER TO RECORD (Any) val*: Strg END; Interface* = POINTER TO RECORD (Any) val*: IUnknown END; (* array types *) AnyArray* = POINTER TO RECORD (Any) p*:POINTER TO ARRAY OF Any END; ObjectArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF Object END; ByteArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF BYTE END; ShortIntArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF SHORTINT END; IntegerArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF INTEGER END; ShortRealArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF SHORTREAL END; RealArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF REAL END; BooleanArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF BOOLEAN END; ResultArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF RESULT END; CurrencyArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF OleCy END; DateArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF OleDate END; StringArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF Strg END; InterfaceArray* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF IUnknown END; (* 2 dimensional array types *) ByteArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF BYTE END; ShortIntArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF SHORTINT END; IntegerArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF INTEGER END; ShortRealArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF SHORTREAL END; RealArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF REAL END; BooleanArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF BOOLEAN END; ResultArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF RESULT END; CurrencyArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF OleCy END; DateArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF OleDate END; StringArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF Strg END; ObjectArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF Object END; InterfaceArray2* = POINTER TO RECORD (Any) p*: POINTER TO ARRAY OF ARRAY OF IUnknown END; AnyArray2* = POINTER TO RECORD (Any) p*:POINTER TO ARRAY OF ARRAY OF Any END; Enumerator* = POINTER TO ABSTRACT RECORD END; InObject = POINTER TO RECORD (Object) END; OutDispatch = POINTER TO RECORD (WinOleAut.IDispatch) obj: OutObject END; VAR noArg-: Any; (* used as placeholder for omited parameters *) context*: SET; lcid*: INTEGER; (* base type conversions *) (* PROCEDURE Stg (IN s: ARRAY OF CHAR): Strg; VAR i, n: INTEGER; str: Strg; BEGIN n := 0; WHILE s[n] # 0X DO INC(n) END; NEW(str, n + 1); str^ := s$; RETURN str END Stg; *) PROCEDURE OleDateToDateAndTime* (d: OleDate; OUT date: Dates.Date; OUT time: Dates.Time); (* CONST c = 693596; (* 1.1.1900 - 2 *) VAR y: INTEGER; BEGIN y := SHORT(ENTIER(d)); Dates.DayToDate(c + y, date); d := d - y; d := d * 24; y := SHORT(ENTIER(d)); time.hour := SHORT(y); d := d - y; d := d * 60; y := SHORT(ENTIER(d)); time.minute := SHORT(y); d := d - y; d := d * 60; y := SHORT(ENTIER(d + 0.5)); time.second := SHORT(y); implementation without WinOleAut import *) VAR res: INTEGER; st: WinApi.SYSTEMTIME; BEGIN res := WinOleAut.VariantTimeToSystemTime(d, st); ASSERT(res = WinApi.TRUE, 20); date.year := st.wYear; date.month := st.wMonth; date.day := st.wDay; time.hour := st.wHour; time.minute := st.wMinute; time.second := st.wSecond END OleDateToDateAndTime; PROCEDURE SystemDayOfWeek (IN date: Dates.Date): SHORTINT; BEGIN CASE Dates.DayOfWeek(date) OF | Dates.monday: RETURN 1 | Dates.tuesday: RETURN 2 | Dates.wednesday: RETURN 3 | Dates.thursday: RETURN 4 | Dates.friday: RETURN 5 | Dates.saturday: RETURN 6 | Dates.sunday: RETURN 0 END END SystemDayOfWeek; PROCEDURE OleDateFromDateAndTime* (IN date: Dates.Date; IN time: Dates.Time): OleDate; (* CONST c = 693596; (* 1.1.1900 - 2 *) BEGIN RETURN Dates.Day(date) - c + ((LONG(time.hour) * 60 + time.minute) * 60 + time.second) / (60 * 60 * 24) implementation without WinOleAut import *) VAR res: INTEGER; st: WinApi.SYSTEMTIME; vt: REAL; BEGIN st.wYear := SHORT(date.year); st.wMonth := SHORT(date.month); st.wDay := SHORT(date.day); st.wDayOfWeek := SystemDayOfWeek(date); st.wHour := SHORT(time.hour); st.wMinute := SHORT(time.minute); st.wSecond := SHORT(time.second); st.wMilliseconds := 0; res := WinOleAut.SystemTimeToVariantTime(st, vt); ASSERT(res # 0, 60); RETURN vt END OleDateFromDateAndTime; (* string tools *) PROCEDURE AllocSysString (IN s: ARRAY OF CHAR): WinOle.BSTR; BEGIN RETURN WinOleAut.SysAllocString(s); END AllocSysString; PROCEDURE AllocString (s: WinOle.BSTR): Strg; VAR i, n: INTEGER; str: Strg; BEGIN IF s # NIL THEN n := WinOleAut.SysStringLen(s); NEW(str, n + 1); str^ := s$ ELSE NEW(str, 1); str[0] := 0X END; RETURN str END AllocString; (* enumerator methods *) PROCEDURE (e: Enumerator) First* (): Any, NEW, ABSTRACT; PROCEDURE (e: Enumerator) Next* (): Any, NEW, ABSTRACT; (* object dispatch methods *) PROCEDURE (obj: OutObject) Invoke* (id, n: INTEGER; VAR [nil] par: ParList; VAR [nil] ret: Variant), NEW, ABSTRACT; PROCEDURE (obj: OutObject) GetIID* (OUT iid: GUID), NEW, ABSTRACT; PROCEDURE (this: OutDispatch) QueryInterface (IN [iid] iid: COM.GUID; OUT [new] int: COM.IUnknown ): COM.RESULT; TYPE T = POINTER TO RECORD [untagged] u: COM.IUnknown END; VAR p: T; myId: COM.GUID; BEGIN this.obj.GetIID(myId); IF iid = myId THEN p := SYSTEM.VAL(T, SYSTEM.ADR(int)); p.u := this; RETURN 0 ELSIF COM.QUERY(this, iid, int) THEN RETURN 0 ELSE RETURN 80004002H (* E_NOINTERFACE *) END END QueryInterface; PROCEDURE (this: OutDispatch) GetTypeInfoCount (OUT [nil] pctinfo: INTEGER): COM.RESULT; BEGIN RETURN 80004001H (* E_NOTIMPL *) END GetTypeInfoCount; PROCEDURE (this: OutDispatch) GetTypeInfo (iTInfo: INTEGER; lcid: WinOle.LCID; OUT [nil] ppTInfo: WinOleAut.ITypeInfo): COM.RESULT; BEGIN RETURN 80004001H (* E_NOTIMPL *) END GetTypeInfo; PROCEDURE (this: OutDispatch) GetIDsOfNames (IN [nil] riid: COM.GUID; IN [nil] rgszNames: WinOle.PtrWSTR; cNames: INTEGER; lcid: WinOle.LCID; OUT [nil] rgDispId: WinOleAut.DISPID): COM.RESULT; BEGIN RETURN 80004001H (* E_NOTIMPL *) END GetIDsOfNames; PROCEDURE (this: OutDispatch) Invoke (dispIdMember: WinOleAut.DISPID; IN riid: COM.GUID; lcid: WinOle.LCID; wFlags: SHORTINT; VAR [nil] pDispParams: WinOleAut.DISPPARAMS; OUT [nil] pVarResult: WinOleAut.VARIANT; OUT [nil] pExcepInfo: WinOleAut.EXCEPINFO; OUT [nil] puArgErr: INTEGER): COM.RESULT; VAR n: INTEGER; BEGIN IF pDispParams.cNamedArgs # 0 THEN RETURN 80020007H (* DISP_E_NONAMEDARGS *) END; IF riid # WinOle.GUID_NULL THEN RETURN 80020001H (* DISP_E_UNKNOWNINTERFACE *) END; IF VALID(pVarResult) THEN pVarResult.vt := 0 END; n := pDispParams.cArgs; IF ODD(wFlags DIV WinOleAut.DISPATCH_PROPERTYPUT) THEN n := -n ELSIF ODD(wFlags DIV WinOleAut.DISPATCH_PROPERTYPUTREF) THEN n := -100 - n END; this.obj.Invoke(dispIdMember, n, pDispParams.rgvarg^, pVarResult); RETURN 0 END Invoke; PROCEDURE Disp* (obj: Object): IDispatch; VAR disp: OutDispatch; BEGIN ASSERT((obj.disp # NIL) OR (obj IS OutObject), 100); IF obj.disp # NIL THEN RETURN obj.disp ELSE NEW(disp); disp.obj := obj(OutObject); RETURN disp END END Disp; (* value access methods *) PROCEDURE (x: Any) Byte* (): BYTE, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END Byte; PROCEDURE (x: Any) SInt* (): SHORTINT, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END SInt; PROCEDURE (x: Any) Int* (): INTEGER, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END Int; PROCEDURE (x: Any) SReal* (): SHORTREAL, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END SReal; PROCEDURE (x: Any) Real* (): REAL, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END Real; PROCEDURE (x: Any) Bool* (): BOOLEAN, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN FALSE END Bool; PROCEDURE (x: Any) Cy* (): OleCy, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END Cy; PROCEDURE (x: Any) Date* (): OleDate, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN 0 END Date; PROCEDURE (x: Any) Str* (): Strg, NEW, EXTENSIBLE; BEGIN HALT(20); RETURN NIL END Str; PROCEDURE (x: ByteT) Byte* (): BYTE; BEGIN RETURN x.val END Byte; PROCEDURE (x: ByteT) SInt* (): SHORTINT; BEGIN RETURN x.val END SInt; PROCEDURE (x: ByteT) Int* (): INTEGER; BEGIN RETURN x.val END Int; PROCEDURE (x: ByteT) SReal* (): SHORTREAL; BEGIN RETURN x.val END SReal; PROCEDURE (x: ByteT) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: ByteT) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0 END Bool; PROCEDURE (x: ByteT) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromUI1(SHORT(CHR(x.val)), c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: ByteT) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromUI1(SHORT(CHR(x.val)), d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: ByteT) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromUI1(SHORT(CHR(x.val)), lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: ShortInt) Byte* (): BYTE; BEGIN RETURN SHORT(x.val) END Byte; PROCEDURE (x: ShortInt) SInt* (): SHORTINT; BEGIN RETURN x.val END SInt; PROCEDURE (x: ShortInt) Int* (): INTEGER; BEGIN RETURN x.val END Int; PROCEDURE (x: ShortInt) SReal* (): SHORTREAL; BEGIN RETURN x.val END SReal; PROCEDURE (x: ShortInt) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: ShortInt) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0 END Bool; PROCEDURE (x: ShortInt) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromI2(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: ShortInt) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromI2(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: ShortInt) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromI2(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: Integer) Byte* (): BYTE; BEGIN ASSERT((x.val >= -128) & (x.val < 256), 20); RETURN SHORT(SHORT(x.val)) END Byte; PROCEDURE (x: Integer) SInt* (): SHORTINT; BEGIN ASSERT((x.val >= -32768) & (x.val <= 32767), 20); RETURN SHORT(x.val) END SInt; PROCEDURE (x: Integer) Int* (): INTEGER; BEGIN RETURN x.val END Int; PROCEDURE (x: Integer) SReal* (): SHORTREAL; BEGIN RETURN x.val END SReal; PROCEDURE (x: Integer) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: Integer) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0 END Bool; PROCEDURE (x: Integer) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromI4(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: Integer) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromI4(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: Integer) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromI4(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: ShortReal) Byte* (): BYTE; VAR c: SHORTCHAR; res: COM.RESULT; BEGIN res := WinOleAut.VarUI1FromR4(x.val, c); ASSERT(res >= 0, 20); RETURN SHORT(ORD(c)) END Byte; PROCEDURE (x: ShortReal) SInt* (): SHORTINT; VAR i: SHORTINT; res: COM.RESULT; BEGIN res := WinOleAut.VarI2FromR4(x.val, i); ASSERT(res >= 0, 20); RETURN i END SInt; PROCEDURE (x: ShortReal) Int* (): INTEGER; VAR i: INTEGER; res: COM.RESULT; BEGIN res := WinOleAut.VarI4FromR4(x.val, i); ASSERT(res >= 0, 20); RETURN i END Int; PROCEDURE (x: ShortReal) SReal* (): SHORTREAL; BEGIN RETURN x.val END SReal; PROCEDURE (x: ShortReal) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: ShortReal) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0.0 END Bool; PROCEDURE (x: ShortReal) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromR4(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: ShortReal) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromR4(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: ShortReal) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromR4(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: RealT) Byte* (): BYTE; VAR c: SHORTCHAR; res: COM.RESULT; BEGIN res := WinOleAut.VarUI1FromR8(x.val, c); ASSERT(res >= 0, 20); RETURN SHORT(ORD(c)) END Byte; PROCEDURE (x: RealT) SInt* (): SHORTINT; VAR i: SHORTINT; res: COM.RESULT; BEGIN res := WinOleAut.VarI2FromR8(x.val, i); ASSERT(res >= 0, 20); RETURN i END SInt; PROCEDURE (x: RealT) Int* (): INTEGER; VAR i: INTEGER; res: COM.RESULT; BEGIN res := WinOleAut.VarI4FromR8(x.val, i); ASSERT(res >= 0, 20); RETURN i END Int; PROCEDURE (x: RealT) SReal* (): SHORTREAL; VAR r: SHORTREAL; res: COM.RESULT; BEGIN res := WinOleAut.VarR4FromR8(x.val, r); ASSERT(res >= 0, 20); RETURN r END SReal; PROCEDURE (x: RealT) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: RealT) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0.0 END Bool; PROCEDURE (x: RealT) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromR8(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: RealT) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromR8(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: RealT) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromR8(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: Boolean) Byte* (): BYTE; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END Byte; PROCEDURE (x: Boolean) SInt* (): SHORTINT; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END SInt; PROCEDURE (x: Boolean) Int* (): INTEGER; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END Int; PROCEDURE (x: Boolean) SReal* (): SHORTREAL; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END SReal; PROCEDURE (x: Boolean) Real* (): REAL; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END Real; PROCEDURE (x: Boolean) Bool* (): BOOLEAN; BEGIN RETURN x.val END Bool; PROCEDURE (x: Boolean) Cy* (): OleCy; BEGIN IF x.val THEN RETURN -10000 ELSE RETURN 0 END END Cy; PROCEDURE (x: Boolean) Date* (): OleDate; BEGIN IF x.val THEN RETURN -1 ELSE RETURN 0 END END Date; PROCEDURE (x: Boolean) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN IF x.val THEN res := WinOleAut.VarBstrFromBool(-1, lcid, {}, b) ELSE res := WinOleAut.VarBstrFromBool(0, lcid, {}, b) END; ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: Currency) Byte* (): BYTE; VAR c: SHORTCHAR; res: COM.RESULT; BEGIN res := WinOleAut.VarUI1FromCy(x.val, c); ASSERT(res >= 0, 20); RETURN SHORT(ORD(c)) END Byte; PROCEDURE (x: Currency) SInt* (): SHORTINT; VAR i: SHORTINT; res: COM.RESULT; BEGIN res := WinOleAut.VarI2FromCy(x.val, i); ASSERT(res >= 0, 20); RETURN i END SInt; PROCEDURE (x: Currency) Int* (): INTEGER; VAR i: INTEGER; res: COM.RESULT; BEGIN res := WinOleAut.VarI4FromCy(x.val, i); ASSERT(res >= 0, 20); RETURN i END Int; PROCEDURE (x: Currency) SReal* (): SHORTREAL; VAR r: SHORTREAL; res: COM.RESULT; BEGIN res := WinOleAut.VarR4FromCy(x.val, r); ASSERT(res >= 0, 20); RETURN r END SReal; PROCEDURE (x: Currency) Real* (): REAL; VAR r: REAL; res: COM.RESULT; BEGIN res := WinOleAut.VarR8FromCy(x.val, r); ASSERT(res >= 0, 20); RETURN r END Real; PROCEDURE (x: Currency) Bool* (): BOOLEAN; VAR b: WinOle.VARIANT_BOOL; res: COM.RESULT; BEGIN res := WinOleAut.VarBoolFromCy(x.val, b); ASSERT(res >= 0, 20); RETURN b # 0 END Bool; PROCEDURE (x: Currency) Cy* (): OleCy; BEGIN RETURN x.val END Cy; PROCEDURE (x: Currency) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromCy(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: Currency) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromCy(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: DateT) Byte* (): BYTE; VAR c: SHORTCHAR; res: COM.RESULT; BEGIN res := WinOleAut.VarUI1FromDate(x.val, c); ASSERT(res >= 0, 20); RETURN SHORT(ORD(c)) END Byte; PROCEDURE (x: DateT) SInt* (): SHORTINT; VAR i: SHORTINT; res: COM.RESULT; BEGIN res := WinOleAut.VarI2FromDate(x.val, i); ASSERT(res >= 0, 20); RETURN i END SInt; PROCEDURE (x: DateT) Int* (): INTEGER; VAR i: INTEGER; res: COM.RESULT; BEGIN res := WinOleAut.VarI4FromDate(x.val, i); ASSERT(res >= 0, 20); RETURN i END Int; PROCEDURE (x: DateT) SReal* (): SHORTREAL; VAR r: SHORTREAL; res: COM.RESULT; BEGIN res := WinOleAut.VarR4FromDate(x.val, r); ASSERT(res >= 0, 20); RETURN r END SReal; PROCEDURE (x: DateT) Real* (): REAL; VAR r: REAL; res: COM.RESULT; BEGIN res := WinOleAut.VarR8FromDate(x.val, r); ASSERT(res >= 0, 20); RETURN r END Real; PROCEDURE (x: DateT) Bool* (): BOOLEAN; VAR b: WinOle.VARIANT_BOOL; res: COM.RESULT; BEGIN res := WinOleAut.VarBoolFromDate(x.val, b); ASSERT(res >= 0, 20); RETURN b # 0 END Bool; PROCEDURE (x: DateT) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromDate(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: DateT) Date* (): OleDate; BEGIN RETURN x.val END Date; PROCEDURE (x: DateT) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromDate(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; PROCEDURE (x: String) Byte* (): BYTE; VAR c: SHORTCHAR; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarUI1FromStr(s^, lcid, {}, c); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN SHORT(ORD(c)) END Byte; PROCEDURE (x: String) SInt* (): SHORTINT; VAR i: SHORTINT; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarI2FromStr(s^, lcid, {}, i); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN i END SInt; PROCEDURE (x: String) Int* (): INTEGER; VAR i: INTEGER; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarI4FromStr(s^, lcid, {}, i); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN i END Int; PROCEDURE (x: String) SReal* (): SHORTREAL; VAR r: SHORTREAL; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarR4FromStr(s^, lcid, {}, r); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN r END SReal; PROCEDURE (x: String) Real* (): REAL; VAR r: REAL; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarR8FromStr(s^, lcid, {}, r); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN r END Real; PROCEDURE (x: String) Bool* (): BOOLEAN; VAR b: WinOle.VARIANT_BOOL; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarBoolFromStr(s^, lcid, {}, b); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN b # 0 END Bool; PROCEDURE (x: String) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarCyFromStr(s^, lcid, {}, c); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN c END Cy; PROCEDURE (x: String) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; s: WinOle.BSTR; BEGIN s := AllocSysString(x.val^); res := WinOleAut.VarDateFromStr(s^, lcid, {}, d); ASSERT(res >= 0, 20); WinOleAut.SysFreeString(s); RETURN d END Date; PROCEDURE (x: String) Str* (): Strg; BEGIN RETURN x.val END Str; PROCEDURE (x: Result) Byte* (): BYTE; BEGIN ASSERT((x.val >= -128) & (x.val < 256), 20); RETURN SHORT(SHORT(x.val)) END Byte; PROCEDURE (x: Result) SInt* (): SHORTINT; BEGIN ASSERT((x.val >= -32768) & (x.val <= 32767), 20); RETURN SHORT(x.val) END SInt; PROCEDURE (x: Result) Int* (): INTEGER; BEGIN RETURN x.val END Int; PROCEDURE (x: Result) SReal* (): SHORTREAL; BEGIN RETURN x.val END SReal; PROCEDURE (x: Result) Real* (): REAL; BEGIN RETURN x.val END Real; PROCEDURE (x: Result) Bool* (): BOOLEAN; BEGIN RETURN x.val # 0 END Bool; PROCEDURE (x: Result) Cy* (): OleCy; VAR c: OleCy; res: COM.RESULT; BEGIN res := WinOleAut.VarCyFromI4(x.val, c); ASSERT(res >= 0, 20); RETURN c END Cy; PROCEDURE (x: Result) Date* (): OleDate; VAR d: OleDate; res: COM.RESULT; BEGIN res := WinOleAut.VarDateFromI4(x.val, d); ASSERT(res >= 0, 20); RETURN d END Date; PROCEDURE (x: Result) Str* (): Strg; VAR b: WinOle.BSTR; s: Strg; res: COM.RESULT; BEGIN res := WinOleAut.VarBstrFromI4(x.val, lcid, {}, b); ASSERT(res >= 0, 20); s := AllocString(b); WinOleAut.SysFreeString(b); RETURN s END Str; (* variant generator functions *) PROCEDURE Byte* (val: BYTE): ByteT; VAR x: ByteT; BEGIN NEW(x); x.typeId := byte; x.val := val; RETURN x END Byte; PROCEDURE SInt* (val: SHORTINT): ShortInt; VAR x: ShortInt; BEGIN NEW(x); x.typeId := shortint; x.val := val; RETURN x END SInt; PROCEDURE Int* (val: INTEGER): Integer; VAR x: Integer; BEGIN NEW(x); x.typeId := integer; x.val := val; RETURN x END Int; PROCEDURE SReal* (val: SHORTREAL): ShortReal; VAR x: ShortReal; BEGIN NEW(x); x.typeId := shortreal; x.val := val; RETURN x END SReal; PROCEDURE Real* (val: REAL): RealT; VAR x: RealT; BEGIN NEW(x); x.typeId := real; x.val := val; RETURN x END Real; PROCEDURE Bool* (val: BOOLEAN): Boolean; VAR x: Boolean; BEGIN NEW(x); x.typeId := boolean; x.val := val; RETURN x END Bool; PROCEDURE Res* (val: RESULT): Result; VAR x: Result; BEGIN NEW(x); x.typeId := result; x.val := val; RETURN x END Res; PROCEDURE Cy* (val: OleCy): Currency; VAR x: Currency; BEGIN NEW(x); x.typeId := currency; x.val := val; RETURN x END Cy; PROCEDURE Date* (val: OleDate): DateT; VAR x: DateT; BEGIN NEW(x); x.typeId := date; x.val := val; RETURN x END Date; PROCEDURE Str* (IN val: ARRAY OF CHAR): String; VAR x: String; BEGIN NEW(x); NEW(x.val, LEN(val)); x.typeId := string; x.val^ := val$; RETURN x END Str; PROCEDURE Obj* (disp: IDispatch): Object; VAR x: InObject; BEGIN IF disp = NIL THEN RETURN NIL ELSE NEW(x); x.typeId := object; x.disp := disp; RETURN x END END Obj; PROCEDURE Intfce* (val: IUnknown): Interface; VAR x: Interface; BEGIN NEW(x); x.typeId := interface; x.val := val; RETURN x END Intfce; PROCEDURE ByteArr* (IN val: ARRAY OF BYTE): ByteArray; VAR x: ByteArray; i: INTEGER; BEGIN NEW(x); x.typeId := byte; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END ByteArr; PROCEDURE SIntArr* (IN val: ARRAY OF SHORTINT): ShortIntArray; VAR x: ShortIntArray; i: INTEGER; BEGIN NEW(x); x.typeId := shortint; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END SIntArr; PROCEDURE IntArr* (IN val: ARRAY OF INTEGER): IntegerArray; VAR x: IntegerArray; i: INTEGER; BEGIN NEW(x); x.typeId := integer; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END IntArr; PROCEDURE SRealArr* (IN val: ARRAY OF SHORTREAL): ShortRealArray; VAR x: ShortRealArray; i: INTEGER; BEGIN NEW(x); x.typeId := shortreal; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END SRealArr; PROCEDURE RealArr* (IN val: ARRAY OF REAL): RealArray; VAR x: RealArray; i: INTEGER; BEGIN NEW(x); x.typeId := real; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END RealArr; PROCEDURE BoolArr* (IN val: ARRAY OF BOOLEAN): BooleanArray; VAR x: BooleanArray; i: INTEGER; BEGIN NEW(x); x.typeId := boolean; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END BoolArr; PROCEDURE ResArr* (IN val: ARRAY OF RESULT): ResultArray; VAR x: ResultArray; i: INTEGER; BEGIN NEW(x); x.typeId := result; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END ResArr; PROCEDURE CyArr* (IN val: ARRAY OF OleCy): CurrencyArray; VAR x: CurrencyArray; i: INTEGER; BEGIN NEW(x); x.typeId := currency; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END CyArr; PROCEDURE DateArr* (IN val: ARRAY OF OleDate): DateArray; VAR x: DateArray; i: INTEGER; BEGIN NEW(x); x.typeId := date; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END DateArr; PROCEDURE StrArr* (IN val: ARRAY OF Strg): StringArray; VAR x: StringArray; i: INTEGER; BEGIN NEW(x); x.typeId := string; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END StrArr; PROCEDURE ObjArr* (IN val: ARRAY OF Object): ObjectArray; VAR x: ObjectArray; i: INTEGER; BEGIN NEW(x); x.typeId := object; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END ObjArr; PROCEDURE IntfceArr* (IN val: ARRAY OF IUnknown): InterfaceArray; VAR x: InterfaceArray; i: INTEGER; BEGIN NEW(x); x.typeId := interface; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END IntfceArr; PROCEDURE AnyArr* (IN val: ARRAY OF Any): AnyArray; VAR x: AnyArray; i: INTEGER; BEGIN NEW(x); x.typeId := any; x.dim := 1; NEW(x.p, LEN(val)); i := 0; WHILE i < LEN(val) DO x.p[i] := val[i]; INC(i) END; RETURN x END AnyArr; PROCEDURE ByteArr2* (IN val: ARRAY OF ARRAY OF BYTE): ByteArray2; VAR x: ByteArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := byte; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END ByteArr2; PROCEDURE SIntArr2* (IN val: ARRAY OF ARRAY OF SHORTINT): ShortIntArray2; VAR x: ShortIntArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := shortint; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END SIntArr2; PROCEDURE IntArr2* (IN val: ARRAY OF ARRAY OF INTEGER): IntegerArray2; VAR x: IntegerArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := integer; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END IntArr2; PROCEDURE SRealArr2* (IN val: ARRAY OF ARRAY OF SHORTREAL): ShortRealArray2; VAR x: ShortRealArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := shortreal; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END SRealArr2; PROCEDURE RealArr2* (IN val: ARRAY OF ARRAY OF REAL): RealArray2; VAR x: RealArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := real; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END RealArr2; PROCEDURE BoolArr2* (IN val: ARRAY OF ARRAY OF BOOLEAN): BooleanArray2; VAR x: BooleanArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := boolean; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END BoolArr2; PROCEDURE ResArr2* (IN val: ARRAY OF ARRAY OF RESULT): ResultArray2; VAR x: ResultArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := result; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END ResArr2; PROCEDURE CyArr2* (IN val: ARRAY OF ARRAY OF OleCy): CurrencyArray2; VAR x: CurrencyArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := currency; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END CyArr2; PROCEDURE DateArr2* (IN val: ARRAY OF ARRAY OF OleDate): DateArray2; VAR x: DateArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := date; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END DateArr2; PROCEDURE StrArr2* (IN val: ARRAY OF ARRAY OF Strg): StringArray2; VAR x: StringArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := string; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END StrArr2; PROCEDURE ObjArr2* (IN val: ARRAY OF ARRAY OF Object): ObjectArray2; VAR x: ObjectArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := object; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END ObjArr2; PROCEDURE IntfceArr2* (IN val: ARRAY OF ARRAY OF IUnknown): InterfaceArray2; VAR x: InterfaceArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := interface; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END IntfceArr2; PROCEDURE AnyArr2* (IN val: ARRAY OF ARRAY OF Any): AnyArray2; VAR x: AnyArray2; i, j: INTEGER; BEGIN NEW(x); x.typeId := any; x.dim := 2; NEW(x.p, LEN(val), LEN(val, 1)); i := 0; WHILE i < LEN(val) DO j := 0; WHILE j < LEN(val, 1) DO x.p[i, j] := val[i, j]; INC(j) END; INC(i) END; RETURN x END AnyArr2; PROCEDURE GetConnectionPoint (source: Object; IN iid: COM.GUID): WinOle.IConnectionPoint; VAR res: COM.RESULT; cont: WinOle.IConnectionPointContainer; cp: WinOle.IConnectionPoint; BEGIN res := source.disp.QueryInterface(COM.ID(cont), cont); IF res >= 0 THEN res := cont.FindConnectionPoint(iid, cp); RETURN cp ELSE RETURN NIL END END GetConnectionPoint; PROCEDURE Connect* (sink: OutObject; source: Object); VAR res: COM.RESULT; cp: WinOle.IConnectionPoint; iid: COM.GUID; disp: WinOleAut.IDispatch; BEGIN sink.GetIID(iid); ASSERT(sink.cookie = 0, 20); ASSERT(source.disp # NIL, 21); cp := GetConnectionPoint(source, iid); ASSERT(cp # NIL, 21); disp := Disp(sink); res := cp.Advise(disp, sink.cookie); ASSERT(res >= 0, 21) END Connect; PROCEDURE Disconnect* (sink: OutObject; source: Object); VAR res: COM.RESULT; cp: WinOle.IConnectionPoint; iid: COM.GUID; BEGIN sink.GetIID(iid); ASSERT(sink.cookie # 0, 20); ASSERT(source.disp # NIL, 20); cp := GetConnectionPoint(source, iid); ASSERT(cp # NIL, 20); res := cp.Unadvise(sink.cookie); ASSERT(res >= 0, 20); sink.cookie := 0; END Disconnect; BEGIN noArg := Res(80020004H); (* DISP_E_PARAMNOTFOUND *) context := WinOle.CLSCTX_INPROC_SERVER + WinOle.CLSCTX_LOCAL_SERVER; lcid := 2048; (* LOCALE_SYSTEM_DEFAULT *) END CtlT.

Ctl/Mod/T.odc

MODULE CtlVBIDE; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Visual Basic for Applications Extensibility, help: C:\PROGRAM FILES\COMMON FILES\MICROSOFT SHARED\VBA\VEENOB3.HLP, id: 100000 *) (* guid: {0002E157-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 5.0 *) IMPORT CtlT, CtlC, CtlOffice; CONST (* vbextFileTypes, hidden *) vbextFileTypeForm* = 0; vbextFileTypeModule* = 1; vbextFileTypeClass* = 2; vbextFileTypeProject* = 3; vbextFileTypeExe* = 4; vbextFileTypeFrx* = 5; vbextFileTypeRes* = 6; vbextFileTypeUserControl* = 7; vbextFileTypePropertyPage* = 8; vbextFileTypeDocObject* = 9; vbextFileTypeBinary* = 10; vbextFileTypeGroupProject* = 11; vbextFileTypeDesigners* = 12; (* vbext_WindowType *) vbext_wt_CodeWindow* = 0; vbext_wt_Designer* = 1; vbext_wt_Browser* = 2; vbext_wt_Watch* = 3; vbext_wt_Locals* = 4; vbext_wt_Immediate* = 5; vbext_wt_ProjectWindow* = 6; vbext_wt_PropertyWindow* = 7; vbext_wt_Find* = 8; vbext_wt_FindReplace* = 9; vbext_wt_LinkedWindowFrame* = 11; vbext_wt_MainWindow* = 12; vbext_wt_ToolWindow* = 15; (* vbext_WindowState *) vbext_ws_Normal* = 0; vbext_ws_Minimize* = 1; vbext_ws_Maximize* = 2; (* vbext_ProjectProtection *) vbext_pp_none* = 0; vbext_pp_locked* = 1; (* vbext_VBAMode *) vbext_vm_Run* = 0; vbext_vm_Break* = 1; vbext_vm_Design* = 2; (* vbext_ComponentType *) vbext_ct_StdModule* = 1; vbext_ct_ClassModule* = 2; vbext_ct_MSForm* = 3; vbext_ct_Document* = 100; (* vbext_ProcKind *) vbext_pk_Proc* = 0; vbext_pk_Let* = 1; vbext_pk_Set* = 2; vbext_pk_Get* = 3; (* vbext_CodePaneview *) vbext_cv_ProcedureView* = 0; vbext_cv_FullModuleView* = 1; (* vbext_RefKind *) vbext_rk_TypeLib* = 0; vbext_rk_Project* = 1; TYPE Application* = POINTER TO RECORD (CtlT.Object) END; vbextFileTypes* = INTEGER; VBE* = POINTER TO RECORD (CtlT.Object) END; vbext_WindowType* = INTEGER; vbext_WindowState* = INTEGER; Window* = POINTER TO RECORD (CtlT.Object) END; _Windows* = POINTER TO RECORD (CtlT.Object) END; Windows* = _Windows; _LinkedWindows* = POINTER TO RECORD (CtlT.Object) END; LinkedWindows* = _LinkedWindows; Events* = POINTER TO RECORD (CtlT.Object) END; _dispVBProjectsEvents* = POINTER TO RECORD (CtlT.Object) END; _dispVBComponentsEvents* = POINTER TO RECORD (CtlT.Object) END; _dispReferencesEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _dispCommandBarControlEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; _ProjectTemplate* = POINTER TO RECORD (CtlT.Object) END; ProjectTemplate* = _ProjectTemplate; vbext_ProjectProtection* = INTEGER; vbext_VBAMode* = INTEGER; _VBProject* = POINTER TO RECORD (CtlT.Object) END; VBProject* = _VBProject; _VBProjects* = POINTER TO RECORD (CtlT.Object) END; VBProjects* = _VBProjects; SelectedComponents* = POINTER TO RECORD (CtlT.Object) END; vbext_ComponentType* = INTEGER; _Components* = POINTER TO RECORD (CtlT.Object) END; Components* = _Components; _VBComponents* = POINTER TO RECORD (CtlT.Object) END; VBComponents* = _VBComponents; _Component* = POINTER TO RECORD (CtlT.Object) END; Component* = _Component; _VBComponent* = POINTER TO RECORD (CtlT.Object) END; VBComponent* = _VBComponent; Property* = POINTER TO RECORD (CtlT.Object) END; _Properties* = POINTER TO RECORD (CtlT.Object) END; Properties* = _Properties; vbext_ProcKind* = INTEGER; _CodeModule* = POINTER TO RECORD (CtlT.Object) END; CodeModule* = _CodeModule; _CodePanes* = POINTER TO RECORD (CtlT.Object) END; CodePanes* = _CodePanes; vbext_CodePaneview* = INTEGER; _CodePane* = POINTER TO RECORD (CtlT.Object) END; CodePane* = _CodePane; _References* = POINTER TO RECORD (CtlT.Object) END; vbext_RefKind* = INTEGER; Reference* = POINTER TO RECORD (CtlT.Object) END; _dispReferences_Events* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; References* = _References; PROCEDURE ThisApplication* (v: CtlT.Any): Application; VAR new: Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E158-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisApplication; PROCEDURE IsApplication* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E158-0000-0000-C000-000000000046}") END IsApplication; PROCEDURE ThisVBE* (v: CtlT.Any): VBE; VAR new: VBE; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E166-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVBE; PROCEDURE IsVBE* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E166-0000-0000-C000-000000000046}") END IsVBE; PROCEDURE ThisWindow* (v: CtlT.Any): Window; VAR new: Window; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E16B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWindow; PROCEDURE IsWindow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E16B-0000-0000-C000-000000000046}") END IsWindow; PROCEDURE This_Windows* (v: CtlT.Any): _Windows; VAR new: _Windows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E16A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Windows; PROCEDURE Is_Windows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E16A-0000-0000-C000-000000000046}") END Is_Windows; PROCEDURE This_LinkedWindows* (v: CtlT.Any): _LinkedWindows; VAR new: _LinkedWindows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E16C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_LinkedWindows; PROCEDURE Is_LinkedWindows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E16C-0000-0000-C000-000000000046}") END Is_LinkedWindows; PROCEDURE ThisEvents* (v: CtlT.Any): Events; VAR new: Events; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E167-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEvents; PROCEDURE IsEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E167-0000-0000-C000-000000000046}") END IsEvents; PROCEDURE This_dispVBProjectsEvents* (v: CtlT.Any): _dispVBProjectsEvents; VAR new: _dispVBProjectsEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E103-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_dispVBProjectsEvents; PROCEDURE Is_dispVBProjectsEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E103-0000-0000-C000-000000000046}") END Is_dispVBProjectsEvents; PROCEDURE This_dispVBComponentsEvents* (v: CtlT.Any): _dispVBComponentsEvents; VAR new: _dispVBComponentsEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E116-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_dispVBComponentsEvents; PROCEDURE Is_dispVBComponentsEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E116-0000-0000-C000-000000000046}") END Is_dispVBComponentsEvents; PROCEDURE This_ProjectTemplate* (v: CtlT.Any): _ProjectTemplate; VAR new: _ProjectTemplate; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E159-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_ProjectTemplate; PROCEDURE Is_ProjectTemplate* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E159-0000-0000-C000-000000000046}") END Is_ProjectTemplate; PROCEDURE This_VBProject* (v: CtlT.Any): _VBProject; VAR new: _VBProject; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E160-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_VBProject; PROCEDURE Is_VBProject* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E160-0000-0000-C000-000000000046}") END Is_VBProject; PROCEDURE This_VBProjects* (v: CtlT.Any): _VBProjects; VAR new: _VBProjects; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E165-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_VBProjects; PROCEDURE Is_VBProjects* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E165-0000-0000-C000-000000000046}") END Is_VBProjects; PROCEDURE ThisSelectedComponents* (v: CtlT.Any): SelectedComponents; VAR new: SelectedComponents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{BE39F3D4-1B13-11D0-887F-00A0C90F2744}"); RETURN new ELSE RETURN NIL END END ThisSelectedComponents; PROCEDURE IsSelectedComponents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{BE39F3D4-1B13-11D0-887F-00A0C90F2744}") END IsSelectedComponents; PROCEDURE This_Components* (v: CtlT.Any): _Components; VAR new: _Components; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E161-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Components; PROCEDURE Is_Components* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E161-0000-0000-C000-000000000046}") END Is_Components; PROCEDURE This_VBComponents* (v: CtlT.Any): _VBComponents; VAR new: _VBComponents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E162-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_VBComponents; PROCEDURE Is_VBComponents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E162-0000-0000-C000-000000000046}") END Is_VBComponents; PROCEDURE This_Component* (v: CtlT.Any): _Component; VAR new: _Component; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E163-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Component; PROCEDURE Is_Component* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E163-0000-0000-C000-000000000046}") END Is_Component; PROCEDURE This_VBComponent* (v: CtlT.Any): _VBComponent; VAR new: _VBComponent; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E164-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_VBComponent; PROCEDURE Is_VBComponent* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E164-0000-0000-C000-000000000046}") END Is_VBComponent; PROCEDURE ThisProperty* (v: CtlT.Any): Property; VAR new: Property; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E18C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisProperty; PROCEDURE IsProperty* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E18C-0000-0000-C000-000000000046}") END IsProperty; PROCEDURE This_Properties* (v: CtlT.Any): _Properties; VAR new: _Properties; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E188-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Properties; PROCEDURE Is_Properties* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E188-0000-0000-C000-000000000046}") END Is_Properties; PROCEDURE This_CodeModule* (v: CtlT.Any): _CodeModule; VAR new: _CodeModule; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E16E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CodeModule; PROCEDURE Is_CodeModule* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E16E-0000-0000-C000-000000000046}") END Is_CodeModule; PROCEDURE This_CodePanes* (v: CtlT.Any): _CodePanes; VAR new: _CodePanes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E172-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CodePanes; PROCEDURE Is_CodePanes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E172-0000-0000-C000-000000000046}") END Is_CodePanes; PROCEDURE This_CodePane* (v: CtlT.Any): _CodePane; VAR new: _CodePane; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E176-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_CodePane; PROCEDURE Is_CodePane* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E176-0000-0000-C000-000000000046}") END Is_CodePane; PROCEDURE This_References* (v: CtlT.Any): _References; VAR new: _References; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E17A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_References; PROCEDURE Is_References* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E17A-0000-0000-C000-000000000046}") END Is_References; PROCEDURE ThisReference* (v: CtlT.Any): Reference; VAR new: Reference; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002E17E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisReference; PROCEDURE IsReference* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002E17E-0000-0000-C000-000000000046}") END IsReference; (* ---------- Application, hidden, dual ---------- *) PROCEDURE (this: Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 100) END Version; (* ---------- VBE, dual ---------- *) PROCEDURE (this: VBE) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 100) END Version; PROCEDURE (this: VBE) VBProjects* (): VBProjects, NEW; BEGIN RETURN This_VBProjects(CtlC.GetAny(this, 107)) END VBProjects; PROCEDURE (this: VBE) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 108)) END CommandBars; PROCEDURE (this: VBE) CodePanes* (): CodePanes, NEW; BEGIN RETURN This_CodePanes(CtlC.GetAny(this, 109)) END CodePanes; PROCEDURE (this: VBE) Windows* (): Windows, NEW; BEGIN RETURN This_Windows(CtlC.GetAny(this, 110)) END Windows; PROCEDURE (this: VBE) Events* (): Events, NEW; BEGIN RETURN ThisEvents(CtlC.GetAny(this, 111)) END Events; PROCEDURE (this: VBE) ActiveVBProject* (): VBProject, NEW; BEGIN RETURN This_VBProject(CtlC.GetAny(this, 201)) END ActiveVBProject; PROCEDURE (this: VBE) PUTREFActiveVBProject* (p1: VBProject), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 201, arg, NIL); END PUTREFActiveVBProject; PROCEDURE (this: VBE) SelectedVBComponent* (): VBComponent, NEW; BEGIN RETURN This_VBComponent(CtlC.GetAny(this, 202)) END SelectedVBComponent; PROCEDURE (this: VBE) MainWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 204)) END MainWindow; PROCEDURE (this: VBE) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 205)) END ActiveWindow; PROCEDURE (this: VBE) ActiveCodePane* (): CodePane, NEW; BEGIN RETURN This_CodePane(CtlC.GetAny(this, 206)) END ActiveCodePane; PROCEDURE (this: VBE) PUTREFActiveCodePane* (p1: CodePane), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 206, arg, NIL); END PUTREFActiveCodePane; (* ---------- Window, dual ---------- *) PROCEDURE (this: Window) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1)) END VBE; PROCEDURE (this: Window) Collection* (): Windows, NEW; BEGIN RETURN This_Windows(CtlC.GetAny(this, 2)) END Collection; PROCEDURE (this: Window) Close* (), NEW; BEGIN CtlC.CallMethod(this, 99, NIL); END Close; PROCEDURE (this: Window) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 100) END Caption; PROCEDURE (this: Window) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 106) END Visible; PROCEDURE (this: Window) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 106, p1) END PUTVisible; PROCEDURE (this: Window) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Left; PROCEDURE (this: Window) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTLeft; PROCEDURE (this: Window) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END Top; PROCEDURE (this: Window) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTTop; PROCEDURE (this: Window) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Width; PROCEDURE (this: Window) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTWidth; PROCEDURE (this: Window) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END Height; PROCEDURE (this: Window) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTHeight; PROCEDURE (this: Window) WindowState* (): vbext_WindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END WindowState; PROCEDURE (this: Window) PUTWindowState* (p1: vbext_WindowState), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTWindowState; PROCEDURE (this: Window) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 111, NIL); END SetFocus; PROCEDURE (this: Window) Type* (): vbext_WindowType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Type; PROCEDURE (this: Window) LinkedWindows* (): LinkedWindows, NEW; BEGIN RETURN This_LinkedWindows(CtlC.GetAny(this, 116)) END LinkedWindows; PROCEDURE (this: Window) LinkedWindowFrame* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 117)) END LinkedWindowFrame; PROCEDURE (this: Window) HWnd* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 120) END HWnd; (* ---------- _Windows, dual ---------- *) PROCEDURE (this: _Windows) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1)) END VBE; PROCEDURE (this: _Windows) Parent* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _Windows) Item* (index: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Windows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 201) END Count; PROCEDURE (this: _Windows) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _LinkedWindows, dual ---------- *) PROCEDURE (this: _LinkedWindows) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1)) END VBE; PROCEDURE (this: _LinkedWindows) Parent* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _LinkedWindows) Item* (index: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _LinkedWindows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 201) END Count; PROCEDURE (this: _LinkedWindows) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _LinkedWindows) Remove* (window: Window), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(window, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END Remove; PROCEDURE (this: _LinkedWindows) Add* (window: Window), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(window, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END Add; (* ---------- Events, dual ---------- *) PROCEDURE (this: Events) ReferencesEvents* (vBProject: VBProject): CtlT.IUnknown, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(vBProject, arg[0]); CtlC.CallGetMethod(this, 202, arg, ret); RETURN CtlC.VarIntfce(ret) END ReferencesEvents; PROCEDURE (this: Events) CommandBarEvents* (CommandBarControl: CtlT.Object): CtlT.IUnknown, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(CommandBarControl, arg[0]); CtlC.CallGetMethod(this, 205, arg, ret); RETURN CtlC.VarIntfce(ret) END CommandBarEvents; (* ---------- _dispVBProjectsEvents ---------- *) PROCEDURE (this: _dispVBProjectsEvents) ItemAdded* (vBProject: VBProject), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBProject, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); END ItemAdded; PROCEDURE (this: _dispVBProjectsEvents) ItemRemoved* (vBProject: VBProject), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBProject, arg[0]); CtlC.CallParMethod(this, 2, arg, NIL); END ItemRemoved; PROCEDURE (this: _dispVBProjectsEvents) ItemRenamed* (vBProject: VBProject; OldName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBProject, arg[1]); CtlC.StrVar(OldName, arg[0]); CtlC.CallParMethod(this, 3, arg, NIL); END ItemRenamed; PROCEDURE (this: _dispVBProjectsEvents) ItemActivated* (vBProject: VBProject), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBProject, arg[0]); CtlC.CallParMethod(this, 4, arg, NIL); END ItemActivated; (* ---------- _dispVBComponentsEvents ---------- *) PROCEDURE (this: _dispVBComponentsEvents) ItemAdded* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 1, arg, NIL); END ItemAdded; PROCEDURE (this: _dispVBComponentsEvents) ItemRemoved* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 2, arg, NIL); END ItemRemoved; PROCEDURE (this: _dispVBComponentsEvents) ItemRenamed* (vBComponent: VBComponent; OldName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[1]); CtlC.StrVar(OldName, arg[0]); CtlC.CallParMethod(this, 3, arg, NIL); END ItemRenamed; PROCEDURE (this: _dispVBComponentsEvents) ItemSelected* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 4, arg, NIL); END ItemSelected; PROCEDURE (this: _dispVBComponentsEvents) ItemActivated* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 5, arg, NIL); END ItemActivated; PROCEDURE (this: _dispVBComponentsEvents) ItemReloaded* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 6, arg, NIL); END ItemReloaded; (* ---------- _dispReferencesEvents ---------- *) PROCEDURE (this: _dispReferencesEvents) ItemAdded* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _dispReferencesEvents) ItemRemoved* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _dispReferencesEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1: ASSERT(n = 1, 11); this.ItemAdded(ThisReference(CtlC.VarAny(par[0]))) | 2: ASSERT(n = 1, 11); this.ItemRemoved(ThisReference(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: _dispReferencesEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0002E118-0000-0000-C000-000000000046}" END GetIID; (* ---------- _dispCommandBarControlEvents ---------- *) PROCEDURE (this: _dispCommandBarControlEvents) Click* (CommandBarControl: CtlT.Object; VAR handled: BOOLEAN; VAR CancelDefault: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: _dispCommandBarControlEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 1: ASSERT(n = 3, 11); this.Click(CtlC.VarObj(par[2]), CtlC.VarRefBool(par[1])[0], CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[1]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: _dispCommandBarControlEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{0002E131-0000-0000-C000-000000000046}" END GetIID; (* ---------- _ProjectTemplate, hidden, dual ---------- *) PROCEDURE (this: _ProjectTemplate) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _ProjectTemplate) Parent* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 2)) END Parent; (* ---------- _VBProject, hidden, dual ---------- *) PROCEDURE (this: _VBProject) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _VBProject) Parent* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _VBProject) HelpFile* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END HelpFile; PROCEDURE (this: _VBProject) PUTHelpFile* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTHelpFile; PROCEDURE (this: _VBProject) HelpContextID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END HelpContextID; PROCEDURE (this: _VBProject) PUTHelpContextID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTHelpContextID; PROCEDURE (this: _VBProject) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 118) END Description; PROCEDURE (this: _VBProject) PUTDescription* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 118, p1) END PUTDescription; PROCEDURE (this: _VBProject) Mode* (): vbext_VBAMode, NEW; BEGIN RETURN CtlC.GetInt(this, 119) END Mode; PROCEDURE (this: _VBProject) References* (): References, NEW; BEGIN RETURN This_References(CtlC.GetAny(this, 120)) END References; PROCEDURE (this: _VBProject) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 121) END Name; PROCEDURE (this: _VBProject) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 121, p1) END PUTName; PROCEDURE (this: _VBProject) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 122)) END VBE; PROCEDURE (this: _VBProject) Collection* (): VBProjects, NEW; BEGIN RETURN This_VBProjects(CtlC.GetAny(this, 123)) END Collection; PROCEDURE (this: _VBProject) Protection* (): vbext_ProjectProtection, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END Protection; PROCEDURE (this: _VBProject) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 133) END Saved; PROCEDURE (this: _VBProject) VBComponents* (): VBComponents, NEW; BEGIN RETURN This_VBComponents(CtlC.GetAny(this, 135)) END VBComponents; (* ---------- _VBProjects, dual ---------- *) PROCEDURE (this: _VBProjects) Item* (index: CtlT.Any): VBProject, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_VBProject(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _VBProjects) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 20)) END VBE; PROCEDURE (this: _VBProjects) Parent* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _VBProjects) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Count; PROCEDURE (this: _VBProjects) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- SelectedComponents, hidden, dual ---------- *) PROCEDURE (this: SelectedComponents) Item* (index: INTEGER): Component, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Component(CtlC.VarAny(ret)) END Item; PROCEDURE (this: SelectedComponents) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: SelectedComponents) Parent* (): VBProject, NEW; BEGIN RETURN This_VBProject(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: SelectedComponents) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Count; PROCEDURE (this: SelectedComponents) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; (* ---------- _Components, hidden, dual ---------- *) PROCEDURE (this: _Components) Item* (index: CtlT.Any): Component, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Component(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Components) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _Components) Parent* (): VBProject, NEW; BEGIN RETURN This_VBProject(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _Components) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Count; PROCEDURE (this: _Components) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Components) Remove* (component: Component), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(component, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Remove; PROCEDURE (this: _Components) Add* (ComponentType: vbext_ComponentType): Component, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ComponentType, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN This_Component(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _Components) Import* (FileName: ARRAY OF CHAR): Component, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN This_Component(CtlC.VarAny(ret)) END Import; PROCEDURE (this: _Components) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 20)) END VBE; (* ---------- _VBComponents, dual ---------- *) PROCEDURE (this: _VBComponents) Item* (index: CtlT.Any): VBComponent, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_VBComponent(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _VBComponents) Parent* (): VBProject, NEW; BEGIN RETURN This_VBProject(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _VBComponents) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Count; PROCEDURE (this: _VBComponents) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _VBComponents) Remove* (vBComponent: VBComponent), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(vBComponent, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Remove; PROCEDURE (this: _VBComponents) Add* (ComponentType: vbext_ComponentType): VBComponent, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(ComponentType, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN This_VBComponent(CtlC.VarAny(ret)) END Add; PROCEDURE (this: _VBComponents) Import* (FileName: ARRAY OF CHAR): VBComponent, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN This_VBComponent(CtlC.VarAny(ret)) END Import; PROCEDURE (this: _VBComponents) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 20)) END VBE; (* ---------- _Component, hidden, dual ---------- *) PROCEDURE (this: _Component) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _Component) Parent* (): Components, NEW; BEGIN RETURN This_Components(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: _Component) IsDirty* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END IsDirty; PROCEDURE (this: _Component) PUTIsDirty* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTIsDirty; PROCEDURE (this: _Component) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 48) END Name; PROCEDURE (this: _Component) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 48, p1) END PUTName; (* ---------- _VBComponent, dual ---------- *) PROCEDURE (this: _VBComponent) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Saved; PROCEDURE (this: _VBComponent) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 48) END Name; PROCEDURE (this: _VBComponent) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 48, p1) END PUTName; PROCEDURE (this: _VBComponent) Designer* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 49) END Designer; PROCEDURE (this: _VBComponent) CodeModule* (): CodeModule, NEW; BEGIN RETURN This_CodeModule(CtlC.GetAny(this, 50)) END CodeModule; PROCEDURE (this: _VBComponent) Type* (): vbext_ComponentType, NEW; BEGIN RETURN CtlC.GetInt(this, 51) END Type; PROCEDURE (this: _VBComponent) Export* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 52, arg, NIL); END Export; PROCEDURE (this: _VBComponent) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 53)) END VBE; PROCEDURE (this: _VBComponent) Collection* (): VBComponents, NEW; BEGIN RETURN This_VBComponents(CtlC.GetAny(this, 54)) END Collection; PROCEDURE (this: _VBComponent) HasOpenDesigner* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 55) END HasOpenDesigner; PROCEDURE (this: _VBComponent) Properties* (): Properties, NEW; BEGIN RETURN This_Properties(CtlC.GetAny(this, 56)) END Properties; PROCEDURE (this: _VBComponent) DesignerWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 57, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END DesignerWindow; PROCEDURE (this: _VBComponent) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 60, NIL); END Activate; (* ---------- Property, dual ---------- *) PROCEDURE (this: Property) Value* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Value; PROCEDURE (this: Property) PUTValue* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTValue; PROCEDURE (this: Property) IndexedValue* (Index1: CtlT.Any; (* optional *) Index2: CtlT.Any; Index3: CtlT.Any; Index4: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[3]); CtlC.AnyVar(Index2, arg[2]); CtlC.AnyVar(Index3, arg[1]); CtlC.AnyVar(Index4, arg[0]); CtlC.CallGetMethod(this, 3, arg, ret); RETURN CtlC.VarAny(ret) END IndexedValue; PROCEDURE (this: Property) PUTIndexedValue* (Index1: CtlT.Any; Index2: CtlT.Any; (* optional *) Index3: CtlT.Any; Index4: CtlT.Any; p5: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(Index1, arg[4]); CtlC.AnyVar(Index2, arg[3]); CtlC.AnyVar(Index3, arg[2]); CtlC.AnyVar(Index4, arg[1]); CtlC.AnyVar(p5, arg[0]); CtlC.CallPutMethod(this, 3, arg, NIL); END PUTIndexedValue; PROCEDURE (this: Property) NumIndices* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 4) END NumIndices; PROCEDURE (this: Property) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: Property) Parent* (): Properties, NEW; BEGIN RETURN This_Properties(CtlC.GetAny(this, 2)) END Parent; PROCEDURE (this: Property) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 40) END Name; PROCEDURE (this: Property) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 41)) END VBE; PROCEDURE (this: Property) Collection* (): Properties, NEW; BEGIN RETURN This_Properties(CtlC.GetAny(this, 42)) END Collection; PROCEDURE (this: Property) Object* (): CtlT.IUnknown, NEW; BEGIN RETURN CtlC.GetIntfce(this, 45) END Object; PROCEDURE (this: Property) PUTREFObject* (p1: CtlT.IUnknown), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntfceVar(p1, arg[0]); CtlC.CallPutRefMethod(this, 45, arg, NIL); END PUTREFObject; (* ---------- _Properties, dual ---------- *) PROCEDURE (this: _Properties) Item* (index: CtlT.Any): Property, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisProperty(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _Properties) Application* (): Application, NEW; BEGIN RETURN ThisApplication(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _Properties) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2) END Parent; PROCEDURE (this: _Properties) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 40) END Count; PROCEDURE (this: _Properties) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _Properties) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 10)) END VBE; (* ---------- _CodeModule, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _CodeModule) Parent* (): VBComponent, NEW; BEGIN RETURN This_VBComponent(CtlC.GetAny(this, 1610743808)) END Parent; PROCEDURE (this: _CodeModule) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743809)) END VBE; PROCEDURE (this: _CodeModule) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _CodeModule) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: _CodeModule) AddFromString* (String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, NIL); END AddFromString; PROCEDURE (this: _CodeModule) AddFromFile* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743813, arg, NIL); END AddFromFile; PROCEDURE (this: _CodeModule) Lines* (StartLine: INTEGER; Count: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(StartLine, arg[1]); CtlC.IntVar(Count, arg[0]); CtlC.CallGetMethod(this, 1610743814, arg, ret); RETURN CtlC.VarStr(ret) END Lines; PROCEDURE (this: _CodeModule) CountOfLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743815) END CountOfLines; PROCEDURE (this: _CodeModule) InsertLines* (Line: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743816, arg, NIL); END InsertLines; PROCEDURE (this: _CodeModule) DeleteLines* (StartLine: INTEGER; Count: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(StartLine, arg[1]); CtlC.IntVar(Count, arg[0]); CtlC.CallParMethod(this, 1610743817, arg, NIL); END DeleteLines; PROCEDURE (this: _CodeModule) ReplaceLine* (Line: INTEGER; String: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 1610743818, arg, NIL); END ReplaceLine; PROCEDURE (this: _CodeModule) ProcStartLine* (ProcName: ARRAY OF CHAR; ProcKind: vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743819, arg, ret); RETURN CtlC.VarInt(ret) END ProcStartLine; PROCEDURE (this: _CodeModule) ProcCountLines* (ProcName: ARRAY OF CHAR; ProcKind: vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743820, arg, ret); RETURN CtlC.VarInt(ret) END ProcCountLines; PROCEDURE (this: _CodeModule) ProcBodyLine* (ProcName: ARRAY OF CHAR; ProcKind: vbext_ProcKind): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(ProcName, arg[1]); CtlC.IntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743821, arg, ret); RETURN CtlC.VarInt(ret) END ProcBodyLine; PROCEDURE (this: _CodeModule) ProcOfLine* (Line: INTEGER; OUT ProcKind: vbext_ProcKind): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Line, arg[1]); CtlC.RefIntVar(ProcKind, arg[0]); CtlC.CallGetMethod(this, 1610743822, arg, ret); RETURN CtlC.VarStr(ret) END ProcOfLine; PROCEDURE (this: _CodeModule) CountOfDeclarationLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743823) END CountOfDeclarationLines; PROCEDURE (this: _CodeModule) CreateEventProc* (EventName: ARRAY OF CHAR; ObjectName: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(EventName, arg[1]); CtlC.StrVar(ObjectName, arg[0]); CtlC.CallParMethod(this, 1610743824, arg, ret); RETURN CtlC.VarInt(ret) END CreateEventProc; PROCEDURE (this: _CodeModule) Find* (Target: ARRAY OF CHAR; VAR StartLine: INTEGER; VAR StartColumn: INTEGER; VAR EndLine: INTEGER; VAR EndColumn: INTEGER; WholeWord: BOOLEAN; MatchCase: BOOLEAN; PatternSearch: BOOLEAN): BOOLEAN, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Target, arg[7]); CtlC.RefIntVar(StartLine, arg[6]); CtlC.RefIntVar(StartColumn, arg[5]); CtlC.RefIntVar(EndLine, arg[4]); CtlC.RefIntVar(EndColumn, arg[3]); CtlC.BoolVar(WholeWord, arg[2]); CtlC.BoolVar(MatchCase, arg[1]); CtlC.BoolVar(PatternSearch, arg[0]); CtlC.CallParMethod(this, 1610743825, arg, ret); RETURN CtlC.VarBool(ret) END Find; PROCEDURE (this: _CodeModule) CodePane* (): CodePane, NEW; BEGIN RETURN This_CodePane(CtlC.GetAny(this, 1610743826)) END CodePane; (* ---------- _CodePanes, dual, nonextensible ---------- *) PROCEDURE (this: _CodePanes) Parent* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743808)) END Parent; PROCEDURE (this: _CodePanes) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743809)) END VBE; PROCEDURE (this: _CodePanes) Item* (index: CtlT.Any): CodePane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_CodePane(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _CodePanes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Count; PROCEDURE (this: _CodePanes) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _CodePanes) Current* (): CodePane, NEW; BEGIN RETURN This_CodePane(CtlC.GetAny(this, 1610743813)) END Current; PROCEDURE (this: _CodePanes) PUTCurrent* (p1: CodePane), NEW; BEGIN CtlC.PutObj(this, 1610743813, p1) END PUTCurrent; (* ---------- _CodePane, dual, nonextensible ---------- *) PROCEDURE (this: _CodePane) Collection* (): CodePanes, NEW; BEGIN RETURN This_CodePanes(CtlC.GetAny(this, 1610743808)) END Collection; PROCEDURE (this: _CodePane) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743809)) END VBE; PROCEDURE (this: _CodePane) Window* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 1610743810)) END Window; PROCEDURE (this: _CodePane) GetSelection* (OUT StartLine: INTEGER; OUT StartColumn: INTEGER; OUT EndLine: INTEGER; OUT EndColumn: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.RefIntVar(StartLine, arg[3]); CtlC.RefIntVar(StartColumn, arg[2]); CtlC.RefIntVar(EndLine, arg[1]); CtlC.RefIntVar(EndColumn, arg[0]); CtlC.CallParMethod(this, 1610743811, arg, NIL); END GetSelection; PROCEDURE (this: _CodePane) SetSelection* (StartLine: INTEGER; StartColumn: INTEGER; EndLine: INTEGER; EndColumn: INTEGER), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(StartLine, arg[3]); CtlC.IntVar(StartColumn, arg[2]); CtlC.IntVar(EndLine, arg[1]); CtlC.IntVar(EndColumn, arg[0]); CtlC.CallParMethod(this, 1610743812, arg, NIL); END SetSelection; PROCEDURE (this: _CodePane) TopLine* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743813) END TopLine; PROCEDURE (this: _CodePane) PUTTopLine* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1610743813, p1) END PUTTopLine; PROCEDURE (this: _CodePane) CountOfVisibleLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743815) END CountOfVisibleLines; PROCEDURE (this: _CodePane) CodeModule* (): CodeModule, NEW; BEGIN RETURN This_CodeModule(CtlC.GetAny(this, 1610743816)) END CodeModule; PROCEDURE (this: _CodePane) Show* (), NEW; BEGIN CtlC.CallMethod(this, 1610743817, NIL); END Show; PROCEDURE (this: _CodePane) CodePaneView* (): vbext_CodePaneview, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743818) END CodePaneView; (* ---------- _References, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _References) Parent* (): VBProject, NEW; BEGIN RETURN This_VBProject(CtlC.GetAny(this, 1610743808)) END Parent; PROCEDURE (this: _References) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743809)) END VBE; PROCEDURE (this: _References) Item* (index: CtlT.Any): Reference, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END Item; PROCEDURE (this: _References) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743811) END Count; PROCEDURE (this: _References) _NewEnum* (): CtlT.Enumerator, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, -4, ret); RETURN CtlC.VarEnum(ret) END _NewEnum; PROCEDURE (this: _References) AddFromGuid* (Guid: ARRAY OF CHAR; Major: INTEGER; Minor: INTEGER): Reference, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Guid, arg[2]); CtlC.IntVar(Major, arg[1]); CtlC.IntVar(Minor, arg[0]); CtlC.CallParMethod(this, 1610743813, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END AddFromGuid; PROCEDURE (this: _References) AddFromFile* (FileName: ARRAY OF CHAR): Reference, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 1610743814, arg, ret); RETURN ThisReference(CtlC.VarAny(ret)) END AddFromFile; PROCEDURE (this: _References) Remove* (reference: Reference), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(reference, arg[0]); CtlC.CallParMethod(this, 1610743815, arg, NIL); END Remove; (* ---------- Reference, dual, nonextensible ---------- *) PROCEDURE (this: Reference) Collection* (): References, NEW; BEGIN RETURN This_References(CtlC.GetAny(this, 1610743808)) END Collection; PROCEDURE (this: Reference) VBE* (): VBE, NEW; BEGIN RETURN ThisVBE(CtlC.GetAny(this, 1610743809)) END VBE; PROCEDURE (this: Reference) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743810) END Name; PROCEDURE (this: Reference) Guid* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743811) END Guid; PROCEDURE (this: Reference) Major* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743812) END Major; PROCEDURE (this: Reference) Minor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743813) END Minor; PROCEDURE (this: Reference) FullPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743814) END FullPath; PROCEDURE (this: Reference) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743815) END BuiltIn; PROCEDURE (this: Reference) IsBroken* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1610743816) END IsBroken; PROCEDURE (this: Reference) Type* (): vbext_RefKind, NEW; BEGIN RETURN CtlC.GetInt(this, 1610743817) END Type; PROCEDURE (this: Reference) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1610743818) END Description; (* ---------- _dispReferences_Events, hidden, nonextensible ---------- *) PROCEDURE (this: _dispReferences_Events) ItemAdded* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _dispReferences_Events) ItemRemoved* (reference: Reference), NEW, ABSTRACT; PROCEDURE (this: _dispReferences_Events) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 0: ASSERT(n = 1, 11); this.ItemAdded(ThisReference(CtlC.VarAny(par[0]))) | 1: ASSERT(n = 1, 11); this.ItemRemoved(ThisReference(CtlC.VarAny(par[0]))) END END Invoke; PROCEDURE (this: _dispReferences_Events) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{CDDE3804-2064-11CF-867F-00AA005FF34A}" END GetIID; PROCEDURE NewWindows* (): _Windows; BEGIN RETURN This_Windows(CtlC.NewObj("{0002E185-0000-0000-C000-000000000046}")) END NewWindows; PROCEDURE NewLinkedWindows* (): _LinkedWindows; BEGIN RETURN This_LinkedWindows(CtlC.NewObj("{0002E187-0000-0000-C000-000000000046}")) END NewLinkedWindows; PROCEDURE NewProjectTemplate* (): _ProjectTemplate; BEGIN RETURN This_ProjectTemplate(CtlC.NewObj("{32CDF9E0-1602-11CE-BFDC-08002B2B8CDA}")) END NewProjectTemplate; PROCEDURE NewVBProject* (): _VBProject; BEGIN RETURN This_VBProject(CtlC.NewObj("{0002E169-0000-0000-C000-000000000046}")) END NewVBProject; PROCEDURE NewVBProjects* (): _VBProjects; BEGIN RETURN This_VBProjects(CtlC.NewObj("{0002E101-0000-0000-C000-000000000046}")) END NewVBProjects; PROCEDURE NewComponents* (): _Components; BEGIN RETURN This_Components(CtlC.NewObj("{BE39F3D6-1B13-11D0-887F-00A0C90F2744}")) END NewComponents; PROCEDURE NewVBComponents* (): _VBComponents; BEGIN RETURN This_VBComponents(CtlC.NewObj("{BE39F3D7-1B13-11D0-887F-00A0C90F2744}")) END NewVBComponents; PROCEDURE NewComponent* (): _Component; BEGIN RETURN This_Component(CtlC.NewObj("{BE39F3D8-1B13-11D0-887F-00A0C90F2744}")) END NewComponent; PROCEDURE NewVBComponent* (): _VBComponent; BEGIN RETURN This_VBComponent(CtlC.NewObj("{BE39F3DA-1B13-11D0-887F-00A0C90F2744}")) END NewVBComponent; PROCEDURE NewProperties* (): _Properties; BEGIN RETURN This_Properties(CtlC.NewObj("{0002E18B-0000-0000-C000-000000000046}")) END NewProperties; PROCEDURE NewCodeModule* (): _CodeModule; BEGIN RETURN This_CodeModule(CtlC.NewObj("{0002E170-0000-0000-C000-000000000046}")) END NewCodeModule; PROCEDURE NewCodePanes* (): _CodePanes; BEGIN RETURN This_CodePanes(CtlC.NewObj("{0002E174-0000-0000-C000-000000000046}")) END NewCodePanes; PROCEDURE NewCodePane* (): _CodePane; BEGIN RETURN This_CodePane(CtlC.NewObj("{0002E178-0000-0000-C000-000000000046}")) END NewCodePane; PROCEDURE NewReferences* (): _References; BEGIN RETURN This_References(CtlC.NewObj("{0002E17C-0000-0000-C000-000000000046}")) END NewReferences; END CtlVBIDE.

Ctl/Mod/VBIDE.odc

MODULE CtlWord9; (** project = "BlackBox" organization = "www.oberon.ch" contributors = "Oberon microsystems" version = "System/Rsrc/About" copyright = "System/Rsrc/About" license = "Docu/BB-License" changes = " - YYYYMMDD, nn, ... " issues = " - ... " **) (* Microsoft Word 9.0 Object Library, help: C:\Program Files\Microsoft Office\Office\VBAWRD9.CHM, id: 0 *) (* guid: {00020905-0000-0000-C000-000000000046}, lcid: 0, syskind: win32, version: 8.1 *) IMPORT CtlT, CtlC, CtlOffice, CtlVBIDE; CONST (* WdMailSystem *) wdNoMailSystem* = 0; wdMAPI* = 1; wdPowerTalk* = 2; wdMAPIandPowerTalk* = 3; (* WdTemplateType *) wdNormalTemplate* = 0; wdGlobalTemplate* = 1; wdAttachedTemplate* = 2; (* WdContinue *) wdContinueDisabled* = 0; wdResetList* = 1; wdContinueList* = 2; (* WdIMEMode *) wdIMEModeNoControl* = 0; wdIMEModeOn* = 1; wdIMEModeOff* = 2; wdIMEModeHiragana* = 4; wdIMEModeKatakana* = 5; wdIMEModeKatakanaHalf* = 6; wdIMEModeAlphaFull* = 7; wdIMEModeAlpha* = 8; wdIMEModeHangulFull* = 9; wdIMEModeHangul* = 10; (* WdBaselineAlignment *) wdBaselineAlignTop* = 0; wdBaselineAlignCenter* = 1; wdBaselineAlignBaseline* = 2; wdBaselineAlignFarEast50* = 3; wdBaselineAlignAuto* = 4; (* WdIndexFilter *) wdIndexFilterNone* = 0; wdIndexFilterAiueo* = 1; wdIndexFilterAkasatana* = 2; wdIndexFilterChosung* = 3; wdIndexFilterLow* = 4; wdIndexFilterMedium* = 5; wdIndexFilterFull* = 6; (* WdIndexSortBy *) wdIndexSortByStroke* = 0; wdIndexSortBySyllable* = 1; (* WdJustificationMode *) wdJustificationModeExpand* = 0; wdJustificationModeCompress* = 1; wdJustificationModeCompressKana* = 2; (* WdFarEastLineBreakLevel *) wdFarEastLineBreakLevelNormal* = 0; wdFarEastLineBreakLevelStrict* = 1; wdFarEastLineBreakLevelCustom* = 2; (* WdMultipleWordConversionsMode *) wdHangulToHanja* = 0; wdHanjaToHangul* = 1; (* WdColorIndex *) wdAuto* = 0; wdBlack* = 1; wdBlue* = 2; wdTurquoise* = 3; wdBrightGreen* = 4; wdPink* = 5; wdRed* = 6; wdYellow* = 7; wdWhite* = 8; wdDarkBlue* = 9; wdTeal* = 10; wdGreen* = 11; wdViolet* = 12; wdDarkRed* = 13; wdDarkYellow* = 14; wdGray50* = 15; wdGray25* = 16; wdByAuthor* = -1; wdNoHighlight* = 0; (* WdTextureIndex *) wdTextureNone* = 0; wdTexture2Pt5Percent* = 25; wdTexture5Percent* = 50; wdTexture7Pt5Percent* = 75; wdTexture10Percent* = 100; wdTexture12Pt5Percent* = 125; wdTexture15Percent* = 150; wdTexture17Pt5Percent* = 175; wdTexture20Percent* = 200; wdTexture22Pt5Percent* = 225; wdTexture25Percent* = 250; wdTexture27Pt5Percent* = 275; wdTexture30Percent* = 300; wdTexture32Pt5Percent* = 325; wdTexture35Percent* = 350; wdTexture37Pt5Percent* = 375; wdTexture40Percent* = 400; wdTexture42Pt5Percent* = 425; wdTexture45Percent* = 450; wdTexture47Pt5Percent* = 475; wdTexture50Percent* = 500; wdTexture52Pt5Percent* = 525; wdTexture55Percent* = 550; wdTexture57Pt5Percent* = 575; wdTexture60Percent* = 600; wdTexture62Pt5Percent* = 625; wdTexture65Percent* = 650; wdTexture67Pt5Percent* = 675; wdTexture70Percent* = 700; wdTexture72Pt5Percent* = 725; wdTexture75Percent* = 750; wdTexture77Pt5Percent* = 775; wdTexture80Percent* = 800; wdTexture82Pt5Percent* = 825; wdTexture85Percent* = 850; wdTexture87Pt5Percent* = 875; wdTexture90Percent* = 900; wdTexture92Pt5Percent* = 925; wdTexture95Percent* = 950; wdTexture97Pt5Percent* = 975; wdTextureSolid* = 1000; wdTextureDarkHorizontal* = -1; wdTextureDarkVertical* = -2; wdTextureDarkDiagonalDown* = -3; wdTextureDarkDiagonalUp* = -4; wdTextureDarkCross* = -5; wdTextureDarkDiagonalCross* = -6; wdTextureHorizontal* = -7; wdTextureVertical* = -8; wdTextureDiagonalDown* = -9; wdTextureDiagonalUp* = -10; wdTextureCross* = -11; wdTextureDiagonalCross* = -12; (* WdUnderline *) wdUnderlineNone* = 0; wdUnderlineSingle* = 1; wdUnderlineWords* = 2; wdUnderlineDouble* = 3; wdUnderlineDotted* = 4; wdUnderlineThick* = 6; wdUnderlineDash* = 7; wdUnderlineDotDash* = 9; wdUnderlineDotDotDash* = 10; wdUnderlineWavy* = 11; wdUnderlineWavyHeavy* = 27; wdUnderlineDottedHeavy* = 20; wdUnderlineDashHeavy* = 23; wdUnderlineDotDashHeavy* = 25; wdUnderlineDotDotDashHeavy* = 26; wdUnderlineDashLong* = 39; wdUnderlineDashLongHeavy* = 55; wdUnderlineWavyDouble* = 43; (* WdEmphasisMark *) wdEmphasisMarkNone* = 0; wdEmphasisMarkOverSolidCircle* = 1; wdEmphasisMarkOverComma* = 2; wdEmphasisMarkOverWhiteCircle* = 3; wdEmphasisMarkUnderSolidCircle* = 4; (* WdInternationalIndex *) wdListSeparator* = 17; wdDecimalSeparator* = 18; wdThousandsSeparator* = 19; wdCurrencyCode* = 20; wd24HourClock* = 21; wdInternationalAM* = 22; wdInternationalPM* = 23; wdTimeSeparator* = 24; wdDateSeparator* = 25; wdProductLanguageID* = 26; (* WdAutoMacros *) wdAutoExec* = 0; wdAutoNew* = 1; wdAutoOpen* = 2; wdAutoClose* = 3; wdAutoExit* = 4; (* WdCaptionPosition *) wdCaptionPositionAbove* = 0; wdCaptionPositionBelow* = 1; (* WdCountry *) wdUS* = 1; wdCanada* = 2; wdLatinAmerica* = 3; wdNetherlands* = 31; wdFrance* = 33; wdSpain* = 34; wdItaly* = 39; wdUK* = 44; wdDenmark* = 45; wdSweden* = 46; wdNorway* = 47; wdGermany* = 49; wdPeru* = 51; wdMexico* = 52; wdArgentina* = 54; wdBrazil* = 55; wdChile* = 56; wdVenezuela* = 58; wdJapan* = 81; wdTaiwan* = 886; wdChina* = 86; wdKorea* = 82; wdFinland* = 358; wdIceland* = 354; (* WdHeadingSeparator *) wdHeadingSeparatorNone* = 0; wdHeadingSeparatorBlankLine* = 1; wdHeadingSeparatorLetter* = 2; wdHeadingSeparatorLetterLow* = 3; wdHeadingSeparatorLetterFull* = 4; (* WdSeparatorType *) wdSeparatorHyphen* = 0; wdSeparatorPeriod* = 1; wdSeparatorColon* = 2; wdSeparatorEmDash* = 3; wdSeparatorEnDash* = 4; (* WdPageNumberAlignment *) wdAlignPageNumberLeft* = 0; wdAlignPageNumberCenter* = 1; wdAlignPageNumberRight* = 2; wdAlignPageNumberInside* = 3; wdAlignPageNumberOutside* = 4; (* WdBorderType *) wdBorderTop* = -1; wdBorderLeft* = -2; wdBorderBottom* = -3; wdBorderRight* = -4; wdBorderHorizontal* = -5; wdBorderVertical* = -6; wdBorderDiagonalDown* = -7; wdBorderDiagonalUp* = -8; (* WdBorderTypeHID, hidden *) emptyenum* = 0; (* WdFramePosition *) wdFrameTop* = -999999; wdFrameLeft* = -999998; wdFrameBottom* = -999997; wdFrameRight* = -999996; wdFrameCenter* = -999995; wdFrameInside* = -999994; wdFrameOutside* = -999993; (* WdAnimation *) wdAnimationNone* = 0; wdAnimationLasVegasLights* = 1; wdAnimationBlinkingBackground* = 2; wdAnimationSparkleText* = 3; wdAnimationMarchingBlackAnts* = 4; wdAnimationMarchingRedAnts* = 5; wdAnimationShimmer* = 6; (* WdCharacterCase *) wdNextCase* = -1; wdLowerCase* = 0; wdUpperCase* = 1; wdTitleWord* = 2; wdTitleSentence* = 4; wdToggleCase* = 5; wdHalfWidth* = 6; wdFullWidth* = 7; wdKatakana* = 8; wdHiragana* = 9; (* WdCharacterCaseHID, hidden *) (* emptyenum* = 0; *) (* WdSummaryMode *) wdSummaryModeHighlight* = 0; wdSummaryModeHideAllButSummary* = 1; wdSummaryModeInsert* = 2; wdSummaryModeCreateNew* = 3; (* WdSummaryLength *) wd10Sentences* = -2; wd20Sentences* = -3; wd100Words* = -4; wd500Words* = -5; wd10Percent* = -6; wd25Percent* = -7; wd50Percent* = -8; wd75Percent* = -9; (* WdStyleType *) wdStyleTypeParagraph* = 1; wdStyleTypeCharacter* = 2; (* WdUnits *) wdCharacter* = 1; wdWord* = 2; wdSentence* = 3; wdParagraph* = 4; wdLine* = 5; wdStory* = 6; wdScreen* = 7; wdSection* = 8; wdColumn* = 9; wdRow* = 10; wdWindow* = 11; wdCell* = 12; wdCharacterFormatting* = 13; wdParagraphFormatting* = 14; wdTable* = 15; wdItem* = 16; (* WdGoToItem *) wdGoToBookmark* = -1; wdGoToSection* = 0; wdGoToPage* = 1; wdGoToTable* = 2; wdGoToLine* = 3; wdGoToFootnote* = 4; wdGoToEndnote* = 5; wdGoToComment* = 6; wdGoToField* = 7; wdGoToGraphic* = 8; wdGoToObject* = 9; wdGoToEquation* = 10; wdGoToHeading* = 11; wdGoToPercent* = 12; wdGoToSpellingError* = 13; wdGoToGrammaticalError* = 14; wdGoToProofreadingError* = 15; (* WdGoToDirection *) wdGoToFirst* = 1; wdGoToLast* = -1; wdGoToNext* = 2; wdGoToRelative* = 2; wdGoToPrevious* = 3; wdGoToAbsolute* = 1; (* WdCollapseDirection *) wdCollapseStart* = 1; wdCollapseEnd* = 0; (* WdRowHeightRule *) wdRowHeightAuto* = 0; wdRowHeightAtLeast* = 1; wdRowHeightExactly* = 2; (* WdFrameSizeRule *) wdFrameAuto* = 0; wdFrameAtLeast* = 1; wdFrameExact* = 2; (* WdInsertCells *) wdInsertCellsShiftRight* = 0; wdInsertCellsShiftDown* = 1; wdInsertCellsEntireRow* = 2; wdInsertCellsEntireColumn* = 3; (* WdDeleteCells *) wdDeleteCellsShiftLeft* = 0; wdDeleteCellsShiftUp* = 1; wdDeleteCellsEntireRow* = 2; wdDeleteCellsEntireColumn* = 3; (* WdListApplyTo *) wdListApplyToWholeList* = 0; wdListApplyToThisPointForward* = 1; wdListApplyToSelection* = 2; (* WdAlertLevel *) wdAlertsNone* = 0; wdAlertsMessageBox* = -2; wdAlertsAll* = -1; (* WdCursorType *) wdCursorWait* = 0; wdCursorIBeam* = 1; wdCursorNormal* = 2; wdCursorNorthwestArrow* = 3; (* WdEnableCancelKey *) wdCancelDisabled* = 0; wdCancelInterrupt* = 1; (* WdRulerStyle *) wdAdjustNone* = 0; wdAdjustProportional* = 1; wdAdjustFirstColumn* = 2; wdAdjustSameWidth* = 3; (* WdParagraphAlignment *) wdAlignParagraphLeft* = 0; wdAlignParagraphCenter* = 1; wdAlignParagraphRight* = 2; wdAlignParagraphJustify* = 3; wdAlignParagraphDistribute* = 4; wdAlignParagraphJustifyMed* = 5; wdAlignParagraphJustifyHi* = 7; wdAlignParagraphJustifyLow* = 8; (* WdParagraphAlignmentHID, hidden *) (* emptyenum* = 0; *) (* WdListLevelAlignment *) wdListLevelAlignLeft* = 0; wdListLevelAlignCenter* = 1; wdListLevelAlignRight* = 2; (* WdRowAlignment *) wdAlignRowLeft* = 0; wdAlignRowCenter* = 1; wdAlignRowRight* = 2; (* WdTabAlignment *) wdAlignTabLeft* = 0; wdAlignTabCenter* = 1; wdAlignTabRight* = 2; wdAlignTabDecimal* = 3; wdAlignTabBar* = 4; wdAlignTabList* = 6; (* WdVerticalAlignment *) wdAlignVerticalTop* = 0; wdAlignVerticalCenter* = 1; wdAlignVerticalJustify* = 2; wdAlignVerticalBottom* = 3; (* WdCellVerticalAlignment *) wdCellAlignVerticalTop* = 0; wdCellAlignVerticalCenter* = 1; wdCellAlignVerticalBottom* = 3; (* WdTrailingCharacter *) wdTrailingTab* = 0; wdTrailingSpace* = 1; wdTrailingNone* = 2; (* WdListGalleryType *) wdBulletGallery* = 1; wdNumberGallery* = 2; wdOutlineNumberGallery* = 3; (* WdListNumberStyle *) wdListNumberStyleArabic* = 0; wdListNumberStyleUppercaseRoman* = 1; wdListNumberStyleLowercaseRoman* = 2; wdListNumberStyleUppercaseLetter* = 3; wdListNumberStyleLowercaseLetter* = 4; wdListNumberStyleOrdinal* = 5; wdListNumberStyleCardinalText* = 6; wdListNumberStyleOrdinalText* = 7; wdListNumberStyleKanji* = 10; wdListNumberStyleKanjiDigit* = 11; wdListNumberStyleAiueoHalfWidth* = 12; wdListNumberStyleIrohaHalfWidth* = 13; wdListNumberStyleArabicFullWidth* = 14; wdListNumberStyleKanjiTraditional* = 16; wdListNumberStyleKanjiTraditional2* = 17; wdListNumberStyleNumberInCircle* = 18; wdListNumberStyleAiueo* = 20; wdListNumberStyleIroha* = 21; wdListNumberStyleArabicLZ* = 22; wdListNumberStyleBullet* = 23; wdListNumberStyleGanada* = 24; wdListNumberStyleChosung* = 25; wdListNumberStyleGBNum1* = 26; wdListNumberStyleGBNum2* = 27; wdListNumberStyleGBNum3* = 28; wdListNumberStyleGBNum4* = 29; wdListNumberStyleZodiac1* = 30; wdListNumberStyleZodiac2* = 31; wdListNumberStyleZodiac3* = 32; wdListNumberStyleTradChinNum1* = 33; wdListNumberStyleTradChinNum2* = 34; wdListNumberStyleTradChinNum3* = 35; wdListNumberStyleTradChinNum4* = 36; wdListNumberStyleSimpChinNum1* = 37; wdListNumberStyleSimpChinNum2* = 38; wdListNumberStyleSimpChinNum3* = 39; wdListNumberStyleSimpChinNum4* = 40; wdListNumberStyleHanjaRead* = 41; wdListNumberStyleHanjaReadDigit* = 42; wdListNumberStyleHangul* = 43; wdListNumberStyleHanja* = 44; wdListNumberStyleHebrew1* = 45; wdListNumberStyleArabic1* = 46; wdListNumberStyleHebrew2* = 47; wdListNumberStyleArabic2* = 48; wdListNumberStyleLegal* = 253; wdListNumberStyleLegalLZ* = 254; wdListNumberStyleNone* = 255; (* WdListNumberStyleHID, hidden *) (* emptyenum* = 0; *) (* WdNoteNumberStyle *) wdNoteNumberStyleArabic* = 0; wdNoteNumberStyleUppercaseRoman* = 1; wdNoteNumberStyleLowercaseRoman* = 2; wdNoteNumberStyleUppercaseLetter* = 3; wdNoteNumberStyleLowercaseLetter* = 4; wdNoteNumberStyleSymbol* = 9; wdNoteNumberStyleArabicFullWidth* = 14; wdNoteNumberStyleKanji* = 10; wdNoteNumberStyleKanjiDigit* = 11; wdNoteNumberStyleKanjiTraditional* = 16; wdNoteNumberStyleNumberInCircle* = 18; wdNoteNumberStyleHanjaRead* = 41; wdNoteNumberStyleHanjaReadDigit* = 42; wdNoteNumberStyleTradChinNum1* = 33; wdNoteNumberStyleTradChinNum2* = 34; wdNoteNumberStyleSimpChinNum1* = 37; wdNoteNumberStyleSimpChinNum2* = 38; wdNoteNumberStyleHebrewLetter1* = 45; wdNoteNumberStyleArabicLetter1* = 46; wdNoteNumberStyleHebrewLetter2* = 47; wdNoteNumberStyleArabicLetter2* = 48; (* WdNoteNumberStyleHID, hidden *) (* emptyenum* = 0; *) (* WdCaptionNumberStyle *) wdCaptionNumberStyleArabic* = 0; wdCaptionNumberStyleUppercaseRoman* = 1; wdCaptionNumberStyleLowercaseRoman* = 2; wdCaptionNumberStyleUppercaseLetter* = 3; wdCaptionNumberStyleLowercaseLetter* = 4; wdCaptionNumberStyleArabicFullWidth* = 14; wdCaptionNumberStyleKanji* = 10; wdCaptionNumberStyleKanjiDigit* = 11; wdCaptionNumberStyleKanjiTraditional* = 16; wdCaptionNumberStyleNumberInCircle* = 18; wdCaptionNumberStyleGanada* = 24; wdCaptionNumberStyleChosung* = 25; wdCaptionNumberStyleZodiac1* = 30; wdCaptionNumberStyleZodiac2* = 31; wdCaptionNumberStyleHanjaRead* = 41; wdCaptionNumberStyleHanjaReadDigit* = 42; wdCaptionNumberStyleTradChinNum2* = 34; wdCaptionNumberStyleTradChinNum3* = 35; wdCaptionNumberStyleSimpChinNum2* = 38; wdCaptionNumberStyleSimpChinNum3* = 39; wdCaptionNumberStyleHebrewLetter1* = 45; wdCaptionNumberStyleArabicLetter1* = 46; wdCaptionNumberStyleHebrewLetter2* = 47; wdCaptionNumberStyleArabicLetter2* = 48; (* WdCaptionNumberStyleHID, hidden *) (* emptyenum* = 0; *) (* WdPageNumberStyle *) wdPageNumberStyleArabic* = 0; wdPageNumberStyleUppercaseRoman* = 1; wdPageNumberStyleLowercaseRoman* = 2; wdPageNumberStyleUppercaseLetter* = 3; wdPageNumberStyleLowercaseLetter* = 4; wdPageNumberStyleArabicFullWidth* = 14; wdPageNumberStyleKanji* = 10; wdPageNumberStyleKanjiDigit* = 11; wdPageNumberStyleKanjiTraditional* = 16; wdPageNumberStyleNumberInCircle* = 18; wdPageNumberStyleHanjaRead* = 41; wdPageNumberStyleHanjaReadDigit* = 42; wdPageNumberStyleTradChinNum1* = 33; wdPageNumberStyleTradChinNum2* = 34; wdPageNumberStyleSimpChinNum1* = 37; wdPageNumberStyleSimpChinNum2* = 38; wdPageNumberStyleHebrewLetter1* = 45; wdPageNumberStyleArabicLetter1* = 46; wdPageNumberStyleHebrewLetter2* = 47; wdPageNumberStyleArabicLetter2* = 48; (* WdPageNumberStyleHID, hidden *) (* emptyenum* = 0; *) (* WdStatistic *) wdStatisticWords* = 0; wdStatisticLines* = 1; wdStatisticPages* = 2; wdStatisticCharacters* = 3; wdStatisticParagraphs* = 4; wdStatisticCharactersWithSpaces* = 5; wdStatisticFarEastCharacters* = 6; (* WdStatisticHID, hidden *) (* emptyenum* = 0; *) (* WdBuiltInProperty *) wdPropertyTitle* = 1; wdPropertySubject* = 2; wdPropertyAuthor* = 3; wdPropertyKeywords* = 4; wdPropertyComments* = 5; wdPropertyTemplate* = 6; wdPropertyLastAuthor* = 7; wdPropertyRevision* = 8; wdPropertyAppName* = 9; wdPropertyTimeLastPrinted* = 10; wdPropertyTimeCreated* = 11; wdPropertyTimeLastSaved* = 12; wdPropertyVBATotalEdit* = 13; wdPropertyPages* = 14; wdPropertyWords* = 15; wdPropertyCharacters* = 16; wdPropertySecurity* = 17; wdPropertyCategory* = 18; wdPropertyFormat* = 19; wdPropertyManager* = 20; wdPropertyCompany* = 21; wdPropertyBytes* = 22; wdPropertyLines* = 23; wdPropertyParas* = 24; wdPropertySlides* = 25; wdPropertyNotes* = 26; wdPropertyHiddenSlides* = 27; wdPropertyMMClips* = 28; wdPropertyHyperlinkBase* = 29; wdPropertyCharsWSpaces* = 30; (* WdLineSpacing *) wdLineSpaceSingle* = 0; wdLineSpace1pt5* = 1; wdLineSpaceDouble* = 2; wdLineSpaceAtLeast* = 3; wdLineSpaceExactly* = 4; wdLineSpaceMultiple* = 5; (* WdNumberType *) wdNumberParagraph* = 1; wdNumberListNum* = 2; wdNumberAllNumbers* = 3; (* WdListType *) wdListNoNumbering* = 0; wdListListNumOnly* = 1; wdListBullet* = 2; wdListSimpleNumbering* = 3; wdListOutlineNumbering* = 4; wdListMixedNumbering* = 5; (* WdStoryType *) wdMainTextStory* = 1; wdFootnotesStory* = 2; wdEndnotesStory* = 3; wdCommentsStory* = 4; wdTextFrameStory* = 5; wdEvenPagesHeaderStory* = 6; wdPrimaryHeaderStory* = 7; wdEvenPagesFooterStory* = 8; wdPrimaryFooterStory* = 9; wdFirstPageHeaderStory* = 10; wdFirstPageFooterStory* = 11; (* WdSaveFormat *) wdFormatDocument* = 0; wdFormatTemplate* = 1; wdFormatText* = 2; wdFormatTextLineBreaks* = 3; wdFormatDOSText* = 4; wdFormatDOSTextLineBreaks* = 5; wdFormatRTF* = 6; wdFormatUnicodeText* = 7; wdFormatEncodedText* = 7; wdFormatHTML* = 8; (* WdOpenFormat *) wdOpenFormatAuto* = 0; wdOpenFormatDocument* = 1; wdOpenFormatTemplate* = 2; wdOpenFormatRTF* = 3; wdOpenFormatText* = 4; wdOpenFormatUnicodeText* = 5; wdOpenFormatEncodedText* = 5; wdOpenFormatAllWord* = 6; wdOpenFormatWebPages* = 7; (* WdHeaderFooterIndex *) wdHeaderFooterPrimary* = 1; wdHeaderFooterFirstPage* = 2; wdHeaderFooterEvenPages* = 3; (* WdTocFormat *) wdTOCTemplate* = 0; wdTOCClassic* = 1; wdTOCDistinctive* = 2; wdTOCFancy* = 3; wdTOCModern* = 4; wdTOCFormal* = 5; wdTOCSimple* = 6; (* WdTofFormat *) wdTOFTemplate* = 0; wdTOFClassic* = 1; wdTOFDistinctive* = 2; wdTOFCentered* = 3; wdTOFFormal* = 4; wdTOFSimple* = 5; (* WdToaFormat *) wdTOATemplate* = 0; wdTOAClassic* = 1; wdTOADistinctive* = 2; wdTOAFormal* = 3; wdTOASimple* = 4; (* WdLineStyle *) wdLineStyleNone* = 0; wdLineStyleSingle* = 1; wdLineStyleDot* = 2; wdLineStyleDashSmallGap* = 3; wdLineStyleDashLargeGap* = 4; wdLineStyleDashDot* = 5; wdLineStyleDashDotDot* = 6; wdLineStyleDouble* = 7; wdLineStyleTriple* = 8; wdLineStyleThinThickSmallGap* = 9; wdLineStyleThickThinSmallGap* = 10; wdLineStyleThinThickThinSmallGap* = 11; wdLineStyleThinThickMedGap* = 12; wdLineStyleThickThinMedGap* = 13; wdLineStyleThinThickThinMedGap* = 14; wdLineStyleThinThickLargeGap* = 15; wdLineStyleThickThinLargeGap* = 16; wdLineStyleThinThickThinLargeGap* = 17; wdLineStyleSingleWavy* = 18; wdLineStyleDoubleWavy* = 19; wdLineStyleDashDotStroked* = 20; wdLineStyleEmboss3D* = 21; wdLineStyleEngrave3D* = 22; wdLineStyleOutset* = 23; wdLineStyleInset* = 24; (* WdLineWidth *) wdLineWidth025pt* = 2; wdLineWidth050pt* = 4; wdLineWidth075pt* = 6; wdLineWidth100pt* = 8; wdLineWidth150pt* = 12; wdLineWidth225pt* = 18; wdLineWidth300pt* = 24; wdLineWidth450pt* = 36; wdLineWidth600pt* = 48; (* WdBreakType *) wdSectionBreakNextPage* = 2; wdSectionBreakContinuous* = 3; wdSectionBreakEvenPage* = 4; wdSectionBreakOddPage* = 5; wdLineBreak* = 6; wdPageBreak* = 7; wdColumnBreak* = 8; wdLineBreakClearLeft* = 9; wdLineBreakClearRight* = 10; wdTextWrappingBreak* = 11; (* WdTabLeader *) wdTabLeaderSpaces* = 0; wdTabLeaderDots* = 1; wdTabLeaderDashes* = 2; wdTabLeaderLines* = 3; wdTabLeaderHeavy* = 4; wdTabLeaderMiddleDot* = 5; (* WdTabLeaderHID, hidden *) (* emptyenum* = 0; *) (* WdMeasurementUnits *) wdInches* = 0; wdCentimeters* = 1; wdMillimeters* = 2; wdPoints* = 3; wdPicas* = 4; (* WdMeasurementUnitsHID, hidden *) (* emptyenum* = 0; *) (* WdDropPosition *) wdDropNone* = 0; wdDropNormal* = 1; wdDropMargin* = 2; (* WdNumberingRule *) wdRestartContinuous* = 0; wdRestartSection* = 1; wdRestartPage* = 2; (* WdFootnoteLocation *) wdBottomOfPage* = 0; wdBeneathText* = 1; (* WdEndnoteLocation *) wdEndOfSection* = 0; wdEndOfDocument* = 1; (* WdSortSeparator *) wdSortSeparateByTabs* = 0; wdSortSeparateByCommas* = 1; wdSortSeparateByDefaultTableSeparator* = 2; (* WdTableFieldSeparator *) wdSeparateByParagraphs* = 0; wdSeparateByTabs* = 1; wdSeparateByCommas* = 2; wdSeparateByDefaultListSeparator* = 3; (* WdSortFieldType *) wdSortFieldAlphanumeric* = 0; wdSortFieldNumeric* = 1; wdSortFieldDate* = 2; wdSortFieldSyllable* = 3; wdSortFieldJapanJIS* = 4; wdSortFieldStroke* = 5; wdSortFieldKoreaKS* = 6; (* WdSortFieldTypeHID, hidden *) (* emptyenum* = 0; *) (* WdSortOrder *) wdSortOrderAscending* = 0; wdSortOrderDescending* = 1; (* WdTableFormat *) wdTableFormatNone* = 0; wdTableFormatSimple1* = 1; wdTableFormatSimple2* = 2; wdTableFormatSimple3* = 3; wdTableFormatClassic1* = 4; wdTableFormatClassic2* = 5; wdTableFormatClassic3* = 6; wdTableFormatClassic4* = 7; wdTableFormatColorful1* = 8; wdTableFormatColorful2* = 9; wdTableFormatColorful3* = 10; wdTableFormatColumns1* = 11; wdTableFormatColumns2* = 12; wdTableFormatColumns3* = 13; wdTableFormatColumns4* = 14; wdTableFormatColumns5* = 15; wdTableFormatGrid1* = 16; wdTableFormatGrid2* = 17; wdTableFormatGrid3* = 18; wdTableFormatGrid4* = 19; wdTableFormatGrid5* = 20; wdTableFormatGrid6* = 21; wdTableFormatGrid7* = 22; wdTableFormatGrid8* = 23; wdTableFormatList1* = 24; wdTableFormatList2* = 25; wdTableFormatList3* = 26; wdTableFormatList4* = 27; wdTableFormatList5* = 28; wdTableFormatList6* = 29; wdTableFormatList7* = 30; wdTableFormatList8* = 31; wdTableFormat3DEffects1* = 32; wdTableFormat3DEffects2* = 33; wdTableFormat3DEffects3* = 34; wdTableFormatContemporary* = 35; wdTableFormatElegant* = 36; wdTableFormatProfessional* = 37; wdTableFormatSubtle1* = 38; wdTableFormatSubtle2* = 39; wdTableFormatWeb1* = 40; wdTableFormatWeb2* = 41; wdTableFormatWeb3* = 42; (* WdTableFormatApply *) wdTableFormatApplyBorders* = 1; wdTableFormatApplyShading* = 2; wdTableFormatApplyFont* = 4; wdTableFormatApplyColor* = 8; wdTableFormatApplyAutoFit* = 16; wdTableFormatApplyHeadingRows* = 32; wdTableFormatApplyLastRow* = 64; wdTableFormatApplyFirstColumn* = 128; wdTableFormatApplyLastColumn* = 256; (* WdLanguageID *) wdLanguageNone* = 0; wdNoProofing* = 1024; wdAfrikaans* = 1078; wdAlbanian* = 1052; wdArabicAlgeria* = 5121; wdArabicBahrain* = 15361; wdArabicEgypt* = 3073; wdArabicIraq* = 2049; wdArabicJordan* = 11265; wdArabicKuwait* = 13313; wdArabicLebanon* = 12289; wdArabicLibya* = 4097; wdArabicMorocco* = 6145; wdArabicOman* = 8193; wdArabicQatar* = 16385; wdArabic* = 1025; wdArabicSyria* = 10241; wdArabicTunisia* = 7169; wdArabicUAE* = 14337; wdArabicYemen* = 9217; wdArmenian* = 1067; wdAssamese* = 1101; wdAzeriCyrillic* = 2092; wdAzeriLatin* = 1068; wdBasque* = 1069; wdByelorussian* = 1059; wdBengali* = 1093; wdBulgarian* = 1026; wdBurmese* = 1109; wdCatalan* = 1027; wdChineseHongKong* = 3076; wdChineseMacao* = 5124; wdSimplifiedChinese* = 2052; wdChineseSingapore* = 4100; wdTraditionalChinese* = 1028; wdCroatian* = 1050; wdCzech* = 1029; wdDanish* = 1030; wdBelgianDutch* = 2067; wdDutch* = 1043; wdEnglishAUS* = 3081; wdEnglishBelize* = 10249; wdEnglishCanadian* = 4105; wdEnglishCaribbean* = 9225; wdEnglishIreland* = 6153; wdEnglishJamaica* = 8201; wdEnglishNewZealand* = 5129; wdEnglishPhilippines* = 13321; wdEnglishSouthAfrica* = 7177; wdEnglishTrinidad* = 11273; wdEnglishUK* = 2057; wdEnglishUS* = 1033; wdEnglishZimbabwe* = 12297; wdEstonian* = 1061; wdFaeroese* = 1080; wdFarsi* = 1065; wdFinnish* = 1035; wdBelgianFrench* = 2060; wdFrenchCameroon* = 11276; wdFrenchCanadian* = 3084; wdFrenchCotedIvoire* = 12300; wdFrench* = 1036; wdFrenchLuxembourg* = 5132; wdFrenchMali* = 13324; wdFrenchMonaco* = 6156; wdFrenchReunion* = 8204; wdFrenchSenegal* = 10252; wdSwissFrench* = 4108; wdFrenchWestIndies* = 7180; wdFrenchZaire* = 9228; wdFrisianNetherlands* = 1122; wdGaelicIreland* = 2108; wdGaelicScotland* = 1084; wdGalician* = 1110; wdGeorgian* = 1079; wdGermanAustria* = 3079; wdGerman* = 1031; wdGermanLiechtenstein* = 5127; wdGermanLuxembourg* = 4103; wdSwissGerman* = 2055; wdGreek* = 1032; wdGujarati* = 1095; wdHebrew* = 1037; wdHindi* = 1081; wdHungarian* = 1038; wdIcelandic* = 1039; wdIndonesian* = 1057; wdItalian* = 1040; wdSwissItalian* = 2064; wdJapanese* = 1041; wdKannada* = 1099; wdKashmiri* = 1120; wdKazakh* = 1087; wdKhmer* = 1107; wdKirghiz* = 1088; wdKonkani* = 1111; wdKorean* = 1042; wdLao* = 1108; wdLatvian* = 1062; wdLithuanian* = 1063; wdMacedonian* = 1071; wdMalaysian* = 1086; wdMalayBruneiDarussalam* = 2110; wdMalayalam* = 1100; wdMaltese* = 1082; wdManipuri* = 1112; wdMarathi* = 1102; wdMongolian* = 1104; wdNepali* = 1121; wdNorwegianBokmol* = 1044; wdNorwegianNynorsk* = 2068; wdOriya* = 1096; wdPolish* = 1045; wdBrazilianPortuguese* = 1046; wdPortuguese* = 2070; wdPunjabi* = 1094; wdRhaetoRomanic* = 1047; wdRomanianMoldova* = 2072; wdRomanian* = 1048; wdRussianMoldova* = 2073; wdRussian* = 1049; wdSamiLappish* = 1083; wdSanskrit* = 1103; wdSerbianCyrillic* = 3098; wdSerbianLatin* = 2074; wdSindhi* = 1113; wdSlovak* = 1051; wdSlovenian* = 1060; wdSorbian* = 1070; wdSpanishArgentina* = 11274; wdSpanishBolivia* = 16394; wdSpanishChile* = 13322; wdSpanishColombia* = 9226; wdSpanishCostaRica* = 5130; wdSpanishDominicanRepublic* = 7178; wdSpanishEcuador* = 12298; wdSpanishElSalvador* = 17418; wdSpanishGuatemala* = 4106; wdSpanishHonduras* = 18442; wdMexicanSpanish* = 2058; wdSpanishNicaragua* = 19466; wdSpanishPanama* = 6154; wdSpanishParaguay* = 15370; wdSpanishPeru* = 10250; wdSpanishPuertoRico* = 20490; wdSpanishModernSort* = 3082; wdSpanish* = 1034; wdSpanishUruguay* = 14346; wdSpanishVenezuela* = 8202; wdSesotho* = 1072; wdSutu* = 1072; wdSwahili* = 1089; wdSwedishFinland* = 2077; wdSwedish* = 1053; wdTajik* = 1064; wdTamil* = 1097; wdTatar* = 1092; wdTelugu* = 1098; wdThai* = 1054; wdTibetan* = 1105; wdTsonga* = 1073; wdTswana* = 1074; wdTurkish* = 1055; wdTurkmen* = 1090; wdUkrainian* = 1058; wdUrdu* = 1056; wdUzbekCyrillic* = 2115; wdUzbekLatin* = 1091; wdVenda* = 1075; wdVietnamese* = 1066; wdWelsh* = 1106; wdXhosa* = 1076; wdZulu* = 1077; (* WdFieldType *) wdFieldEmpty* = -1; wdFieldRef* = 3; wdFieldIndexEntry* = 4; wdFieldFootnoteRef* = 5; wdFieldSet* = 6; wdFieldIf* = 7; wdFieldIndex* = 8; wdFieldTOCEntry* = 9; wdFieldStyleRef* = 10; wdFieldRefDoc* = 11; wdFieldSequence* = 12; wdFieldTOC* = 13; wdFieldInfo* = 14; wdFieldTitle* = 15; wdFieldSubject* = 16; wdFieldAuthor* = 17; wdFieldKeyWord* = 18; wdFieldComments* = 19; wdFieldLastSavedBy* = 20; wdFieldCreateDate* = 21; wdFieldSaveDate* = 22; wdFieldPrintDate* = 23; wdFieldRevisionNum* = 24; wdFieldEditTime* = 25; wdFieldNumPages* = 26; wdFieldNumWords* = 27; wdFieldNumChars* = 28; wdFieldFileName* = 29; wdFieldTemplate* = 30; wdFieldDate* = 31; wdFieldTime* = 32; wdFieldPage* = 33; wdFieldExpression* = 34; wdFieldQuote* = 35; wdFieldInclude* = 36; wdFieldPageRef* = 37; wdFieldAsk* = 38; wdFieldFillIn* = 39; wdFieldData* = 40; wdFieldNext* = 41; wdFieldNextIf* = 42; wdFieldSkipIf* = 43; wdFieldMergeRec* = 44; wdFieldDDE* = 45; wdFieldDDEAuto* = 46; wdFieldGlossary* = 47; wdFieldPrint* = 48; wdFieldFormula* = 49; wdFieldGoToButton* = 50; wdFieldMacroButton* = 51; wdFieldAutoNumOutline* = 52; wdFieldAutoNumLegal* = 53; wdFieldAutoNum* = 54; wdFieldImport* = 55; wdFieldLink* = 56; wdFieldSymbol* = 57; wdFieldEmbed* = 58; wdFieldMergeField* = 59; wdFieldUserName* = 60; wdFieldUserInitials* = 61; wdFieldUserAddress* = 62; wdFieldBarCode* = 63; wdFieldDocVariable* = 64; wdFieldSection* = 65; wdFieldSectionPages* = 66; wdFieldIncludePicture* = 67; wdFieldIncludeText* = 68; wdFieldFileSize* = 69; wdFieldFormTextInput* = 70; wdFieldFormCheckBox* = 71; wdFieldNoteRef* = 72; wdFieldTOA* = 73; wdFieldTOAEntry* = 74; wdFieldMergeSeq* = 75; wdFieldPrivate* = 77; wdFieldDatabase* = 78; wdFieldAutoText* = 79; wdFieldCompare* = 80; wdFieldAddin* = 81; wdFieldSubscriber* = 82; wdFieldFormDropDown* = 83; wdFieldAdvance* = 84; wdFieldDocProperty* = 85; wdFieldOCX* = 87; wdFieldHyperlink* = 88; wdFieldAutoTextList* = 89; wdFieldListNum* = 90; wdFieldHTMLActiveX* = 91; (* WdBuiltinStyle *) wdStyleNormal* = -1; wdStyleEnvelopeAddress* = -37; wdStyleEnvelopeReturn* = -38; wdStyleBodyText* = -67; wdStyleHeading1* = -2; wdStyleHeading2* = -3; wdStyleHeading3* = -4; wdStyleHeading4* = -5; wdStyleHeading5* = -6; wdStyleHeading6* = -7; wdStyleHeading7* = -8; wdStyleHeading8* = -9; wdStyleHeading9* = -10; wdStyleIndex1* = -11; wdStyleIndex2* = -12; wdStyleIndex3* = -13; wdStyleIndex4* = -14; wdStyleIndex5* = -15; wdStyleIndex6* = -16; wdStyleIndex7* = -17; wdStyleIndex8* = -18; wdStyleIndex9* = -19; wdStyleTOC1* = -20; wdStyleTOC2* = -21; wdStyleTOC3* = -22; wdStyleTOC4* = -23; wdStyleTOC5* = -24; wdStyleTOC6* = -25; wdStyleTOC7* = -26; wdStyleTOC8* = -27; wdStyleTOC9* = -28; wdStyleNormalIndent* = -29; wdStyleFootnoteText* = -30; wdStyleCommentText* = -31; wdStyleHeader* = -32; wdStyleFooter* = -33; wdStyleIndexHeading* = -34; wdStyleCaption* = -35; wdStyleTableOfFigures* = -36; wdStyleFootnoteReference* = -39; wdStyleCommentReference* = -40; wdStyleLineNumber* = -41; wdStylePageNumber* = -42; wdStyleEndnoteReference* = -43; wdStyleEndnoteText* = -44; wdStyleTableOfAuthorities* = -45; wdStyleMacroText* = -46; wdStyleTOAHeading* = -47; wdStyleList* = -48; wdStyleListBullet* = -49; wdStyleListNumber* = -50; wdStyleList2* = -51; wdStyleList3* = -52; wdStyleList4* = -53; wdStyleList5* = -54; wdStyleListBullet2* = -55; wdStyleListBullet3* = -56; wdStyleListBullet4* = -57; wdStyleListBullet5* = -58; wdStyleListNumber2* = -59; wdStyleListNumber3* = -60; wdStyleListNumber4* = -61; wdStyleListNumber5* = -62; wdStyleTitle* = -63; wdStyleClosing* = -64; wdStyleSignature* = -65; wdStyleDefaultParagraphFont* = -66; wdStyleBodyTextIndent* = -68; wdStyleListContinue* = -69; wdStyleListContinue2* = -70; wdStyleListContinue3* = -71; wdStyleListContinue4* = -72; wdStyleListContinue5* = -73; wdStyleMessageHeader* = -74; wdStyleSubtitle* = -75; wdStyleSalutation* = -76; wdStyleDate* = -77; wdStyleBodyTextFirstIndent* = -78; wdStyleBodyTextFirstIndent2* = -79; wdStyleNoteHeading* = -80; wdStyleBodyText2* = -81; wdStyleBodyText3* = -82; wdStyleBodyTextIndent2* = -83; wdStyleBodyTextIndent3* = -84; wdStyleBlockQuotation* = -85; wdStyleHyperlink* = -86; wdStyleHyperlinkFollowed* = -87; wdStyleStrong* = -88; wdStyleEmphasis* = -89; wdStyleNavPane* = -90; wdStylePlainText* = -91; wdStyleHtmlNormal* = -95; wdStyleHtmlAcronym* = -96; wdStyleHtmlAddress* = -97; wdStyleHtmlCite* = -98; wdStyleHtmlCode* = -99; wdStyleHtmlDfn* = -100; wdStyleHtmlKbd* = -101; wdStyleHtmlPre* = -102; wdStyleHtmlSamp* = -103; wdStyleHtmlTt* = -104; wdStyleHtmlVar* = -105; (* WdWordDialogTab *) wdDialogToolsOptionsTabView* = 204; wdDialogToolsOptionsTabGeneral* = 203; wdDialogToolsOptionsTabEdit* = 224; wdDialogToolsOptionsTabPrint* = 208; wdDialogToolsOptionsTabSave* = 209; wdDialogToolsOptionsTabProofread* = 211; wdDialogToolsOptionsTabTrackChanges* = 386; wdDialogToolsOptionsTabUserInfo* = 213; wdDialogToolsOptionsTabCompatibility* = 525; wdDialogToolsOptionsTabTypography* = 739; wdDialogToolsOptionsTabFileLocations* = 225; wdDialogToolsOptionsTabFuzzy* = 790; wdDialogToolsOptionsTabHangulHanjaConversion* = 786; wdDialogToolsOptionsTabBidi* = 1029; wdDialogFilePageSetupTabMargins* = 150000; wdDialogFilePageSetupTabPaperSize* = 150001; wdDialogFilePageSetupTabPaperSource* = 150002; wdDialogFilePageSetupTabLayout* = 150003; wdDialogFilePageSetupTabCharsLines* = 150004; wdDialogInsertSymbolTabSymbols* = 200000; wdDialogInsertSymbolTabSpecialCharacters* = 200001; wdDialogNoteOptionsTabAllFootnotes* = 300000; wdDialogNoteOptionsTabAllEndnotes* = 300001; wdDialogInsertIndexAndTablesTabIndex* = 400000; wdDialogInsertIndexAndTablesTabTableOfContents* = 400001; wdDialogInsertIndexAndTablesTabTableOfFigures* = 400002; wdDialogInsertIndexAndTablesTabTableOfAuthorities* = 400003; wdDialogOrganizerTabStyles* = 500000; wdDialogOrganizerTabAutoText* = 500001; wdDialogOrganizerTabCommandBars* = 500002; wdDialogOrganizerTabMacros* = 500003; wdDialogFormatFontTabFont* = 600000; wdDialogFormatFontTabCharacterSpacing* = 600001; wdDialogFormatFontTabAnimation* = 600002; wdDialogFormatBordersAndShadingTabBorders* = 700000; wdDialogFormatBordersAndShadingTabPageBorder* = 700001; wdDialogFormatBordersAndShadingTabShading* = 700002; wdDialogToolsEnvelopesAndLabelsTabEnvelopes* = 800000; wdDialogToolsEnvelopesAndLabelsTabLabels* = 800001; wdDialogFormatParagraphTabIndentsAndSpacing* = 1000000; wdDialogFormatParagraphTabTextFlow* = 1000001; wdDialogFormatParagraphTabTeisai* = 1000002; wdDialogFormatDrawingObjectTabColorsAndLines* = 1200000; wdDialogFormatDrawingObjectTabSize* = 1200001; wdDialogFormatDrawingObjectTabPosition* = 1200002; wdDialogFormatDrawingObjectTabWrapping* = 1200003; wdDialogFormatDrawingObjectTabPicture* = 1200004; wdDialogFormatDrawingObjectTabTextbox* = 1200005; wdDialogFormatDrawingObjectTabWeb* = 1200006; wdDialogFormatDrawingObjectTabHR* = 1200007; wdDialogToolsAutoCorrectExceptionsTabFirstLetter* = 1400000; wdDialogToolsAutoCorrectExceptionsTabInitialCaps* = 1400001; wdDialogToolsAutoCorrectExceptionsTabHangulAndAlphabet* = 1400002; wdDialogToolsAutoCorrectExceptionsTabIac* = 1400003; wdDialogFormatBulletsAndNumberingTabBulleted* = 1500000; wdDialogFormatBulletsAndNumberingTabNumbered* = 1500001; wdDialogFormatBulletsAndNumberingTabOutlineNumbered* = 1500002; wdDialogLetterWizardTabLetterFormat* = 1600000; wdDialogLetterWizardTabRecipientInfo* = 1600001; wdDialogLetterWizardTabOtherElements* = 1600002; wdDialogLetterWizardTabSenderInfo* = 1600003; wdDialogToolsAutoManagerTabAutoCorrect* = 1700000; wdDialogToolsAutoManagerTabAutoFormatAsYouType* = 1700001; wdDialogToolsAutoManagerTabAutoText* = 1700002; wdDialogToolsAutoManagerTabAutoFormat* = 1700003; wdDialogEmailOptionsTabSignature* = 1900000; wdDialogEmailOptionsTabStationary* = 1900001; wdDialogEmailOptionsTabQuoting* = 1900002; wdDialogWebOptionsGeneral* = 2000000; wdDialogWebOptionsFiles* = 2000001; wdDialogWebOptionsPictures* = 2000002; wdDialogWebOptionsEncoding* = 2000003; wdDialogWebOptionsFonts* = 2000004; (* WdWordDialogTabHID, hidden *) (* emptyenum* = 0; *) (* WdWordDialog *) wdDialogHelpAbout* = 9; wdDialogHelpWordPerfectHelp* = 10; wdDialogHelpWordPerfectHelpOptions* = 511; wdDialogFormatChangeCase* = 322; wdDialogToolsOptionsFuzzy* = 790; wdDialogToolsWordCount* = 228; wdDialogDocumentStatistics* = 78; wdDialogFileNew* = 79; wdDialogFileOpen* = 80; wdDialogMailMergeOpenDataSource* = 81; wdDialogMailMergeOpenHeaderSource* = 82; wdDialogMailMergeUseAddressBook* = 779; wdDialogFileSaveAs* = 84; wdDialogFileSummaryInfo* = 86; wdDialogToolsTemplates* = 87; wdDialogOrganizer* = 222; wdDialogFilePrint* = 88; wdDialogMailMerge* = 676; wdDialogMailMergeCheck* = 677; wdDialogMailMergeQueryOptions* = 681; wdDialogMailMergeFindRecord* = 569; wdDialogMailMergeInsertIf* = 4049; wdDialogMailMergeInsertNextIf* = 4053; wdDialogMailMergeInsertSkipIf* = 4055; wdDialogMailMergeInsertFillIn* = 4048; wdDialogMailMergeInsertAsk* = 4047; wdDialogMailMergeInsertSet* = 4054; wdDialogMailMergeHelper* = 680; wdDialogLetterWizard* = 821; wdDialogFilePrintSetup* = 97; wdDialogFileFind* = 99; wdDialogMailMergeCreateDataSource* = 642; wdDialogMailMergeCreateHeaderSource* = 643; wdDialogEditPasteSpecial* = 111; wdDialogEditFind* = 112; wdDialogEditReplace* = 117; wdDialogEditGoToOld* = 811; wdDialogEditGoTo* = 896; wdDialogCreateAutoText* = 872; wdDialogEditAutoText* = 985; wdDialogEditLinks* = 124; wdDialogEditObject* = 125; wdDialogConvertObject* = 392; wdDialogTableToText* = 128; wdDialogTextToTable* = 127; wdDialogTableInsertTable* = 129; wdDialogTableInsertCells* = 130; wdDialogTableInsertRow* = 131; wdDialogTableDeleteCells* = 133; wdDialogTableSplitCells* = 137; wdDialogTableFormula* = 348; wdDialogTableAutoFormat* = 563; wdDialogTableFormatCell* = 612; wdDialogViewZoom* = 577; wdDialogNewToolbar* = 586; wdDialogInsertBreak* = 159; wdDialogInsertFootnote* = 370; wdDialogInsertSymbol* = 162; wdDialogInsertPicture* = 163; wdDialogInsertFile* = 164; wdDialogInsertDateTime* = 165; wdDialogInsertNumber* = 812; wdDialogInsertField* = 166; wdDialogInsertDatabase* = 341; wdDialogInsertMergeField* = 167; wdDialogInsertBookmark* = 168; wdDialogInsertHyperlink* = 925; wdDialogMarkIndexEntry* = 169; wdDialogMarkCitation* = 463; wdDialogEditTOACategory* = 625; wdDialogInsertIndexAndTables* = 473; wdDialogInsertIndex* = 170; wdDialogInsertTableOfContents* = 171; wdDialogMarkTableOfContentsEntry* = 442; wdDialogInsertTableOfFigures* = 472; wdDialogInsertTableOfAuthorities* = 471; wdDialogInsertObject* = 172; wdDialogFormatCallout* = 610; wdDialogDrawSnapToGrid* = 633; wdDialogDrawAlign* = 634; wdDialogToolsEnvelopesAndLabels* = 607; wdDialogToolsCreateEnvelope* = 173; wdDialogToolsCreateLabels* = 489; wdDialogToolsProtectDocument* = 503; wdDialogToolsProtectSection* = 578; wdDialogToolsUnprotectDocument* = 521; wdDialogFormatFont* = 174; wdDialogFormatParagraph* = 175; wdDialogFormatSectionLayout* = 176; wdDialogFormatColumns* = 177; wdDialogFileDocumentLayout* = 178; wdDialogFileMacPageSetup* = 685; wdDialogFilePrintOneCopy* = 445; wdDialogFileMacPageSetupGX* = 444; wdDialogFileMacCustomPageSetupGX* = 737; wdDialogFilePageSetup* = 178; wdDialogFormatTabs* = 179; wdDialogFormatStyle* = 180; wdDialogFormatStyleGallery* = 505; wdDialogFormatDefineStyleFont* = 181; wdDialogFormatDefineStylePara* = 182; wdDialogFormatDefineStyleTabs* = 183; wdDialogFormatDefineStyleFrame* = 184; wdDialogFormatDefineStyleBorders* = 185; wdDialogFormatDefineStyleLang* = 186; wdDialogFormatPicture* = 187; wdDialogToolsLanguage* = 188; wdDialogFormatBordersAndShading* = 189; wdDialogFormatDrawingObject* = 960; wdDialogFormatFrame* = 190; wdDialogFormatDropCap* = 488; wdDialogFormatBulletsAndNumbering* = 824; wdDialogToolsHyphenation* = 195; wdDialogToolsBulletsNumbers* = 196; wdDialogToolsHighlightChanges* = 197; wdDialogToolsAcceptRejectChanges* = 506; wdDialogToolsMergeDocuments* = 435; wdDialogToolsCompareDocuments* = 198; wdDialogTableSort* = 199; wdDialogToolsCustomizeMenuBar* = 615; wdDialogToolsCustomize* = 152; wdDialogToolsCustomizeKeyboard* = 432; wdDialogToolsCustomizeMenus* = 433; wdDialogListCommands* = 723; wdDialogToolsOptions* = 974; wdDialogToolsOptionsGeneral* = 203; wdDialogToolsAdvancedSettings* = 206; wdDialogToolsOptionsCompatibility* = 525; wdDialogToolsOptionsPrint* = 208; wdDialogToolsOptionsSave* = 209; wdDialogToolsOptionsSpellingAndGrammar* = 211; wdDialogToolsSpellingAndGrammar* = 828; wdDialogToolsThesaurus* = 194; wdDialogToolsOptionsUserInfo* = 213; wdDialogToolsOptionsAutoFormat* = 959; wdDialogToolsOptionsTrackChanges* = 386; wdDialogToolsOptionsEdit* = 224; wdDialogToolsMacro* = 215; wdDialogInsertPageNumbers* = 294; wdDialogFormatPageNumber* = 298; wdDialogNoteOptions* = 373; wdDialogCopyFile* = 300; wdDialogFormatAddrFonts* = 103; wdDialogFormatRetAddrFonts* = 221; wdDialogToolsOptionsFileLocations* = 225; wdDialogToolsCreateDirectory* = 833; wdDialogUpdateTOC* = 331; wdDialogInsertFormField* = 483; wdDialogFormFieldOptions* = 353; wdDialogInsertCaption* = 357; wdDialogInsertAutoCaption* = 359; wdDialogInsertAddCaption* = 402; wdDialogInsertCaptionNumbering* = 358; wdDialogInsertCrossReference* = 367; wdDialogToolsManageFields* = 631; wdDialogToolsAutoManager* = 915; wdDialogToolsAutoCorrect* = 378; wdDialogToolsAutoCorrectExceptions* = 762; wdDialogConnect* = 420; wdDialogToolsOptionsBidi* = 1029; wdDialogToolsOptionsView* = 204; wdDialogInsertSubdocument* = 583; wdDialogFileRoutingSlip* = 624; wdDialogFontSubstitution* = 581; wdDialogEditCreatePublisher* = 732; wdDialogEditSubscribeTo* = 733; wdDialogEditPublishOptions* = 735; wdDialogEditSubscribeOptions* = 736; wdDialogToolsOptionsTypography* = 739; wdDialogToolsOptionsAutoFormatAsYouType* = 778; wdDialogControlRun* = 235; wdDialogFileVersions* = 945; wdDialogToolsAutoSummarize* = 874; wdDialogFileSaveVersion* = 1007; wdDialogWindowActivate* = 220; wdDialogToolsMacroRecord* = 214; wdDialogToolsRevisions* = 197; wdDialogEmailOptions* = 863; wdDialogWebOptions* = 898; wdDialogFitText* = 983; wdDialogPhoneticGuide* = 986; wdDialogHorizontalInVertical* = 1160; wdDialogTwoLinesInOne* = 1161; wdDialogFormatEncloseCharacters* = 1162; wdDialogFormatTheme* = 855; wdDialogTCSCTranslator* = 1156; (* WdWordDialogHID, hidden *) (* emptyenum* = 0; *) (* WdFieldKind *) wdFieldKindNone* = 0; wdFieldKindHot* = 1; wdFieldKindWarm* = 2; wdFieldKindCold* = 3; (* WdTextFormFieldType *) wdRegularText* = 0; wdNumberText* = 1; wdDateText* = 2; wdCurrentDateText* = 3; wdCurrentTimeText* = 4; wdCalculationText* = 5; (* WdChevronConvertRule *) wdNeverConvert* = 0; wdAlwaysConvert* = 1; wdAskToNotConvert* = 2; wdAskToConvert* = 3; (* WdMailMergeMainDocType *) wdNotAMergeDocument* = -1; wdFormLetters* = 0; wdMailingLabels* = 1; wdEnvelopes* = 2; wdCatalog* = 3; (* WdMailMergeState *) wdNormalDocument* = 0; wdMainDocumentOnly* = 1; wdMainAndDataSource* = 2; wdMainAndHeader* = 3; wdMainAndSourceAndHeader* = 4; wdDataSource* = 5; (* WdMailMergeDestination *) wdSendToNewDocument* = 0; wdSendToPrinter* = 1; wdSendToEmail* = 2; wdSendToFax* = 3; (* WdMailMergeActiveRecord *) wdNoActiveRecord* = -1; wdNextRecord* = -2; wdPreviousRecord* = -3; wdFirstRecord* = -4; wdLastRecord* = -5; (* WdMailMergeDefaultRecord *) wdDefaultFirstRecord* = 1; wdDefaultLastRecord* = -16; (* WdMailMergeDataSource *) wdNoMergeInfo* = -1; wdMergeInfoFromWord* = 0; wdMergeInfoFromAccessDDE* = 1; wdMergeInfoFromExcelDDE* = 2; wdMergeInfoFromMSQueryDDE* = 3; wdMergeInfoFromODBC* = 4; (* WdMailMergeComparison *) wdMergeIfEqual* = 0; wdMergeIfNotEqual* = 1; wdMergeIfLessThan* = 2; wdMergeIfGreaterThan* = 3; wdMergeIfLessThanOrEqual* = 4; wdMergeIfGreaterThanOrEqual* = 5; wdMergeIfIsBlank* = 6; wdMergeIfIsNotBlank* = 7; (* WdBookmarkSortBy *) wdSortByName* = 0; wdSortByLocation* = 1; (* WdWindowState *) wdWindowStateNormal* = 0; wdWindowStateMaximize* = 1; wdWindowStateMinimize* = 2; (* WdPictureLinkType *) wdLinkNone* = 0; wdLinkDataInDoc* = 1; wdLinkDataOnDisk* = 2; (* WdLinkType *) wdLinkTypeOLE* = 0; wdLinkTypePicture* = 1; wdLinkTypeText* = 2; wdLinkTypeReference* = 3; wdLinkTypeInclude* = 4; wdLinkTypeImport* = 5; wdLinkTypeDDE* = 6; wdLinkTypeDDEAuto* = 7; (* WdWindowType *) wdWindowDocument* = 0; wdWindowTemplate* = 1; (* WdViewType *) wdNormalView* = 1; wdOutlineView* = 2; wdPrintView* = 3; wdPrintPreview* = 4; wdMasterView* = 5; wdWebView* = 6; (* WdSeekView *) wdSeekMainDocument* = 0; wdSeekPrimaryHeader* = 1; wdSeekFirstPageHeader* = 2; wdSeekEvenPagesHeader* = 3; wdSeekPrimaryFooter* = 4; wdSeekFirstPageFooter* = 5; wdSeekEvenPagesFooter* = 6; wdSeekFootnotes* = 7; wdSeekEndnotes* = 8; wdSeekCurrentPageHeader* = 9; wdSeekCurrentPageFooter* = 10; (* WdSpecialPane *) wdPaneNone* = 0; wdPanePrimaryHeader* = 1; wdPaneFirstPageHeader* = 2; wdPaneEvenPagesHeader* = 3; wdPanePrimaryFooter* = 4; wdPaneFirstPageFooter* = 5; wdPaneEvenPagesFooter* = 6; wdPaneFootnotes* = 7; wdPaneEndnotes* = 8; wdPaneFootnoteContinuationNotice* = 9; wdPaneFootnoteContinuationSeparator* = 10; wdPaneFootnoteSeparator* = 11; wdPaneEndnoteContinuationNotice* = 12; wdPaneEndnoteContinuationSeparator* = 13; wdPaneEndnoteSeparator* = 14; wdPaneComments* = 15; wdPaneCurrentPageHeader* = 16; wdPaneCurrentPageFooter* = 17; (* WdPageFit *) wdPageFitNone* = 0; wdPageFitFullPage* = 1; wdPageFitBestFit* = 2; wdPageFitTextFit* = 3; (* WdBrowseTarget *) wdBrowsePage* = 1; wdBrowseSection* = 2; wdBrowseComment* = 3; wdBrowseFootnote* = 4; wdBrowseEndnote* = 5; wdBrowseField* = 6; wdBrowseTable* = 7; wdBrowseGraphic* = 8; wdBrowseHeading* = 9; wdBrowseEdit* = 10; wdBrowseFind* = 11; wdBrowseGoTo* = 12; (* WdPaperTray *) wdPrinterDefaultBin* = 0; wdPrinterUpperBin* = 1; wdPrinterOnlyBin* = 1; wdPrinterLowerBin* = 2; wdPrinterMiddleBin* = 3; wdPrinterManualFeed* = 4; wdPrinterEnvelopeFeed* = 5; wdPrinterManualEnvelopeFeed* = 6; wdPrinterAutomaticSheetFeed* = 7; wdPrinterTractorFeed* = 8; wdPrinterSmallFormatBin* = 9; wdPrinterLargeFormatBin* = 10; wdPrinterLargeCapacityBin* = 11; wdPrinterPaperCassette* = 14; wdPrinterFormSource* = 15; (* WdOrientation *) wdOrientPortrait* = 0; wdOrientLandscape* = 1; (* WdSelectionType *) wdNoSelection* = 0; wdSelectionIP* = 1; wdSelectionNormal* = 2; wdSelectionFrame* = 3; wdSelectionColumn* = 4; wdSelectionRow* = 5; wdSelectionBlock* = 6; wdSelectionInlineShape* = 7; wdSelectionShape* = 8; (* WdCaptionLabelID *) wdCaptionFigure* = -1; wdCaptionTable* = -2; wdCaptionEquation* = -3; (* WdReferenceType *) wdRefTypeNumberedItem* = 0; wdRefTypeHeading* = 1; wdRefTypeBookmark* = 2; wdRefTypeFootnote* = 3; wdRefTypeEndnote* = 4; (* WdReferenceKind *) wdContentText* = -1; wdNumberRelativeContext* = -2; wdNumberNoContext* = -3; wdNumberFullContext* = -4; wdEntireCaption* = 2; wdOnlyLabelAndNumber* = 3; wdOnlyCaptionText* = 4; wdFootnoteNumber* = 5; wdEndnoteNumber* = 6; wdPageNumber* = 7; wdPosition* = 15; wdFootnoteNumberFormatted* = 16; wdEndnoteNumberFormatted* = 17; (* WdIndexFormat *) wdIndexTemplate* = 0; wdIndexClassic* = 1; wdIndexFancy* = 2; wdIndexModern* = 3; wdIndexBulleted* = 4; wdIndexFormal* = 5; wdIndexSimple* = 6; (* WdIndexType *) wdIndexIndent* = 0; wdIndexRunin* = 1; (* WdRevisionsWrap *) wdWrapNever* = 0; wdWrapAlways* = 1; wdWrapAsk* = 2; (* WdRevisionType *) wdNoRevision* = 0; wdRevisionInsert* = 1; wdRevisionDelete* = 2; wdRevisionProperty* = 3; wdRevisionParagraphNumber* = 4; wdRevisionDisplayField* = 5; wdRevisionReconcile* = 6; wdRevisionConflict* = 7; wdRevisionStyle* = 8; wdRevisionReplace* = 9; (* WdRoutingSlipDelivery *) wdOneAfterAnother* = 0; wdAllAtOnce* = 1; (* WdRoutingSlipStatus *) wdNotYetRouted* = 0; wdRouteInProgress* = 1; wdRouteComplete* = 2; (* WdSectionStart *) wdSectionContinuous* = 0; wdSectionNewColumn* = 1; wdSectionNewPage* = 2; wdSectionEvenPage* = 3; wdSectionOddPage* = 4; (* WdSaveOptions *) wdDoNotSaveChanges* = 0; wdSaveChanges* = -1; wdPromptToSaveChanges* = -2; (* WdDocumentKind *) wdDocumentNotSpecified* = 0; wdDocumentLetter* = 1; wdDocumentEmail* = 2; (* WdDocumentType *) wdTypeDocument* = 0; wdTypeTemplate* = 1; wdTypeFrameset* = 2; (* WdOriginalFormat *) wdWordDocument* = 0; wdOriginalDocumentFormat* = 1; wdPromptUser* = 2; (* WdRelocate *) wdRelocateUp* = 0; wdRelocateDown* = 1; (* WdInsertedTextMark *) wdInsertedTextMarkNone* = 0; wdInsertedTextMarkBold* = 1; wdInsertedTextMarkItalic* = 2; wdInsertedTextMarkUnderline* = 3; wdInsertedTextMarkDoubleUnderline* = 4; (* WdRevisedLinesMark *) wdRevisedLinesMarkNone* = 0; wdRevisedLinesMarkLeftBorder* = 1; wdRevisedLinesMarkRightBorder* = 2; wdRevisedLinesMarkOutsideBorder* = 3; (* WdDeletedTextMark *) wdDeletedTextMarkHidden* = 0; wdDeletedTextMarkStrikeThrough* = 1; wdDeletedTextMarkCaret* = 2; wdDeletedTextMarkPound* = 3; (* WdRevisedPropertiesMark *) wdRevisedPropertiesMarkNone* = 0; wdRevisedPropertiesMarkBold* = 1; wdRevisedPropertiesMarkItalic* = 2; wdRevisedPropertiesMarkUnderline* = 3; wdRevisedPropertiesMarkDoubleUnderline* = 4; (* WdFieldShading *) wdFieldShadingNever* = 0; wdFieldShadingAlways* = 1; wdFieldShadingWhenSelected* = 2; (* WdDefaultFilePath *) wdDocumentsPath* = 0; wdPicturesPath* = 1; wdUserTemplatesPath* = 2; wdWorkgroupTemplatesPath* = 3; wdUserOptionsPath* = 4; wdAutoRecoverPath* = 5; wdToolsPath* = 6; wdTutorialPath* = 7; wdStartupPath* = 8; wdProgramPath* = 9; wdGraphicsFiltersPath* = 10; wdTextConvertersPath* = 11; wdProofingToolsPath* = 12; wdTempFilePath* = 13; wdCurrentFolderPath* = 14; wdStyleGalleryPath* = 15; wdBorderArtPath* = 19; (* WdCompatibility *) wdNoTabHangIndent* = 1; wdNoSpaceRaiseLower* = 2; wdPrintColBlack* = 3; wdWrapTrailSpaces* = 4; wdNoColumnBalance* = 5; wdConvMailMergeEsc* = 6; wdSuppressSpBfAfterPgBrk* = 7; wdSuppressTopSpacing* = 8; wdOrigWordTableRules* = 9; wdTransparentMetafiles* = 10; wdShowBreaksInFrames* = 11; wdSwapBordersFacingPages* = 12; wdLeaveBackslashAlone* = 13; wdExpandShiftReturn* = 14; wdDontULTrailSpace* = 15; wdDontBalanceSingleByteDoubleByteWidth* = 16; wdSuppressTopSpacingMac5* = 17; wdSpacingInWholePoints* = 18; wdPrintBodyTextBeforeHeader* = 19; wdNoLeading* = 20; wdNoSpaceForUL* = 21; wdMWSmallCaps* = 22; wdNoExtraLineSpacing* = 23; wdTruncateFontHeight* = 24; wdSubFontBySize* = 25; wdUsePrinterMetrics* = 26; wdWW6BorderRules* = 27; wdExactOnTop* = 28; wdSuppressBottomSpacing* = 29; wdWPSpaceWidth* = 30; wdWPJustification* = 31; wdLineWrapLikeWord6* = 32; wdShapeLayoutLikeWW8* = 33; wdFootnoteLayoutLikeWW8* = 34; wdDontUseHTMLParagraphAutoSpacing* = 35; wdDontAdjustLineHeightInTable* = 36; wdForgetLastTabAlignment* = 37; wdAutospaceLikeWW7* = 38; wdAlignTablesRowByRow* = 39; wdLayoutRawTableWidth* = 40; wdLayoutTableRowsApart* = 41; wdUseWord97LineBreakingRules* = 42; (* WdPaperSize *) wdPaper10x14* = 0; wdPaper11x17* = 1; wdPaperLetter* = 2; wdPaperLetterSmall* = 3; wdPaperLegal* = 4; wdPaperExecutive* = 5; wdPaperA3* = 6; wdPaperA4* = 7; wdPaperA4Small* = 8; wdPaperA5* = 9; wdPaperB4* = 10; wdPaperB5* = 11; wdPaperCSheet* = 12; wdPaperDSheet* = 13; wdPaperESheet* = 14; wdPaperFanfoldLegalGerman* = 15; wdPaperFanfoldStdGerman* = 16; wdPaperFanfoldUS* = 17; wdPaperFolio* = 18; wdPaperLedger* = 19; wdPaperNote* = 20; wdPaperQuarto* = 21; wdPaperStatement* = 22; wdPaperTabloid* = 23; wdPaperEnvelope9* = 24; wdPaperEnvelope10* = 25; wdPaperEnvelope11* = 26; wdPaperEnvelope12* = 27; wdPaperEnvelope14* = 28; wdPaperEnvelopeB4* = 29; wdPaperEnvelopeB5* = 30; wdPaperEnvelopeB6* = 31; wdPaperEnvelopeC3* = 32; wdPaperEnvelopeC4* = 33; wdPaperEnvelopeC5* = 34; wdPaperEnvelopeC6* = 35; wdPaperEnvelopeC65* = 36; wdPaperEnvelopeDL* = 37; wdPaperEnvelopeItaly* = 38; wdPaperEnvelopeMonarch* = 39; wdPaperEnvelopePersonal* = 40; wdPaperCustom* = 41; (* WdCustomLabelPageSize *) wdCustomLabelLetter* = 0; wdCustomLabelLetterLS* = 1; wdCustomLabelA4* = 2; wdCustomLabelA4LS* = 3; wdCustomLabelA5* = 4; wdCustomLabelA5LS* = 5; wdCustomLabelB5* = 6; wdCustomLabelMini* = 7; wdCustomLabelFanfold* = 8; wdCustomLabelVertHalfSheet* = 9; wdCustomLabelVertHalfSheetLS* = 10; wdCustomLabelHigaki* = 11; wdCustomLabelHigakiLS* = 12; wdCustomLabelB4JIS* = 13; (* WdProtectionType *) wdNoProtection* = -1; wdAllowOnlyRevisions* = 0; wdAllowOnlyComments* = 1; wdAllowOnlyFormFields* = 2; (* WdPartOfSpeech *) wdAdjective* = 0; wdNoun* = 1; wdAdverb* = 2; wdVerb* = 3; wdPronoun* = 4; wdConjunction* = 5; wdPreposition* = 6; wdInterjection* = 7; wdIdiom* = 8; wdOther* = 9; (* WdSubscriberFormats *) wdSubscriberBestFormat* = 0; wdSubscriberRTF* = 1; wdSubscriberText* = 2; wdSubscriberPict* = 4; (* WdEditionType *) wdPublisher* = 0; wdSubscriber* = 1; (* WdEditionOption *) wdCancelPublisher* = 0; wdSendPublisher* = 1; wdSelectPublisher* = 2; wdAutomaticUpdate* = 3; wdManualUpdate* = 4; wdChangeAttributes* = 5; wdUpdateSubscriber* = 6; wdOpenSource* = 7; (* WdRelativeHorizontalPosition *) wdRelativeHorizontalPositionMargin* = 0; wdRelativeHorizontalPositionPage* = 1; wdRelativeHorizontalPositionColumn* = 2; wdRelativeHorizontalPositionCharacter* = 3; (* WdRelativeVerticalPosition *) wdRelativeVerticalPositionMargin* = 0; wdRelativeVerticalPositionPage* = 1; wdRelativeVerticalPositionParagraph* = 2; wdRelativeVerticalPositionLine* = 3; (* WdHelpType *) wdHelp* = 0; wdHelpAbout* = 1; wdHelpActiveWindow* = 2; wdHelpContents* = 3; wdHelpExamplesAndDemos* = 4; wdHelpIndex* = 5; wdHelpKeyboard* = 6; wdHelpPSSHelp* = 7; wdHelpQuickPreview* = 8; wdHelpSearch* = 9; wdHelpUsingHelp* = 10; wdHelpIchitaro* = 11; wdHelpPE2* = 12; wdHelpHWP* = 13; (* WdHelpTypeHID, hidden *) (* emptyenum* = 0; *) (* WdKeyCategory *) wdKeyCategoryNil* = -1; wdKeyCategoryDisable* = 0; wdKeyCategoryCommand* = 1; wdKeyCategoryMacro* = 2; wdKeyCategoryFont* = 3; wdKeyCategoryAutoText* = 4; wdKeyCategoryStyle* = 5; wdKeyCategorySymbol* = 6; wdKeyCategoryPrefix* = 7; (* WdKey *) wdNoKey* = 255; wdKeyShift* = 256; wdKeyControl* = 512; wdKeyCommand* = 512; wdKeyAlt* = 1024; wdKeyOption* = 1024; wdKeyA* = 65; wdKeyB* = 66; wdKeyC* = 67; wdKeyD* = 68; wdKeyE* = 69; wdKeyF* = 70; wdKeyG* = 71; wdKeyH* = 72; wdKeyI* = 73; wdKeyJ* = 74; wdKeyK* = 75; wdKeyL* = 76; wdKeyM* = 77; wdKeyN* = 78; wdKeyO* = 79; wdKeyP* = 80; wdKeyQ* = 81; wdKeyR* = 82; wdKeyS* = 83; wdKeyT* = 84; wdKeyU* = 85; wdKeyV* = 86; wdKeyW* = 87; wdKeyX* = 88; wdKeyY* = 89; wdKeyZ* = 90; wdKey0* = 48; wdKey1* = 49; wdKey2* = 50; wdKey3* = 51; wdKey4* = 52; wdKey5* = 53; wdKey6* = 54; wdKey7* = 55; wdKey8* = 56; wdKey9* = 57; wdKeyBackspace* = 8; wdKeyTab* = 9; wdKeyNumeric5Special* = 12; wdKeyReturn* = 13; wdKeyPause* = 19; wdKeyEsc* = 27; wdKeySpacebar* = 32; wdKeyPageUp* = 33; wdKeyPageDown* = 34; wdKeyEnd* = 35; wdKeyHome* = 36; wdKeyInsert* = 45; wdKeyDelete* = 46; wdKeyNumeric0* = 96; wdKeyNumeric1* = 97; wdKeyNumeric2* = 98; wdKeyNumeric3* = 99; wdKeyNumeric4* = 100; wdKeyNumeric5* = 101; wdKeyNumeric6* = 102; wdKeyNumeric7* = 103; wdKeyNumeric8* = 104; wdKeyNumeric9* = 105; wdKeyNumericMultiply* = 106; wdKeyNumericAdd* = 107; wdKeyNumericSubtract* = 109; wdKeyNumericDecimal* = 110; wdKeyNumericDivide* = 111; wdKeyF1* = 112; wdKeyF2* = 113; wdKeyF3* = 114; wdKeyF4* = 115; wdKeyF5* = 116; wdKeyF6* = 117; wdKeyF7* = 118; wdKeyF8* = 119; wdKeyF9* = 120; wdKeyF10* = 121; wdKeyF11* = 122; wdKeyF12* = 123; wdKeyF13* = 124; wdKeyF14* = 125; wdKeyF15* = 126; wdKeyF16* = 127; wdKeyScrollLock* = 145; wdKeySemiColon* = 186; wdKeyEquals* = 187; wdKeyComma* = 188; wdKeyHyphen* = 189; wdKeyPeriod* = 190; wdKeySlash* = 191; wdKeyBackSingleQuote* = 192; wdKeyOpenSquareBrace* = 219; wdKeyBackSlash* = 220; wdKeyCloseSquareBrace* = 221; wdKeySingleQuote* = 222; (* WdOLEType *) wdOLELink* = 0; wdOLEEmbed* = 1; wdOLEControl* = 2; (* WdOLEVerb *) wdOLEVerbPrimary* = 0; wdOLEVerbShow* = -1; wdOLEVerbOpen* = -2; wdOLEVerbHide* = -3; wdOLEVerbUIActivate* = -4; wdOLEVerbInPlaceActivate* = -5; wdOLEVerbDiscardUndoState* = -6; (* WdOLEPlacement *) wdInLine* = 0; wdFloatOverText* = 1; (* WdEnvelopeOrientation *) wdLeftPortrait* = 0; wdCenterPortrait* = 1; wdRightPortrait* = 2; wdLeftLandscape* = 3; wdCenterLandscape* = 4; wdRightLandscape* = 5; wdLeftClockwise* = 6; wdCenterClockwise* = 7; wdRightClockwise* = 8; (* WdLetterStyle *) wdFullBlock* = 0; wdModifiedBlock* = 1; wdSemiBlock* = 2; (* WdLetterheadLocation *) wdLetterTop* = 0; wdLetterBottom* = 1; wdLetterLeft* = 2; wdLetterRight* = 3; (* WdSalutationType *) wdSalutationInformal* = 0; wdSalutationFormal* = 1; wdSalutationBusiness* = 2; wdSalutationOther* = 3; (* WdSalutationGender *) wdGenderFemale* = 0; wdGenderMale* = 1; wdGenderNeutral* = 2; wdGenderUnknown* = 3; (* WdMovementType *) wdMove* = 0; wdExtend* = 1; (* WdConstants *) wdUndefined* = 9999999; wdToggle* = 9999998; wdForward* = 1073741823; wdBackward* = -1073741823; wdAutoPosition* = 0; wdFirst* = 1; wdCreatorCode* = 1297307460; (* WdPasteDataType *) wdPasteOLEObject* = 0; wdPasteRTF* = 1; wdPasteText* = 2; wdPasteMetafilePicture* = 3; wdPasteBitmap* = 4; wdPasteDeviceIndependentBitmap* = 5; wdPasteHyperlink* = 7; wdPasteShape* = 8; wdPasteEnhancedMetafile* = 9; wdPasteHTML* = 10; (* WdPrintOutItem *) wdPrintDocumentContent* = 0; wdPrintProperties* = 1; wdPrintComments* = 2; wdPrintStyles* = 3; wdPrintAutoTextEntries* = 4; wdPrintKeyAssignments* = 5; wdPrintEnvelope* = 6; (* WdPrintOutPages *) wdPrintAllPages* = 0; wdPrintOddPagesOnly* = 1; wdPrintEvenPagesOnly* = 2; (* WdPrintOutRange *) wdPrintAllDocument* = 0; wdPrintSelection* = 1; wdPrintCurrentPage* = 2; wdPrintFromTo* = 3; wdPrintRangeOfPages* = 4; (* WdDictionaryType *) wdSpelling* = 0; wdGrammar* = 1; wdThesaurus* = 2; wdHyphenation* = 3; wdSpellingComplete* = 4; wdSpellingCustom* = 5; wdSpellingLegal* = 6; wdSpellingMedical* = 7; wdHangulHanjaConversion* = 8; wdHangulHanjaConversionCustom* = 9; (* WdDictionaryTypeHID, hidden *) (* emptyenum* = 0; *) (* WdSpellingWordType *) wdSpellword* = 0; wdWildcard* = 1; wdAnagram* = 2; (* WdSpellingErrorType *) wdSpellingCorrect* = 0; wdSpellingNotInDictionary* = 1; wdSpellingCapitalization* = 2; (* WdProofreadingErrorType *) wdSpellingError* = 0; wdGrammaticalError* = 1; (* WdInlineShapeType *) wdInlineShapeEmbeddedOLEObject* = 1; wdInlineShapeLinkedOLEObject* = 2; wdInlineShapePicture* = 3; wdInlineShapeLinkedPicture* = 4; wdInlineShapeOLEControlObject* = 5; wdInlineShapeHorizontalLine* = 6; wdInlineShapePictureHorizontalLine* = 7; wdInlineShapeLinkedPictureHorizontalLine* = 8; wdInlineShapePictureBullet* = 9; wdInlineShapeScriptAnchor* = 10; wdInlineShapeOWSAnchor* = 11; (* WdArrangeStyle *) wdTiled* = 0; wdIcons* = 1; (* WdSelectionFlags *) wdSelStartActive* = 1; wdSelAtEOL* = 2; wdSelOvertype* = 4; wdSelActive* = 8; wdSelReplace* = 16; (* WdAutoVersions *) wdAutoVersionOff* = 0; wdAutoVersionOnClose* = 1; (* WdOrganizerObject *) wdOrganizerObjectStyles* = 0; wdOrganizerObjectAutoText* = 1; wdOrganizerObjectCommandBars* = 2; wdOrganizerObjectProjectItems* = 3; (* WdFindMatch *) wdMatchParagraphMark* = 65551; wdMatchTabCharacter* = 9; wdMatchCommentMark* = 5; wdMatchAnyCharacter* = 65599; wdMatchAnyDigit* = 65567; wdMatchAnyLetter* = 65583; wdMatchCaretCharacter* = 11; wdMatchColumnBreak* = 14; wdMatchEmDash* = 8212; wdMatchEnDash* = 8211; wdMatchEndnoteMark* = 65555; wdMatchField* = 19; wdMatchFootnoteMark* = 65554; wdMatchGraphic* = 1; wdMatchManualLineBreak* = 65551; wdMatchManualPageBreak* = 65564; wdMatchNonbreakingHyphen* = 30; wdMatchNonbreakingSpace* = 160; wdMatchOptionalHyphen* = 31; wdMatchSectionBreak* = 65580; wdMatchWhiteSpace* = 65655; (* WdFindWrap *) wdFindStop* = 0; wdFindContinue* = 1; wdFindAsk* = 2; (* WdInformation *) wdActiveEndAdjustedPageNumber* = 1; wdActiveEndSectionNumber* = 2; wdActiveEndPageNumber* = 3; wdNumberOfPagesInDocument* = 4; wdHorizontalPositionRelativeToPage* = 5; wdVerticalPositionRelativeToPage* = 6; wdHorizontalPositionRelativeToTextBoundary* = 7; wdVerticalPositionRelativeToTextBoundary* = 8; wdFirstCharacterColumnNumber* = 9; wdFirstCharacterLineNumber* = 10; wdFrameIsSelected* = 11; wdWithInTable* = 12; wdStartOfRangeRowNumber* = 13; wdEndOfRangeRowNumber* = 14; wdMaximumNumberOfRows* = 15; wdStartOfRangeColumnNumber* = 16; wdEndOfRangeColumnNumber* = 17; wdMaximumNumberOfColumns* = 18; wdZoomPercentage* = 19; wdSelectionMode* = 20; wdCapsLock* = 21; wdNumLock* = 22; wdOverType* = 23; wdRevisionMarking* = 24; wdInFootnoteEndnotePane* = 25; wdInCommentPane* = 26; wdInHeaderFooter* = 28; wdAtEndOfRowMarker* = 31; wdReferenceOfType* = 32; wdHeaderFooterType* = 33; wdInMasterDocument* = 34; wdInFootnote* = 35; wdInEndnote* = 36; wdInWordMail* = 37; wdInClipboard* = 38; (* WdWrapType *) wdWrapSquare* = 0; wdWrapTight* = 1; wdWrapThrough* = 2; wdWrapNone* = 3; wdWrapTopBottom* = 4; (* WdWrapSideType *) wdWrapBoth* = 0; wdWrapLeft* = 1; wdWrapRight* = 2; wdWrapLargest* = 3; (* WdOutlineLevel *) wdOutlineLevel1* = 1; wdOutlineLevel2* = 2; wdOutlineLevel3* = 3; wdOutlineLevel4* = 4; wdOutlineLevel5* = 5; wdOutlineLevel6* = 6; wdOutlineLevel7* = 7; wdOutlineLevel8* = 8; wdOutlineLevel9* = 9; wdOutlineLevelBodyText* = 10; (* WdTextOrientation *) wdTextOrientationHorizontal* = 0; wdTextOrientationUpward* = 2; wdTextOrientationDownward* = 3; wdTextOrientationVerticalFarEast* = 1; wdTextOrientationHorizontalRotatedFarEast* = 4; (* WdTextOrientationHID, hidden *) (* emptyenum* = 0; *) (* WdPageBorderArt *) wdArtApples* = 1; wdArtMapleMuffins* = 2; wdArtCakeSlice* = 3; wdArtCandyCorn* = 4; wdArtIceCreamCones* = 5; wdArtChampagneBottle* = 6; wdArtPartyGlass* = 7; wdArtChristmasTree* = 8; wdArtTrees* = 9; wdArtPalmsColor* = 10; wdArtBalloons3Colors* = 11; wdArtBalloonsHotAir* = 12; wdArtPartyFavor* = 13; wdArtConfettiStreamers* = 14; wdArtHearts* = 15; wdArtHeartBalloon* = 16; wdArtStars3D* = 17; wdArtStarsShadowed* = 18; wdArtStars* = 19; wdArtSun* = 20; wdArtEarth2* = 21; wdArtEarth1* = 22; wdArtPeopleHats* = 23; wdArtSombrero* = 24; wdArtPencils* = 25; wdArtPackages* = 26; wdArtClocks* = 27; wdArtFirecrackers* = 28; wdArtRings* = 29; wdArtMapPins* = 30; wdArtConfetti* = 31; wdArtCreaturesButterfly* = 32; wdArtCreaturesLadyBug* = 33; wdArtCreaturesFish* = 34; wdArtBirdsFlight* = 35; wdArtScaredCat* = 36; wdArtBats* = 37; wdArtFlowersRoses* = 38; wdArtFlowersRedRose* = 39; wdArtPoinsettias* = 40; wdArtHolly* = 41; wdArtFlowersTiny* = 42; wdArtFlowersPansy* = 43; wdArtFlowersModern2* = 44; wdArtFlowersModern1* = 45; wdArtWhiteFlowers* = 46; wdArtVine* = 47; wdArtFlowersDaisies* = 48; wdArtFlowersBlockPrint* = 49; wdArtDecoArchColor* = 50; wdArtFans* = 51; wdArtFilm* = 52; wdArtLightning1* = 53; wdArtCompass* = 54; wdArtDoubleD* = 55; wdArtClassicalWave* = 56; wdArtShadowedSquares* = 57; wdArtTwistedLines1* = 58; wdArtWaveline* = 59; wdArtQuadrants* = 60; wdArtCheckedBarColor* = 61; wdArtSwirligig* = 62; wdArtPushPinNote1* = 63; wdArtPushPinNote2* = 64; wdArtPumpkin1* = 65; wdArtEggsBlack* = 66; wdArtCup* = 67; wdArtHeartGray* = 68; wdArtGingerbreadMan* = 69; wdArtBabyPacifier* = 70; wdArtBabyRattle* = 71; wdArtCabins* = 72; wdArtHouseFunky* = 73; wdArtStarsBlack* = 74; wdArtSnowflakes* = 75; wdArtSnowflakeFancy* = 76; wdArtSkyrocket* = 77; wdArtSeattle* = 78; wdArtMusicNotes* = 79; wdArtPalmsBlack* = 80; wdArtMapleLeaf* = 81; wdArtPaperClips* = 82; wdArtShorebirdTracks* = 83; wdArtPeople* = 84; wdArtPeopleWaving* = 85; wdArtEclipsingSquares2* = 86; wdArtHypnotic* = 87; wdArtDiamondsGray* = 88; wdArtDecoArch* = 89; wdArtDecoBlocks* = 90; wdArtCirclesLines* = 91; wdArtPapyrus* = 92; wdArtWoodwork* = 93; wdArtWeavingBraid* = 94; wdArtWeavingRibbon* = 95; wdArtWeavingAngles* = 96; wdArtArchedScallops* = 97; wdArtSafari* = 98; wdArtCelticKnotwork* = 99; wdArtCrazyMaze* = 100; wdArtEclipsingSquares1* = 101; wdArtBirds* = 102; wdArtFlowersTeacup* = 103; wdArtNorthwest* = 104; wdArtSouthwest* = 105; wdArtTribal6* = 106; wdArtTribal4* = 107; wdArtTribal3* = 108; wdArtTribal2* = 109; wdArtTribal5* = 110; wdArtXIllusions* = 111; wdArtZanyTriangles* = 112; wdArtPyramids* = 113; wdArtPyramidsAbove* = 114; wdArtConfettiGrays* = 115; wdArtConfettiOutline* = 116; wdArtConfettiWhite* = 117; wdArtMosaic* = 118; wdArtLightning2* = 119; wdArtHeebieJeebies* = 120; wdArtLightBulb* = 121; wdArtGradient* = 122; wdArtTriangleParty* = 123; wdArtTwistedLines2* = 124; wdArtMoons* = 125; wdArtOvals* = 126; wdArtDoubleDiamonds* = 127; wdArtChainLink* = 128; wdArtTriangles* = 129; wdArtTribal1* = 130; wdArtMarqueeToothed* = 131; wdArtSharksTeeth* = 132; wdArtSawtooth* = 133; wdArtSawtoothGray* = 134; wdArtPostageStamp* = 135; wdArtWeavingStrips* = 136; wdArtZigZag* = 137; wdArtCrossStitch* = 138; wdArtGems* = 139; wdArtCirclesRectangles* = 140; wdArtCornerTriangles* = 141; wdArtCreaturesInsects* = 142; wdArtZigZagStitch* = 143; wdArtCheckered* = 144; wdArtCheckedBarBlack* = 145; wdArtMarquee* = 146; wdArtBasicWhiteDots* = 147; wdArtBasicWideMidline* = 148; wdArtBasicWideOutline* = 149; wdArtBasicWideInline* = 150; wdArtBasicThinLines* = 151; wdArtBasicWhiteDashes* = 152; wdArtBasicWhiteSquares* = 153; wdArtBasicBlackSquares* = 154; wdArtBasicBlackDashes* = 155; wdArtBasicBlackDots* = 156; wdArtStarsTop* = 157; wdArtCertificateBanner* = 158; wdArtHandmade1* = 159; wdArtHandmade2* = 160; wdArtTornPaper* = 161; wdArtTornPaperBlack* = 162; wdArtCouponCutoutDashes* = 163; wdArtCouponCutoutDots* = 164; (* WdBorderDistanceFrom *) wdBorderDistanceFromText* = 0; wdBorderDistanceFromPageEdge* = 1; (* WdReplace *) wdReplaceNone* = 0; wdReplaceOne* = 1; wdReplaceAll* = 2; (* WdFontBias *) wdFontBiasDontCare* = 255; wdFontBiasDefault* = 0; wdFontBiasFareast* = 1; (* WdBrowserLevel *) wdBrowserLevelV4* = 0; wdBrowserLevelMicrosoftInternetExplorer5* = 1; (* WdEnclosureType *) wdEnclosureCircle* = 0; wdEnclosureSquare* = 1; wdEnclosureTriangle* = 2; wdEnclosureDiamond* = 3; (* WdEncloseStyle *) wdEncloseStyleNone* = 0; wdEncloseStyleSmall* = 1; wdEncloseStyleLarge* = 2; (* WdHighAnsiText *) wdHighAnsiIsFarEast* = 0; wdHighAnsiIsHighAnsi* = 1; wdAutoDetectHighAnsiFarEast* = 2; (* WdLayoutMode *) wdLayoutModeDefault* = 0; wdLayoutModeGrid* = 1; wdLayoutModeLineGrid* = 2; wdLayoutModeGenko* = 3; (* WdDocumentMedium *) wdEmailMessage* = 0; wdDocument* = 1; wdWebPage* = 2; (* WdMailerPriority *) wdPriorityNormal* = 1; wdPriorityLow* = 2; wdPriorityHigh* = 3; (* WdDocumentViewDirection *) wdDocumentViewRtl* = 0; wdDocumentViewLtr* = 1; (* WdArabicNumeral *) wdNumeralArabic* = 0; wdNumeralHindi* = 1; wdNumeralContext* = 2; wdNumeralSystem* = 3; (* WdMonthNames *) wdMonthNamesArabic* = 0; wdMonthNamesEnglish* = 1; wdMonthNamesFrench* = 2; (* WdCursorMovement *) wdCursorMovementLogical* = 0; wdCursorMovementVisual* = 1; (* WdVisualSelection *) wdVisualSelectionBlock* = 0; wdVisualSelectionContinuous* = 1; (* WdTableDirection *) wdTableDirectionRtl* = 0; wdTableDirectionLtr* = 1; (* WdFlowDirection *) wdFlowLtr* = 0; wdFlowRtl* = 1; (* WdDiacriticColor *) wdDiacriticColorBidi* = 0; wdDiacriticColorLatin* = 1; (* WdGutterStyle *) wdGutterPosLeft* = 0; wdGutterPosTop* = 1; wdGutterPosRight* = 2; (* WdGutterStyleOld *) wdGutterStyleLatin* = -10; wdGutterStyleBidi* = 2; (* WdSectionDirection *) wdSectionDirectionRtl* = 0; wdSectionDirectionLtr* = 1; (* WdDateLanguage *) wdDateLanguageBidi* = 10; wdDateLanguageLatin* = 1033; (* WdCalendarTypeBi *) wdCalendarTypeBidi* = 99; wdCalendarTypeGregorian* = 100; (* WdCalendarType *) wdCalendarWestern* = 0; wdCalendarArabic* = 1; wdCalendarHebrew* = 2; wdCalendarChina* = 3; wdCalendarJapan* = 4; wdCalendarThai* = 5; wdCalendarKorean* = 6; (* WdReadingOrder *) wdReadingOrderRtl* = 0; wdReadingOrderLtr* = 1; (* WdHebSpellStart *) wdFullScript* = 0; wdPartialScript* = 1; wdMixedScript* = 2; wdMixedAuthorizedScript* = 3; (* WdAraSpeller *) wdNone* = 0; wdInitialAlef* = 1; wdFinalYaa* = 2; wdBoth* = 3; (* WdColor *) wdColorAutomatic* = -16777216; wdColorBlack* = 0; wdColorBlue* = 16711680; wdColorTurquoise* = 16776960; wdColorBrightGreen* = 65280; wdColorPink* = 16711935; wdColorRed* = 255; wdColorYellow* = 65535; wdColorWhite* = 16777215; wdColorDarkBlue* = 8388608; wdColorTeal* = 8421376; wdColorGreen* = 32768; wdColorViolet* = 8388736; wdColorDarkRed* = 128; wdColorDarkYellow* = 32896; wdColorBrown* = 13209; wdColorOliveGreen* = 13107; wdColorDarkGreen* = 13056; wdColorDarkTeal* = 6697728; wdColorIndigo* = 10040115; wdColorOrange* = 26367; wdColorBlueGray* = 10053222; wdColorLightOrange* = 39423; wdColorLime* = 52377; wdColorSeaGreen* = 6723891; wdColorAqua* = 13421619; wdColorLightBlue* = 16737843; wdColorGold* = 52479; wdColorSkyBlue* = 16763904; wdColorPlum* = 6697881; wdColorRose* = 13408767; wdColorTan* = 10079487; wdColorLightYellow* = 10092543; wdColorLightGreen* = 13434828; wdColorLightTurquoise* = 16777164; wdColorPaleBlue* = 16764057; wdColorLavender* = 16751052; wdColorGray05* = 15987699; wdColorGray10* = 15132390; wdColorGray125* = 14737632; wdColorGray15* = 14277081; wdColorGray20* = 13421772; wdColorGray25* = 12632256; wdColorGray30* = 11776947; wdColorGray35* = 10921638; wdColorGray375* = 10526880; wdColorGray40* = 10066329; wdColorGray45* = 9211020; wdColorGray50* = 8421504; wdColorGray55* = 7566195; wdColorGray60* = 6710886; wdColorGray625* = 6316128; wdColorGray65* = 5855577; wdColorGray70* = 5000268; wdColorGray75* = 4210752; wdColorGray80* = 3355443; wdColorGray85* = 2500134; wdColorGray875* = 2105376; wdColorGray90* = 1644825; wdColorGray95* = 789516; (* WdShapePosition *) wdShapeTop* = -999999; wdShapeLeft* = -999998; wdShapeBottom* = -999997; wdShapeRight* = -999996; wdShapeCenter* = -999995; wdShapeInside* = -999994; wdShapeOutside* = -999993; (* WdTablePosition *) wdTableTop* = -999999; wdTableLeft* = -999998; wdTableBottom* = -999997; wdTableRight* = -999996; wdTableCenter* = -999995; wdTableInside* = -999994; wdTableOutside* = -999993; (* WdDefaultListBehavior *) wdWord8ListBehavior* = 0; wdWord9ListBehavior* = 1; (* WdDefaultTableBehavior *) wdWord8TableBehavior* = 0; wdWord9TableBehavior* = 1; (* WdAutoFitBehavior *) wdAutoFitFixed* = 0; wdAutoFitContent* = 1; wdAutoFitWindow* = 2; (* WdPreferredWidthType *) wdPreferredWidthAuto* = 1; wdPreferredWidthPercent* = 2; wdPreferredWidthPoints* = 3; (* WdFarEastLineBreakLanguageID *) wdLineBreakJapanese* = 1041; wdLineBreakKorean* = 1042; wdLineBreakSimplifiedChinese* = 2052; wdLineBreakTraditionalChinese* = 1028; (* WdViewTypeOld, hidden *) wdPageView* = 3; wdOnlineView* = 6; (* WdFramesetType *) wdFramesetTypeFrameset* = 0; wdFramesetTypeFrame* = 1; (* WdFramesetSizeType *) wdFramesetSizeTypePercent* = 0; wdFramesetSizeTypeFixed* = 1; wdFramesetSizeTypeRelative* = 2; (* WdFramesetNewFrameLocation *) wdFramesetNewFrameAbove* = 0; wdFramesetNewFrameBelow* = 1; wdFramesetNewFrameRight* = 2; wdFramesetNewFrameLeft* = 3; (* WdScrollbarType *) wdScrollbarTypeAuto* = 0; wdScrollbarTypeYes* = 1; wdScrollbarTypeNo* = 2; (* WdTwoLinesInOneType *) wdTwoLinesInOneNone* = 0; wdTwoLinesInOneNoBrackets* = 1; wdTwoLinesInOneParentheses* = 2; wdTwoLinesInOneSquareBrackets* = 3; wdTwoLinesInOneAngleBrackets* = 4; wdTwoLinesInOneCurlyBrackets* = 5; (* WdHorizontalInVerticalType *) wdHorizontalInVerticalNone* = 0; wdHorizontalInVerticalFitInLine* = 1; wdHorizontalInVerticalResizeLine* = 2; (* WdHorizontalLineAlignment *) wdHorizontalLineAlignLeft* = 0; wdHorizontalLineAlignCenter* = 1; wdHorizontalLineAlignRight* = 2; (* WdHorizontalLineWidthType *) wdHorizontalLinePercentWidth* = -1; wdHorizontalLineFixedWidth* = -2; (* WdPhoneticGuideAlignmentType *) wdPhoneticGuideAlignmentCenter* = 0; wdPhoneticGuideAlignmentZeroOneZero* = 1; wdPhoneticGuideAlignmentOneTwoOne* = 2; wdPhoneticGuideAlignmentLeft* = 3; wdPhoneticGuideAlignmentRight* = 4; (* WdNewDocumentType *) wdNewBlankDocument* = 0; wdNewWebPage* = 1; wdNewEmailMessage* = 2; wdNewFrameset* = 3; (* WdKana *) wdKanaKatakana* = 8; wdKanaHiragana* = 9; (* WdCharacterWidth *) wdWidthHalfWidth* = 6; wdWidthFullWidth* = 7; (* WdNumberStyleWordBasicBiDi *) wdListNumberStyleBidi1* = 49; wdListNumberStyleBidi2* = 50; wdCaptionNumberStyleBidiLetter1* = 49; wdCaptionNumberStyleBidiLetter2* = 50; wdNoteNumberStyleBidiLetter1* = 49; wdNoteNumberStyleBidiLetter2* = 50; wdPageNumberStyleBidiLetter1* = 49; wdPageNumberStyleBidiLetter2* = 50; (* WdTCSCConverterDirection *) wdTCSCConverterDirectionSCTC* = 0; wdTCSCConverterDirectionTCSC* = 1; wdTCSCConverterDirectionAuto* = 2; TYPE WdMailSystem* = INTEGER; WdTemplateType* = INTEGER; WdContinue* = INTEGER; WdIMEMode* = INTEGER; WdBaselineAlignment* = INTEGER; WdIndexFilter* = INTEGER; WdIndexSortBy* = INTEGER; WdJustificationMode* = INTEGER; WdFarEastLineBreakLevel* = INTEGER; WdMultipleWordConversionsMode* = INTEGER; WdColorIndex* = INTEGER; WdTextureIndex* = INTEGER; WdUnderline* = INTEGER; WdEmphasisMark* = INTEGER; WdInternationalIndex* = INTEGER; WdAutoMacros* = INTEGER; WdCaptionPosition* = INTEGER; WdCountry* = INTEGER; WdHeadingSeparator* = INTEGER; WdSeparatorType* = INTEGER; WdPageNumberAlignment* = INTEGER; WdBorderType* = INTEGER; WdBorderTypeHID* = INTEGER; WdFramePosition* = INTEGER; WdAnimation* = INTEGER; WdCharacterCase* = INTEGER; WdCharacterCaseHID* = INTEGER; WdSummaryMode* = INTEGER; WdSummaryLength* = INTEGER; WdStyleType* = INTEGER; WdUnits* = INTEGER; WdGoToItem* = INTEGER; WdGoToDirection* = INTEGER; WdCollapseDirection* = INTEGER; WdRowHeightRule* = INTEGER; WdFrameSizeRule* = INTEGER; WdInsertCells* = INTEGER; WdDeleteCells* = INTEGER; WdListApplyTo* = INTEGER; WdAlertLevel* = INTEGER; WdCursorType* = INTEGER; WdEnableCancelKey* = INTEGER; WdRulerStyle* = INTEGER; WdParagraphAlignment* = INTEGER; WdParagraphAlignmentHID* = INTEGER; WdListLevelAlignment* = INTEGER; WdRowAlignment* = INTEGER; WdTabAlignment* = INTEGER; WdVerticalAlignment* = INTEGER; WdCellVerticalAlignment* = INTEGER; WdTrailingCharacter* = INTEGER; WdListGalleryType* = INTEGER; WdListNumberStyle* = INTEGER; WdListNumberStyleHID* = INTEGER; WdNoteNumberStyle* = INTEGER; WdNoteNumberStyleHID* = INTEGER; WdCaptionNumberStyle* = INTEGER; WdCaptionNumberStyleHID* = INTEGER; WdPageNumberStyle* = INTEGER; WdPageNumberStyleHID* = INTEGER; WdStatistic* = INTEGER; WdStatisticHID* = INTEGER; WdBuiltInProperty* = INTEGER; WdLineSpacing* = INTEGER; WdNumberType* = INTEGER; WdListType* = INTEGER; WdStoryType* = INTEGER; WdSaveFormat* = INTEGER; WdOpenFormat* = INTEGER; WdHeaderFooterIndex* = INTEGER; WdTocFormat* = INTEGER; WdTofFormat* = INTEGER; WdToaFormat* = INTEGER; WdLineStyle* = INTEGER; WdLineWidth* = INTEGER; WdBreakType* = INTEGER; WdTabLeader* = INTEGER; WdTabLeaderHID* = INTEGER; WdMeasurementUnits* = INTEGER; WdMeasurementUnitsHID* = INTEGER; WdDropPosition* = INTEGER; WdNumberingRule* = INTEGER; WdFootnoteLocation* = INTEGER; WdEndnoteLocation* = INTEGER; WdSortSeparator* = INTEGER; WdTableFieldSeparator* = INTEGER; WdSortFieldType* = INTEGER; WdSortFieldTypeHID* = INTEGER; WdSortOrder* = INTEGER; WdTableFormat* = INTEGER; WdTableFormatApply* = INTEGER; WdLanguageID* = INTEGER; WdFieldType* = INTEGER; WdBuiltinStyle* = INTEGER; WdWordDialogTab* = INTEGER; WdWordDialogTabHID* = INTEGER; WdWordDialog* = INTEGER; WdWordDialogHID* = INTEGER; WdFieldKind* = INTEGER; WdTextFormFieldType* = INTEGER; WdChevronConvertRule* = INTEGER; WdMailMergeMainDocType* = INTEGER; WdMailMergeState* = INTEGER; WdMailMergeDestination* = INTEGER; WdMailMergeActiveRecord* = INTEGER; WdMailMergeDefaultRecord* = INTEGER; WdMailMergeDataSource* = INTEGER; WdMailMergeComparison* = INTEGER; WdBookmarkSortBy* = INTEGER; WdWindowState* = INTEGER; WdPictureLinkType* = INTEGER; WdLinkType* = INTEGER; WdWindowType* = INTEGER; WdViewType* = INTEGER; WdSeekView* = INTEGER; WdSpecialPane* = INTEGER; WdPageFit* = INTEGER; WdBrowseTarget* = INTEGER; WdPaperTray* = INTEGER; WdOrientation* = INTEGER; WdSelectionType* = INTEGER; WdCaptionLabelID* = INTEGER; WdReferenceType* = INTEGER; WdReferenceKind* = INTEGER; WdIndexFormat* = INTEGER; WdIndexType* = INTEGER; WdRevisionsWrap* = INTEGER; WdRevisionType* = INTEGER; WdRoutingSlipDelivery* = INTEGER; WdRoutingSlipStatus* = INTEGER; WdSectionStart* = INTEGER; WdSaveOptions* = INTEGER; WdDocumentKind* = INTEGER; WdDocumentType* = INTEGER; WdOriginalFormat* = INTEGER; WdRelocate* = INTEGER; WdInsertedTextMark* = INTEGER; WdRevisedLinesMark* = INTEGER; WdDeletedTextMark* = INTEGER; WdRevisedPropertiesMark* = INTEGER; WdFieldShading* = INTEGER; WdDefaultFilePath* = INTEGER; WdCompatibility* = INTEGER; WdPaperSize* = INTEGER; WdCustomLabelPageSize* = INTEGER; WdProtectionType* = INTEGER; WdPartOfSpeech* = INTEGER; WdSubscriberFormats* = INTEGER; WdEditionType* = INTEGER; WdEditionOption* = INTEGER; WdRelativeHorizontalPosition* = INTEGER; WdRelativeVerticalPosition* = INTEGER; WdHelpType* = INTEGER; WdHelpTypeHID* = INTEGER; WdKeyCategory* = INTEGER; WdKey* = INTEGER; WdOLEType* = INTEGER; WdOLEVerb* = INTEGER; WdOLEPlacement* = INTEGER; WdEnvelopeOrientation* = INTEGER; WdLetterStyle* = INTEGER; WdLetterheadLocation* = INTEGER; WdSalutationType* = INTEGER; WdSalutationGender* = INTEGER; WdMovementType* = INTEGER; WdConstants* = INTEGER; WdPasteDataType* = INTEGER; WdPrintOutItem* = INTEGER; WdPrintOutPages* = INTEGER; WdPrintOutRange* = INTEGER; WdDictionaryType* = INTEGER; WdDictionaryTypeHID* = INTEGER; WdSpellingWordType* = INTEGER; WdSpellingErrorType* = INTEGER; WdProofreadingErrorType* = INTEGER; WdInlineShapeType* = INTEGER; WdArrangeStyle* = INTEGER; WdSelectionFlags* = INTEGER; WdAutoVersions* = INTEGER; WdOrganizerObject* = INTEGER; WdFindMatch* = INTEGER; WdFindWrap* = INTEGER; WdInformation* = INTEGER; WdWrapType* = INTEGER; WdWrapSideType* = INTEGER; WdOutlineLevel* = INTEGER; WdTextOrientation* = INTEGER; WdTextOrientationHID* = INTEGER; WdPageBorderArt* = INTEGER; WdBorderDistanceFrom* = INTEGER; WdReplace* = INTEGER; WdFontBias* = INTEGER; _Application* = POINTER TO RECORD (CtlT.Object) END; _Global* = POINTER TO RECORD (CtlT.Object) END; FontNames* = POINTER TO RECORD (CtlT.Object) END; Languages* = POINTER TO RECORD (CtlT.Object) END; Language* = POINTER TO RECORD (CtlT.Object) END; Documents* = POINTER TO RECORD (CtlT.Object) END; _Document* = POINTER TO RECORD (CtlT.Object) END; Template* = POINTER TO RECORD (CtlT.Object) END; Templates* = POINTER TO RECORD (CtlT.Object) END; RoutingSlip* = POINTER TO RECORD (CtlT.Object) END; Bookmark* = POINTER TO RECORD (CtlT.Object) END; Bookmarks* = POINTER TO RECORD (CtlT.Object) END; Variable* = POINTER TO RECORD (CtlT.Object) END; Variables* = POINTER TO RECORD (CtlT.Object) END; RecentFile* = POINTER TO RECORD (CtlT.Object) END; RecentFiles* = POINTER TO RECORD (CtlT.Object) END; Window* = POINTER TO RECORD (CtlT.Object) END; Windows* = POINTER TO RECORD (CtlT.Object) END; Pane* = POINTER TO RECORD (CtlT.Object) END; Panes* = POINTER TO RECORD (CtlT.Object) END; Range* = POINTER TO RECORD (CtlT.Object) END; ListFormat* = POINTER TO RECORD (CtlT.Object) END; Find* = POINTER TO RECORD (CtlT.Object) END; Replacement* = POINTER TO RECORD (CtlT.Object) END; Characters* = POINTER TO RECORD (CtlT.Object) END; Words* = POINTER TO RECORD (CtlT.Object) END; Sentences* = POINTER TO RECORD (CtlT.Object) END; Sections* = POINTER TO RECORD (CtlT.Object) END; Section* = POINTER TO RECORD (CtlT.Object) END; Paragraphs* = POINTER TO RECORD (CtlT.Object) END; Paragraph* = POINTER TO RECORD (CtlT.Object) END; DropCap* = POINTER TO RECORD (CtlT.Object) END; TabStops* = POINTER TO RECORD (CtlT.Object) END; TabStop* = POINTER TO RECORD (CtlT.Object) END; _ParagraphFormat* = POINTER TO RECORD (CtlT.Object) END; _Font* = POINTER TO RECORD (CtlT.Object) END; Table* = POINTER TO RECORD (CtlT.Object) END; Row* = POINTER TO RECORD (CtlT.Object) END; Column* = POINTER TO RECORD (CtlT.Object) END; Cell* = POINTER TO RECORD (CtlT.Object) END; Tables* = POINTER TO RECORD (CtlT.Object) END; Rows* = POINTER TO RECORD (CtlT.Object) END; Columns* = POINTER TO RECORD (CtlT.Object) END; Cells* = POINTER TO RECORD (CtlT.Object) END; AutoCorrect* = POINTER TO RECORD (CtlT.Object) END; AutoCorrectEntries* = POINTER TO RECORD (CtlT.Object) END; AutoCorrectEntry* = POINTER TO RECORD (CtlT.Object) END; FirstLetterExceptions* = POINTER TO RECORD (CtlT.Object) END; FirstLetterException* = POINTER TO RECORD (CtlT.Object) END; TwoInitialCapsExceptions* = POINTER TO RECORD (CtlT.Object) END; TwoInitialCapsException* = POINTER TO RECORD (CtlT.Object) END; Footnotes* = POINTER TO RECORD (CtlT.Object) END; Endnotes* = POINTER TO RECORD (CtlT.Object) END; Comments* = POINTER TO RECORD (CtlT.Object) END; Footnote* = POINTER TO RECORD (CtlT.Object) END; Endnote* = POINTER TO RECORD (CtlT.Object) END; Comment* = POINTER TO RECORD (CtlT.Object) END; Borders* = POINTER TO RECORD (CtlT.Object) END; Border* = POINTER TO RECORD (CtlT.Object) END; Shading* = POINTER TO RECORD (CtlT.Object) END; TextRetrievalMode* = POINTER TO RECORD (CtlT.Object) END; AutoTextEntries* = POINTER TO RECORD (CtlT.Object) END; AutoTextEntry* = POINTER TO RECORD (CtlT.Object) END; System* = POINTER TO RECORD (CtlT.Object) END; OLEFormat* = POINTER TO RECORD (CtlT.Object) END; LinkFormat* = POINTER TO RECORD (CtlT.Object) END; _OLEControl* = POINTER TO RECORD (CtlT.Object) END; Fields* = POINTER TO RECORD (CtlT.Object) END; Field* = POINTER TO RECORD (CtlT.Object) END; Browser* = POINTER TO RECORD (CtlT.Object) END; Styles* = POINTER TO RECORD (CtlT.Object) END; Style* = POINTER TO RECORD (CtlT.Object) END; Frames* = POINTER TO RECORD (CtlT.Object) END; Frame* = POINTER TO RECORD (CtlT.Object) END; FormFields* = POINTER TO RECORD (CtlT.Object) END; FormField* = POINTER TO RECORD (CtlT.Object) END; TextInput* = POINTER TO RECORD (CtlT.Object) END; CheckBox* = POINTER TO RECORD (CtlT.Object) END; DropDown* = POINTER TO RECORD (CtlT.Object) END; ListEntries* = POINTER TO RECORD (CtlT.Object) END; ListEntry* = POINTER TO RECORD (CtlT.Object) END; TablesOfFigures* = POINTER TO RECORD (CtlT.Object) END; TableOfFigures* = POINTER TO RECORD (CtlT.Object) END; MailMerge* = POINTER TO RECORD (CtlT.Object) END; MailMergeFields* = POINTER TO RECORD (CtlT.Object) END; MailMergeField* = POINTER TO RECORD (CtlT.Object) END; MailMergeDataSource* = POINTER TO RECORD (CtlT.Object) END; MailMergeFieldNames* = POINTER TO RECORD (CtlT.Object) END; MailMergeFieldName* = POINTER TO RECORD (CtlT.Object) END; MailMergeDataFields* = POINTER TO RECORD (CtlT.Object) END; MailMergeDataField* = POINTER TO RECORD (CtlT.Object) END; Envelope* = POINTER TO RECORD (CtlT.Object) END; MailingLabel* = POINTER TO RECORD (CtlT.Object) END; CustomLabels* = POINTER TO RECORD (CtlT.Object) END; CustomLabel* = POINTER TO RECORD (CtlT.Object) END; TablesOfContents* = POINTER TO RECORD (CtlT.Object) END; TableOfContents* = POINTER TO RECORD (CtlT.Object) END; TablesOfAuthorities* = POINTER TO RECORD (CtlT.Object) END; TableOfAuthorities* = POINTER TO RECORD (CtlT.Object) END; Dialogs* = POINTER TO RECORD (CtlT.Object) END; Dialog* = POINTER TO RECORD (CtlT.Object) END; PageSetup* = POINTER TO RECORD (CtlT.Object) END; LineNumbering* = POINTER TO RECORD (CtlT.Object) END; TextColumns* = POINTER TO RECORD (CtlT.Object) END; TextColumn* = POINTER TO RECORD (CtlT.Object) END; Selection* = POINTER TO RECORD (CtlT.Object) END; TablesOfAuthoritiesCategories* = POINTER TO RECORD (CtlT.Object) END; TableOfAuthoritiesCategory* = POINTER TO RECORD (CtlT.Object) END; CaptionLabels* = POINTER TO RECORD (CtlT.Object) END; CaptionLabel* = POINTER TO RECORD (CtlT.Object) END; AutoCaptions* = POINTER TO RECORD (CtlT.Object) END; AutoCaption* = POINTER TO RECORD (CtlT.Object) END; Indexes* = POINTER TO RECORD (CtlT.Object) END; Index* = POINTER TO RECORD (CtlT.Object) END; AddIn* = POINTER TO RECORD (CtlT.Object) END; AddIns* = POINTER TO RECORD (CtlT.Object) END; Revisions* = POINTER TO RECORD (CtlT.Object) END; Revision* = POINTER TO RECORD (CtlT.Object) END; Task* = POINTER TO RECORD (CtlT.Object) END; Tasks* = POINTER TO RECORD (CtlT.Object) END; HeadersFooters* = POINTER TO RECORD (CtlT.Object) END; HeaderFooter* = POINTER TO RECORD (CtlT.Object) END; PageNumbers* = POINTER TO RECORD (CtlT.Object) END; PageNumber* = POINTER TO RECORD (CtlT.Object) END; Subdocuments* = POINTER TO RECORD (CtlT.Object) END; Subdocument* = POINTER TO RECORD (CtlT.Object) END; HeadingStyles* = POINTER TO RECORD (CtlT.Object) END; HeadingStyle* = POINTER TO RECORD (CtlT.Object) END; StoryRanges* = POINTER TO RECORD (CtlT.Object) END; ListLevel* = POINTER TO RECORD (CtlT.Object) END; ListLevels* = POINTER TO RECORD (CtlT.Object) END; ListTemplate* = POINTER TO RECORD (CtlT.Object) END; ListTemplates* = POINTER TO RECORD (CtlT.Object) END; ListParagraphs* = POINTER TO RECORD (CtlT.Object) END; List* = POINTER TO RECORD (CtlT.Object) END; Lists* = POINTER TO RECORD (CtlT.Object) END; ListGallery* = POINTER TO RECORD (CtlT.Object) END; ListGalleries* = POINTER TO RECORD (CtlT.Object) END; KeyBindings* = POINTER TO RECORD (CtlT.Object) END; KeysBoundTo* = POINTER TO RECORD (CtlT.Object) END; KeyBinding* = POINTER TO RECORD (CtlT.Object) END; FileConverter* = POINTER TO RECORD (CtlT.Object) END; FileConverters* = POINTER TO RECORD (CtlT.Object) END; SynonymInfo* = POINTER TO RECORD (CtlT.Object) END; Hyperlinks* = POINTER TO RECORD (CtlT.Object) END; Hyperlink* = POINTER TO RECORD (CtlT.Object) END; Shapes* = POINTER TO RECORD (CtlT.Object) END; ShapeRange* = POINTER TO RECORD (CtlT.Object) END; GroupShapes* = POINTER TO RECORD (CtlT.Object) END; Shape* = POINTER TO RECORD (CtlT.Object) END; TextFrame* = POINTER TO RECORD (CtlT.Object) END; _LetterContent* = POINTER TO RECORD (CtlT.Object) END; View* = POINTER TO RECORD (CtlT.Object) END; Zoom* = POINTER TO RECORD (CtlT.Object) END; Zooms* = POINTER TO RECORD (CtlT.Object) END; InlineShape* = POINTER TO RECORD (CtlT.Object) END; InlineShapes* = POINTER TO RECORD (CtlT.Object) END; SpellingSuggestions* = POINTER TO RECORD (CtlT.Object) END; SpellingSuggestion* = POINTER TO RECORD (CtlT.Object) END; Dictionaries* = POINTER TO RECORD (CtlT.Object) END; HangulHanjaConversionDictionaries* = POINTER TO RECORD (CtlT.Object) END; Dictionary* = POINTER TO RECORD (CtlT.Object) END; ReadabilityStatistics* = POINTER TO RECORD (CtlT.Object) END; ReadabilityStatistic* = POINTER TO RECORD (CtlT.Object) END; Versions* = POINTER TO RECORD (CtlT.Object) END; Version* = POINTER TO RECORD (CtlT.Object) END; Options* = POINTER TO RECORD (CtlT.Object) END; MailMessage* = POINTER TO RECORD (CtlT.Object) END; ProofreadingErrors* = POINTER TO RECORD (CtlT.Object) END; Mailer* = POINTER TO RECORD (CtlT.Object) END; WrapFormat* = POINTER TO RECORD (CtlT.Object) END; HangulAndAlphabetExceptions* = POINTER TO RECORD (CtlT.Object) END; HangulAndAlphabetException* = POINTER TO RECORD (CtlT.Object) END; Adjustments* = POINTER TO RECORD (CtlT.Object) END; CalloutFormat* = POINTER TO RECORD (CtlT.Object) END; ColorFormat* = POINTER TO RECORD (CtlT.Object) END; ConnectorFormat* = POINTER TO RECORD (CtlT.Object) END; FillFormat* = POINTER TO RECORD (CtlT.Object) END; FreeformBuilder* = POINTER TO RECORD (CtlT.Object) END; LineFormat* = POINTER TO RECORD (CtlT.Object) END; PictureFormat* = POINTER TO RECORD (CtlT.Object) END; ShadowFormat* = POINTER TO RECORD (CtlT.Object) END; ShapeNode* = POINTER TO RECORD (CtlT.Object) END; ShapeNodes* = POINTER TO RECORD (CtlT.Object) END; TextEffectFormat* = POINTER TO RECORD (CtlT.Object) END; ThreeDFormat* = POINTER TO RECORD (CtlT.Object) END; ApplicationEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Global* = _Global; Application* = _Application; DocumentEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; Document* = _Document; Font* = _Font; ParagraphFormat* = _ParagraphFormat; OCXEvents* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; OLEControl* = _OLEControl; LetterContent* = _LetterContent; IApplicationEvents* = POINTER TO RECORD (CtlT.Object) END; IApplicationEvents2* = POINTER TO RECORD (CtlT.Object) END; ApplicationEvents2* = POINTER TO ABSTRACT RECORD (CtlT.OutObject) END; WdBrowserLevel* = INTEGER; WdEnclosureType* = INTEGER; WdEncloseStyle* = INTEGER; WdHighAnsiText* = INTEGER; WdLayoutMode* = INTEGER; WdDocumentMedium* = INTEGER; WdMailerPriority* = INTEGER; WdDocumentViewDirection* = INTEGER; WdArabicNumeral* = INTEGER; WdMonthNames* = INTEGER; WdCursorMovement* = INTEGER; WdVisualSelection* = INTEGER; WdTableDirection* = INTEGER; WdFlowDirection* = INTEGER; WdDiacriticColor* = INTEGER; WdGutterStyle* = INTEGER; WdGutterStyleOld* = INTEGER; WdSectionDirection* = INTEGER; WdDateLanguage* = INTEGER; WdCalendarTypeBi* = INTEGER; WdCalendarType* = INTEGER; WdReadingOrder* = INTEGER; WdHebSpellStart* = INTEGER; WdAraSpeller* = INTEGER; WdColor* = INTEGER; WdShapePosition* = INTEGER; WdTablePosition* = INTEGER; WdDefaultListBehavior* = INTEGER; WdDefaultTableBehavior* = INTEGER; WdAutoFitBehavior* = INTEGER; WdPreferredWidthType* = INTEGER; WdFarEastLineBreakLanguageID* = INTEGER; WdViewTypeOld* = INTEGER; WdFramesetType* = INTEGER; WdFramesetSizeType* = INTEGER; WdFramesetNewFrameLocation* = INTEGER; WdScrollbarType* = INTEGER; WdTwoLinesInOneType* = INTEGER; WdHorizontalInVerticalType* = INTEGER; WdHorizontalLineAlignment* = INTEGER; WdHorizontalLineWidthType* = INTEGER; WdPhoneticGuideAlignmentType* = INTEGER; WdNewDocumentType* = INTEGER; WdKana* = INTEGER; WdCharacterWidth* = INTEGER; WdNumberStyleWordBasicBiDi* = INTEGER; WdTCSCConverterDirection* = INTEGER; EmailAuthor* = POINTER TO RECORD (CtlT.Object) END; EmailOptions* = POINTER TO RECORD (CtlT.Object) END; EmailSignature* = POINTER TO RECORD (CtlT.Object) END; Email* = POINTER TO RECORD (CtlT.Object) END; HorizontalLineFormat* = POINTER TO RECORD (CtlT.Object) END; Frameset* = POINTER TO RECORD (CtlT.Object) END; DefaultWebOptions* = POINTER TO RECORD (CtlT.Object) END; WebOptions* = POINTER TO RECORD (CtlT.Object) END; OtherCorrectionsExceptions* = POINTER TO RECORD (CtlT.Object) END; OtherCorrectionsException* = POINTER TO RECORD (CtlT.Object) END; PROCEDURE This_Application* (v: CtlT.Any): _Application; VAR new: _Application; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020970-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Application; PROCEDURE Is_Application* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020970-0000-0000-C000-000000000046}") END Is_Application; PROCEDURE This_Global* (v: CtlT.Any): _Global; VAR new: _Global; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Global; PROCEDURE Is_Global* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B9-0000-0000-C000-000000000046}") END Is_Global; PROCEDURE ThisFontNames* (v: CtlT.Any): FontNames; VAR new: FontNames; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFontNames; PROCEDURE IsFontNames* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096F-0000-0000-C000-000000000046}") END IsFontNames; PROCEDURE ThisLanguages* (v: CtlT.Any): Languages; VAR new: Languages; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLanguages; PROCEDURE IsLanguages* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096E-0000-0000-C000-000000000046}") END IsLanguages; PROCEDURE ThisLanguage* (v: CtlT.Any): Language; VAR new: Language; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLanguage; PROCEDURE IsLanguage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096D-0000-0000-C000-000000000046}") END IsLanguage; PROCEDURE ThisDocuments* (v: CtlT.Any): Documents; VAR new: Documents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDocuments; PROCEDURE IsDocuments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096C-0000-0000-C000-000000000046}") END IsDocuments; PROCEDURE This_Document* (v: CtlT.Any): _Document; VAR new: _Document; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Document; PROCEDURE Is_Document* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096B-0000-0000-C000-000000000046}") END Is_Document; PROCEDURE ThisTemplate* (v: CtlT.Any): Template; VAR new: Template; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002096A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTemplate; PROCEDURE IsTemplate* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002096A-0000-0000-C000-000000000046}") END IsTemplate; PROCEDURE ThisTemplates* (v: CtlT.Any): Templates; VAR new: Templates; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTemplates; PROCEDURE IsTemplates* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A2-0000-0000-C000-000000000046}") END IsTemplates; PROCEDURE ThisRoutingSlip* (v: CtlT.Any): RoutingSlip; VAR new: RoutingSlip; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020969-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRoutingSlip; PROCEDURE IsRoutingSlip* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020969-0000-0000-C000-000000000046}") END IsRoutingSlip; PROCEDURE ThisBookmark* (v: CtlT.Any): Bookmark; VAR new: Bookmark; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020968-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBookmark; PROCEDURE IsBookmark* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020968-0000-0000-C000-000000000046}") END IsBookmark; PROCEDURE ThisBookmarks* (v: CtlT.Any): Bookmarks; VAR new: Bookmarks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020967-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBookmarks; PROCEDURE IsBookmarks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020967-0000-0000-C000-000000000046}") END IsBookmarks; PROCEDURE ThisVariable* (v: CtlT.Any): Variable; VAR new: Variable; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020966-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVariable; PROCEDURE IsVariable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020966-0000-0000-C000-000000000046}") END IsVariable; PROCEDURE ThisVariables* (v: CtlT.Any): Variables; VAR new: Variables; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020965-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVariables; PROCEDURE IsVariables* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020965-0000-0000-C000-000000000046}") END IsVariables; PROCEDURE ThisRecentFile* (v: CtlT.Any): RecentFile; VAR new: RecentFile; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020964-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecentFile; PROCEDURE IsRecentFile* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020964-0000-0000-C000-000000000046}") END IsRecentFile; PROCEDURE ThisRecentFiles* (v: CtlT.Any): RecentFiles; VAR new: RecentFiles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020963-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRecentFiles; PROCEDURE IsRecentFiles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020963-0000-0000-C000-000000000046}") END IsRecentFiles; PROCEDURE ThisWindow* (v: CtlT.Any): Window; VAR new: Window; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020962-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWindow; PROCEDURE IsWindow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020962-0000-0000-C000-000000000046}") END IsWindow; PROCEDURE ThisWindows* (v: CtlT.Any): Windows; VAR new: Windows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020961-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWindows; PROCEDURE IsWindows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020961-0000-0000-C000-000000000046}") END IsWindows; PROCEDURE ThisPane* (v: CtlT.Any): Pane; VAR new: Pane; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020960-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPane; PROCEDURE IsPane* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020960-0000-0000-C000-000000000046}") END IsPane; PROCEDURE ThisPanes* (v: CtlT.Any): Panes; VAR new: Panes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPanes; PROCEDURE IsPanes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095F-0000-0000-C000-000000000046}") END IsPanes; PROCEDURE ThisRange* (v: CtlT.Any): Range; VAR new: Range; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRange; PROCEDURE IsRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095E-0000-0000-C000-000000000046}") END IsRange; PROCEDURE ThisListFormat* (v: CtlT.Any): ListFormat; VAR new: ListFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListFormat; PROCEDURE IsListFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C0-0000-0000-C000-000000000046}") END IsListFormat; PROCEDURE ThisFind* (v: CtlT.Any): Find; VAR new: Find; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFind; PROCEDURE IsFind* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B0-0000-0000-C000-000000000046}") END IsFind; PROCEDURE ThisReplacement* (v: CtlT.Any): Replacement; VAR new: Replacement; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisReplacement; PROCEDURE IsReplacement* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B1-0000-0000-C000-000000000046}") END IsReplacement; PROCEDURE ThisCharacters* (v: CtlT.Any): Characters; VAR new: Characters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCharacters; PROCEDURE IsCharacters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095D-0000-0000-C000-000000000046}") END IsCharacters; PROCEDURE ThisWords* (v: CtlT.Any): Words; VAR new: Words; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWords; PROCEDURE IsWords* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095C-0000-0000-C000-000000000046}") END IsWords; PROCEDURE ThisSentences* (v: CtlT.Any): Sentences; VAR new: Sentences; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSentences; PROCEDURE IsSentences* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095B-0000-0000-C000-000000000046}") END IsSentences; PROCEDURE ThisSections* (v: CtlT.Any): Sections; VAR new: Sections; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002095A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSections; PROCEDURE IsSections* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002095A-0000-0000-C000-000000000046}") END IsSections; PROCEDURE ThisSection* (v: CtlT.Any): Section; VAR new: Section; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020959-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSection; PROCEDURE IsSection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020959-0000-0000-C000-000000000046}") END IsSection; PROCEDURE ThisParagraphs* (v: CtlT.Any): Paragraphs; VAR new: Paragraphs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020958-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisParagraphs; PROCEDURE IsParagraphs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020958-0000-0000-C000-000000000046}") END IsParagraphs; PROCEDURE ThisParagraph* (v: CtlT.Any): Paragraph; VAR new: Paragraph; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020957-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisParagraph; PROCEDURE IsParagraph* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020957-0000-0000-C000-000000000046}") END IsParagraph; PROCEDURE ThisDropCap* (v: CtlT.Any): DropCap; VAR new: DropCap; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020956-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropCap; PROCEDURE IsDropCap* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020956-0000-0000-C000-000000000046}") END IsDropCap; PROCEDURE ThisTabStops* (v: CtlT.Any): TabStops; VAR new: TabStops; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020955-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTabStops; PROCEDURE IsTabStops* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020955-0000-0000-C000-000000000046}") END IsTabStops; PROCEDURE ThisTabStop* (v: CtlT.Any): TabStop; VAR new: TabStop; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020954-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTabStop; PROCEDURE IsTabStop* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020954-0000-0000-C000-000000000046}") END IsTabStop; PROCEDURE This_ParagraphFormat* (v: CtlT.Any): _ParagraphFormat; VAR new: _ParagraphFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020953-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_ParagraphFormat; PROCEDURE Is_ParagraphFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020953-0000-0000-C000-000000000046}") END Is_ParagraphFormat; PROCEDURE This_Font* (v: CtlT.Any): _Font; VAR new: _Font; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020952-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_Font; PROCEDURE Is_Font* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020952-0000-0000-C000-000000000046}") END Is_Font; PROCEDURE ThisTable* (v: CtlT.Any): Table; VAR new: Table; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020951-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTable; PROCEDURE IsTable* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020951-0000-0000-C000-000000000046}") END IsTable; PROCEDURE ThisRow* (v: CtlT.Any): Row; VAR new: Row; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020950-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRow; PROCEDURE IsRow* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020950-0000-0000-C000-000000000046}") END IsRow; PROCEDURE ThisColumn* (v: CtlT.Any): Column; VAR new: Column; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisColumn; PROCEDURE IsColumn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094F-0000-0000-C000-000000000046}") END IsColumn; PROCEDURE ThisCell* (v: CtlT.Any): Cell; VAR new: Cell; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCell; PROCEDURE IsCell* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094E-0000-0000-C000-000000000046}") END IsCell; PROCEDURE ThisTables* (v: CtlT.Any): Tables; VAR new: Tables; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTables; PROCEDURE IsTables* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094D-0000-0000-C000-000000000046}") END IsTables; PROCEDURE ThisRows* (v: CtlT.Any): Rows; VAR new: Rows; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRows; PROCEDURE IsRows* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094C-0000-0000-C000-000000000046}") END IsRows; PROCEDURE ThisColumns* (v: CtlT.Any): Columns; VAR new: Columns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisColumns; PROCEDURE IsColumns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094B-0000-0000-C000-000000000046}") END IsColumns; PROCEDURE ThisCells* (v: CtlT.Any): Cells; VAR new: Cells; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002094A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCells; PROCEDURE IsCells* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002094A-0000-0000-C000-000000000046}") END IsCells; PROCEDURE ThisAutoCorrect* (v: CtlT.Any): AutoCorrect; VAR new: AutoCorrect; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020949-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCorrect; PROCEDURE IsAutoCorrect* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020949-0000-0000-C000-000000000046}") END IsAutoCorrect; PROCEDURE ThisAutoCorrectEntries* (v: CtlT.Any): AutoCorrectEntries; VAR new: AutoCorrectEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020948-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCorrectEntries; PROCEDURE IsAutoCorrectEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020948-0000-0000-C000-000000000046}") END IsAutoCorrectEntries; PROCEDURE ThisAutoCorrectEntry* (v: CtlT.Any): AutoCorrectEntry; VAR new: AutoCorrectEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020947-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCorrectEntry; PROCEDURE IsAutoCorrectEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020947-0000-0000-C000-000000000046}") END IsAutoCorrectEntry; PROCEDURE ThisFirstLetterExceptions* (v: CtlT.Any): FirstLetterExceptions; VAR new: FirstLetterExceptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020946-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFirstLetterExceptions; PROCEDURE IsFirstLetterExceptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020946-0000-0000-C000-000000000046}") END IsFirstLetterExceptions; PROCEDURE ThisFirstLetterException* (v: CtlT.Any): FirstLetterException; VAR new: FirstLetterException; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020945-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFirstLetterException; PROCEDURE IsFirstLetterException* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020945-0000-0000-C000-000000000046}") END IsFirstLetterException; PROCEDURE ThisTwoInitialCapsExceptions* (v: CtlT.Any): TwoInitialCapsExceptions; VAR new: TwoInitialCapsExceptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020944-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTwoInitialCapsExceptions; PROCEDURE IsTwoInitialCapsExceptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020944-0000-0000-C000-000000000046}") END IsTwoInitialCapsExceptions; PROCEDURE ThisTwoInitialCapsException* (v: CtlT.Any): TwoInitialCapsException; VAR new: TwoInitialCapsException; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020943-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTwoInitialCapsException; PROCEDURE IsTwoInitialCapsException* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020943-0000-0000-C000-000000000046}") END IsTwoInitialCapsException; PROCEDURE ThisFootnotes* (v: CtlT.Any): Footnotes; VAR new: Footnotes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020942-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFootnotes; PROCEDURE IsFootnotes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020942-0000-0000-C000-000000000046}") END IsFootnotes; PROCEDURE ThisEndnotes* (v: CtlT.Any): Endnotes; VAR new: Endnotes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020941-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEndnotes; PROCEDURE IsEndnotes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020941-0000-0000-C000-000000000046}") END IsEndnotes; PROCEDURE ThisComments* (v: CtlT.Any): Comments; VAR new: Comments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020940-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisComments; PROCEDURE IsComments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020940-0000-0000-C000-000000000046}") END IsComments; PROCEDURE ThisFootnote* (v: CtlT.Any): Footnote; VAR new: Footnote; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFootnote; PROCEDURE IsFootnote* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093F-0000-0000-C000-000000000046}") END IsFootnote; PROCEDURE ThisEndnote* (v: CtlT.Any): Endnote; VAR new: Endnote; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEndnote; PROCEDURE IsEndnote* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093E-0000-0000-C000-000000000046}") END IsEndnote; PROCEDURE ThisComment* (v: CtlT.Any): Comment; VAR new: Comment; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisComment; PROCEDURE IsComment* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093D-0000-0000-C000-000000000046}") END IsComment; PROCEDURE ThisBorders* (v: CtlT.Any): Borders; VAR new: Borders; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBorders; PROCEDURE IsBorders* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093C-0000-0000-C000-000000000046}") END IsBorders; PROCEDURE ThisBorder* (v: CtlT.Any): Border; VAR new: Border; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBorder; PROCEDURE IsBorder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093B-0000-0000-C000-000000000046}") END IsBorder; PROCEDURE ThisShading* (v: CtlT.Any): Shading; VAR new: Shading; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002093A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShading; PROCEDURE IsShading* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002093A-0000-0000-C000-000000000046}") END IsShading; PROCEDURE ThisTextRetrievalMode* (v: CtlT.Any): TextRetrievalMode; VAR new: TextRetrievalMode; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020939-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextRetrievalMode; PROCEDURE IsTextRetrievalMode* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020939-0000-0000-C000-000000000046}") END IsTextRetrievalMode; PROCEDURE ThisAutoTextEntries* (v: CtlT.Any): AutoTextEntries; VAR new: AutoTextEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020937-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoTextEntries; PROCEDURE IsAutoTextEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020937-0000-0000-C000-000000000046}") END IsAutoTextEntries; PROCEDURE ThisAutoTextEntry* (v: CtlT.Any): AutoTextEntry; VAR new: AutoTextEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020936-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoTextEntry; PROCEDURE IsAutoTextEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020936-0000-0000-C000-000000000046}") END IsAutoTextEntry; PROCEDURE ThisSystem* (v: CtlT.Any): System; VAR new: System; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020935-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSystem; PROCEDURE IsSystem* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020935-0000-0000-C000-000000000046}") END IsSystem; PROCEDURE ThisOLEFormat* (v: CtlT.Any): OLEFormat; VAR new: OLEFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020933-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOLEFormat; PROCEDURE IsOLEFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020933-0000-0000-C000-000000000046}") END IsOLEFormat; PROCEDURE ThisLinkFormat* (v: CtlT.Any): LinkFormat; VAR new: LinkFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020931-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLinkFormat; PROCEDURE IsLinkFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020931-0000-0000-C000-000000000046}") END IsLinkFormat; PROCEDURE This_OLEControl* (v: CtlT.Any): _OLEControl; VAR new: _OLEControl; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_OLEControl; PROCEDURE Is_OLEControl* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A4-0000-0000-C000-000000000046}") END Is_OLEControl; PROCEDURE ThisFields* (v: CtlT.Any): Fields; VAR new: Fields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020930-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFields; PROCEDURE IsFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020930-0000-0000-C000-000000000046}") END IsFields; PROCEDURE ThisField* (v: CtlT.Any): Field; VAR new: Field; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisField; PROCEDURE IsField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092F-0000-0000-C000-000000000046}") END IsField; PROCEDURE ThisBrowser* (v: CtlT.Any): Browser; VAR new: Browser; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisBrowser; PROCEDURE IsBrowser* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092E-0000-0000-C000-000000000046}") END IsBrowser; PROCEDURE ThisStyles* (v: CtlT.Any): Styles; VAR new: Styles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisStyles; PROCEDURE IsStyles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092D-0000-0000-C000-000000000046}") END IsStyles; PROCEDURE ThisStyle* (v: CtlT.Any): Style; VAR new: Style; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisStyle; PROCEDURE IsStyle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092C-0000-0000-C000-000000000046}") END IsStyle; PROCEDURE ThisFrames* (v: CtlT.Any): Frames; VAR new: Frames; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFrames; PROCEDURE IsFrames* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092B-0000-0000-C000-000000000046}") END IsFrames; PROCEDURE ThisFrame* (v: CtlT.Any): Frame; VAR new: Frame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002092A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFrame; PROCEDURE IsFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002092A-0000-0000-C000-000000000046}") END IsFrame; PROCEDURE ThisFormFields* (v: CtlT.Any): FormFields; VAR new: FormFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020929-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFormFields; PROCEDURE IsFormFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020929-0000-0000-C000-000000000046}") END IsFormFields; PROCEDURE ThisFormField* (v: CtlT.Any): FormField; VAR new: FormField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020928-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFormField; PROCEDURE IsFormField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020928-0000-0000-C000-000000000046}") END IsFormField; PROCEDURE ThisTextInput* (v: CtlT.Any): TextInput; VAR new: TextInput; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020927-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextInput; PROCEDURE IsTextInput* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020927-0000-0000-C000-000000000046}") END IsTextInput; PROCEDURE ThisCheckBox* (v: CtlT.Any): CheckBox; VAR new: CheckBox; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020926-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCheckBox; PROCEDURE IsCheckBox* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020926-0000-0000-C000-000000000046}") END IsCheckBox; PROCEDURE ThisDropDown* (v: CtlT.Any): DropDown; VAR new: DropDown; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020925-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDropDown; PROCEDURE IsDropDown* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020925-0000-0000-C000-000000000046}") END IsDropDown; PROCEDURE ThisListEntries* (v: CtlT.Any): ListEntries; VAR new: ListEntries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020924-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListEntries; PROCEDURE IsListEntries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020924-0000-0000-C000-000000000046}") END IsListEntries; PROCEDURE ThisListEntry* (v: CtlT.Any): ListEntry; VAR new: ListEntry; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020923-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListEntry; PROCEDURE IsListEntry* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020923-0000-0000-C000-000000000046}") END IsListEntry; PROCEDURE ThisTablesOfFigures* (v: CtlT.Any): TablesOfFigures; VAR new: TablesOfFigures; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020922-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTablesOfFigures; PROCEDURE IsTablesOfFigures* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020922-0000-0000-C000-000000000046}") END IsTablesOfFigures; PROCEDURE ThisTableOfFigures* (v: CtlT.Any): TableOfFigures; VAR new: TableOfFigures; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020921-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTableOfFigures; PROCEDURE IsTableOfFigures* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020921-0000-0000-C000-000000000046}") END IsTableOfFigures; PROCEDURE ThisMailMerge* (v: CtlT.Any): MailMerge; VAR new: MailMerge; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020920-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMerge; PROCEDURE IsMailMerge* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020920-0000-0000-C000-000000000046}") END IsMailMerge; PROCEDURE ThisMailMergeFields* (v: CtlT.Any): MailMergeFields; VAR new: MailMergeFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeFields; PROCEDURE IsMailMergeFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091F-0000-0000-C000-000000000046}") END IsMailMergeFields; PROCEDURE ThisMailMergeField* (v: CtlT.Any): MailMergeField; VAR new: MailMergeField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeField; PROCEDURE IsMailMergeField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091E-0000-0000-C000-000000000046}") END IsMailMergeField; PROCEDURE ThisMailMergeDataSource* (v: CtlT.Any): MailMergeDataSource; VAR new: MailMergeDataSource; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeDataSource; PROCEDURE IsMailMergeDataSource* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091D-0000-0000-C000-000000000046}") END IsMailMergeDataSource; PROCEDURE ThisMailMergeFieldNames* (v: CtlT.Any): MailMergeFieldNames; VAR new: MailMergeFieldNames; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeFieldNames; PROCEDURE IsMailMergeFieldNames* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091C-0000-0000-C000-000000000046}") END IsMailMergeFieldNames; PROCEDURE ThisMailMergeFieldName* (v: CtlT.Any): MailMergeFieldName; VAR new: MailMergeFieldName; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeFieldName; PROCEDURE IsMailMergeFieldName* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091B-0000-0000-C000-000000000046}") END IsMailMergeFieldName; PROCEDURE ThisMailMergeDataFields* (v: CtlT.Any): MailMergeDataFields; VAR new: MailMergeDataFields; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002091A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeDataFields; PROCEDURE IsMailMergeDataFields* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002091A-0000-0000-C000-000000000046}") END IsMailMergeDataFields; PROCEDURE ThisMailMergeDataField* (v: CtlT.Any): MailMergeDataField; VAR new: MailMergeDataField; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020919-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMergeDataField; PROCEDURE IsMailMergeDataField* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020919-0000-0000-C000-000000000046}") END IsMailMergeDataField; PROCEDURE ThisEnvelope* (v: CtlT.Any): Envelope; VAR new: Envelope; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020918-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEnvelope; PROCEDURE IsEnvelope* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020918-0000-0000-C000-000000000046}") END IsEnvelope; PROCEDURE ThisMailingLabel* (v: CtlT.Any): MailingLabel; VAR new: MailingLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020917-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailingLabel; PROCEDURE IsMailingLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020917-0000-0000-C000-000000000046}") END IsMailingLabel; PROCEDURE ThisCustomLabels* (v: CtlT.Any): CustomLabels; VAR new: CustomLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020916-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCustomLabels; PROCEDURE IsCustomLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020916-0000-0000-C000-000000000046}") END IsCustomLabels; PROCEDURE ThisCustomLabel* (v: CtlT.Any): CustomLabel; VAR new: CustomLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020915-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCustomLabel; PROCEDURE IsCustomLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020915-0000-0000-C000-000000000046}") END IsCustomLabel; PROCEDURE ThisTablesOfContents* (v: CtlT.Any): TablesOfContents; VAR new: TablesOfContents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020914-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTablesOfContents; PROCEDURE IsTablesOfContents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020914-0000-0000-C000-000000000046}") END IsTablesOfContents; PROCEDURE ThisTableOfContents* (v: CtlT.Any): TableOfContents; VAR new: TableOfContents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020913-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTableOfContents; PROCEDURE IsTableOfContents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020913-0000-0000-C000-000000000046}") END IsTableOfContents; PROCEDURE ThisTablesOfAuthorities* (v: CtlT.Any): TablesOfAuthorities; VAR new: TablesOfAuthorities; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020912-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTablesOfAuthorities; PROCEDURE IsTablesOfAuthorities* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020912-0000-0000-C000-000000000046}") END IsTablesOfAuthorities; PROCEDURE ThisTableOfAuthorities* (v: CtlT.Any): TableOfAuthorities; VAR new: TableOfAuthorities; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020911-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTableOfAuthorities; PROCEDURE IsTableOfAuthorities* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020911-0000-0000-C000-000000000046}") END IsTableOfAuthorities; PROCEDURE ThisDialogs* (v: CtlT.Any): Dialogs; VAR new: Dialogs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020910-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialogs; PROCEDURE IsDialogs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020910-0000-0000-C000-000000000046}") END IsDialogs; PROCEDURE ThisDialog* (v: CtlT.Any): Dialog; VAR new: Dialog; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDialog; PROCEDURE IsDialog* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B8-0000-0000-C000-000000000046}") END IsDialog; PROCEDURE ThisPageSetup* (v: CtlT.Any): PageSetup; VAR new: PageSetup; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020971-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPageSetup; PROCEDURE IsPageSetup* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020971-0000-0000-C000-000000000046}") END IsPageSetup; PROCEDURE ThisLineNumbering* (v: CtlT.Any): LineNumbering; VAR new: LineNumbering; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020972-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLineNumbering; PROCEDURE IsLineNumbering* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020972-0000-0000-C000-000000000046}") END IsLineNumbering; PROCEDURE ThisTextColumns* (v: CtlT.Any): TextColumns; VAR new: TextColumns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020973-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextColumns; PROCEDURE IsTextColumns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020973-0000-0000-C000-000000000046}") END IsTextColumns; PROCEDURE ThisTextColumn* (v: CtlT.Any): TextColumn; VAR new: TextColumn; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020974-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextColumn; PROCEDURE IsTextColumn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020974-0000-0000-C000-000000000046}") END IsTextColumn; PROCEDURE ThisSelection* (v: CtlT.Any): Selection; VAR new: Selection; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020975-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSelection; PROCEDURE IsSelection* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020975-0000-0000-C000-000000000046}") END IsSelection; PROCEDURE ThisTablesOfAuthoritiesCategories* (v: CtlT.Any): TablesOfAuthoritiesCategories; VAR new: TablesOfAuthoritiesCategories; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020976-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTablesOfAuthoritiesCategories; PROCEDURE IsTablesOfAuthoritiesCategories* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020976-0000-0000-C000-000000000046}") END IsTablesOfAuthoritiesCategories; PROCEDURE ThisTableOfAuthoritiesCategory* (v: CtlT.Any): TableOfAuthoritiesCategory; VAR new: TableOfAuthoritiesCategory; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020977-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTableOfAuthoritiesCategory; PROCEDURE IsTableOfAuthoritiesCategory* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020977-0000-0000-C000-000000000046}") END IsTableOfAuthoritiesCategory; PROCEDURE ThisCaptionLabels* (v: CtlT.Any): CaptionLabels; VAR new: CaptionLabels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020978-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCaptionLabels; PROCEDURE IsCaptionLabels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020978-0000-0000-C000-000000000046}") END IsCaptionLabels; PROCEDURE ThisCaptionLabel* (v: CtlT.Any): CaptionLabel; VAR new: CaptionLabel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020979-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCaptionLabel; PROCEDURE IsCaptionLabel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020979-0000-0000-C000-000000000046}") END IsCaptionLabel; PROCEDURE ThisAutoCaptions* (v: CtlT.Any): AutoCaptions; VAR new: AutoCaptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCaptions; PROCEDURE IsAutoCaptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097A-0000-0000-C000-000000000046}") END IsAutoCaptions; PROCEDURE ThisAutoCaption* (v: CtlT.Any): AutoCaption; VAR new: AutoCaption; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAutoCaption; PROCEDURE IsAutoCaption* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097B-0000-0000-C000-000000000046}") END IsAutoCaption; PROCEDURE ThisIndexes* (v: CtlT.Any): Indexes; VAR new: Indexes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIndexes; PROCEDURE IsIndexes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097C-0000-0000-C000-000000000046}") END IsIndexes; PROCEDURE ThisIndex* (v: CtlT.Any): Index; VAR new: Index; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIndex; PROCEDURE IsIndex* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097D-0000-0000-C000-000000000046}") END IsIndex; PROCEDURE ThisAddIn* (v: CtlT.Any): AddIn; VAR new: AddIn; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddIn; PROCEDURE IsAddIn* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097E-0000-0000-C000-000000000046}") END IsAddIn; PROCEDURE ThisAddIns* (v: CtlT.Any): AddIns; VAR new: AddIns; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002097F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAddIns; PROCEDURE IsAddIns* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002097F-0000-0000-C000-000000000046}") END IsAddIns; PROCEDURE ThisRevisions* (v: CtlT.Any): Revisions; VAR new: Revisions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020980-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRevisions; PROCEDURE IsRevisions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020980-0000-0000-C000-000000000046}") END IsRevisions; PROCEDURE ThisRevision* (v: CtlT.Any): Revision; VAR new: Revision; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020981-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisRevision; PROCEDURE IsRevision* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020981-0000-0000-C000-000000000046}") END IsRevision; PROCEDURE ThisTask* (v: CtlT.Any): Task; VAR new: Task; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020982-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTask; PROCEDURE IsTask* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020982-0000-0000-C000-000000000046}") END IsTask; PROCEDURE ThisTasks* (v: CtlT.Any): Tasks; VAR new: Tasks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020983-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTasks; PROCEDURE IsTasks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020983-0000-0000-C000-000000000046}") END IsTasks; PROCEDURE ThisHeadersFooters* (v: CtlT.Any): HeadersFooters; VAR new: HeadersFooters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020984-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHeadersFooters; PROCEDURE IsHeadersFooters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020984-0000-0000-C000-000000000046}") END IsHeadersFooters; PROCEDURE ThisHeaderFooter* (v: CtlT.Any): HeaderFooter; VAR new: HeaderFooter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020985-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHeaderFooter; PROCEDURE IsHeaderFooter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020985-0000-0000-C000-000000000046}") END IsHeaderFooter; PROCEDURE ThisPageNumbers* (v: CtlT.Any): PageNumbers; VAR new: PageNumbers; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020986-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPageNumbers; PROCEDURE IsPageNumbers* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020986-0000-0000-C000-000000000046}") END IsPageNumbers; PROCEDURE ThisPageNumber* (v: CtlT.Any): PageNumber; VAR new: PageNumber; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020987-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPageNumber; PROCEDURE IsPageNumber* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020987-0000-0000-C000-000000000046}") END IsPageNumber; PROCEDURE ThisSubdocuments* (v: CtlT.Any): Subdocuments; VAR new: Subdocuments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020988-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSubdocuments; PROCEDURE IsSubdocuments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020988-0000-0000-C000-000000000046}") END IsSubdocuments; PROCEDURE ThisSubdocument* (v: CtlT.Any): Subdocument; VAR new: Subdocument; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020989-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSubdocument; PROCEDURE IsSubdocument* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020989-0000-0000-C000-000000000046}") END IsSubdocument; PROCEDURE ThisHeadingStyles* (v: CtlT.Any): HeadingStyles; VAR new: HeadingStyles; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHeadingStyles; PROCEDURE IsHeadingStyles* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098A-0000-0000-C000-000000000046}") END IsHeadingStyles; PROCEDURE ThisHeadingStyle* (v: CtlT.Any): HeadingStyle; VAR new: HeadingStyle; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHeadingStyle; PROCEDURE IsHeadingStyle* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098B-0000-0000-C000-000000000046}") END IsHeadingStyle; PROCEDURE ThisStoryRanges* (v: CtlT.Any): StoryRanges; VAR new: StoryRanges; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisStoryRanges; PROCEDURE IsStoryRanges* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098C-0000-0000-C000-000000000046}") END IsStoryRanges; PROCEDURE ThisListLevel* (v: CtlT.Any): ListLevel; VAR new: ListLevel; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListLevel; PROCEDURE IsListLevel* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098D-0000-0000-C000-000000000046}") END IsListLevel; PROCEDURE ThisListLevels* (v: CtlT.Any): ListLevels; VAR new: ListLevels; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098E-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListLevels; PROCEDURE IsListLevels* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098E-0000-0000-C000-000000000046}") END IsListLevels; PROCEDURE ThisListTemplate* (v: CtlT.Any): ListTemplate; VAR new: ListTemplate; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002098F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListTemplate; PROCEDURE IsListTemplate* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002098F-0000-0000-C000-000000000046}") END IsListTemplate; PROCEDURE ThisListTemplates* (v: CtlT.Any): ListTemplates; VAR new: ListTemplates; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020990-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListTemplates; PROCEDURE IsListTemplates* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020990-0000-0000-C000-000000000046}") END IsListTemplates; PROCEDURE ThisListParagraphs* (v: CtlT.Any): ListParagraphs; VAR new: ListParagraphs; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020991-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListParagraphs; PROCEDURE IsListParagraphs* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020991-0000-0000-C000-000000000046}") END IsListParagraphs; PROCEDURE ThisList* (v: CtlT.Any): List; VAR new: List; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020992-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisList; PROCEDURE IsList* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020992-0000-0000-C000-000000000046}") END IsList; PROCEDURE ThisLists* (v: CtlT.Any): Lists; VAR new: Lists; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020993-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLists; PROCEDURE IsLists* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020993-0000-0000-C000-000000000046}") END IsLists; PROCEDURE ThisListGallery* (v: CtlT.Any): ListGallery; VAR new: ListGallery; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020994-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListGallery; PROCEDURE IsListGallery* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020994-0000-0000-C000-000000000046}") END IsListGallery; PROCEDURE ThisListGalleries* (v: CtlT.Any): ListGalleries; VAR new: ListGalleries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020995-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisListGalleries; PROCEDURE IsListGalleries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020995-0000-0000-C000-000000000046}") END IsListGalleries; PROCEDURE ThisKeyBindings* (v: CtlT.Any): KeyBindings; VAR new: KeyBindings; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020996-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisKeyBindings; PROCEDURE IsKeyBindings* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020996-0000-0000-C000-000000000046}") END IsKeyBindings; PROCEDURE ThisKeysBoundTo* (v: CtlT.Any): KeysBoundTo; VAR new: KeysBoundTo; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020997-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisKeysBoundTo; PROCEDURE IsKeysBoundTo* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020997-0000-0000-C000-000000000046}") END IsKeysBoundTo; PROCEDURE ThisKeyBinding* (v: CtlT.Any): KeyBinding; VAR new: KeyBinding; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020998-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisKeyBinding; PROCEDURE IsKeyBinding* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020998-0000-0000-C000-000000000046}") END IsKeyBinding; PROCEDURE ThisFileConverter* (v: CtlT.Any): FileConverter; VAR new: FileConverter; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{00020999-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFileConverter; PROCEDURE IsFileConverter* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{00020999-0000-0000-C000-000000000046}") END IsFileConverter; PROCEDURE ThisFileConverters* (v: CtlT.Any): FileConverters; VAR new: FileConverters; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002099A-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFileConverters; PROCEDURE IsFileConverters* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002099A-0000-0000-C000-000000000046}") END IsFileConverters; PROCEDURE ThisSynonymInfo* (v: CtlT.Any): SynonymInfo; VAR new: SynonymInfo; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002099B-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSynonymInfo; PROCEDURE IsSynonymInfo* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002099B-0000-0000-C000-000000000046}") END IsSynonymInfo; PROCEDURE ThisHyperlinks* (v: CtlT.Any): Hyperlinks; VAR new: Hyperlinks; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002099C-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHyperlinks; PROCEDURE IsHyperlinks* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002099C-0000-0000-C000-000000000046}") END IsHyperlinks; PROCEDURE ThisHyperlink* (v: CtlT.Any): Hyperlink; VAR new: Hyperlink; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002099D-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHyperlink; PROCEDURE IsHyperlink* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002099D-0000-0000-C000-000000000046}") END IsHyperlink; PROCEDURE ThisShapes* (v: CtlT.Any): Shapes; VAR new: Shapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{0002099F-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapes; PROCEDURE IsShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{0002099F-0000-0000-C000-000000000046}") END IsShapes; PROCEDURE ThisShapeRange* (v: CtlT.Any): ShapeRange; VAR new: ShapeRange; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeRange; PROCEDURE IsShapeRange* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B5-0000-0000-C000-000000000046}") END IsShapeRange; PROCEDURE ThisGroupShapes* (v: CtlT.Any): GroupShapes; VAR new: GroupShapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisGroupShapes; PROCEDURE IsGroupShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B6-0000-0000-C000-000000000046}") END IsGroupShapes; PROCEDURE ThisShape* (v: CtlT.Any): Shape; VAR new: Shape; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShape; PROCEDURE IsShape* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A0-0000-0000-C000-000000000046}") END IsShape; PROCEDURE ThisTextFrame* (v: CtlT.Any): TextFrame; VAR new: TextFrame; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextFrame; PROCEDURE IsTextFrame* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B2-0000-0000-C000-000000000046}") END IsTextFrame; PROCEDURE This_LetterContent* (v: CtlT.Any): _LetterContent; VAR new: _LetterContent; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END This_LetterContent; PROCEDURE Is_LetterContent* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A1-0000-0000-C000-000000000046}") END Is_LetterContent; PROCEDURE ThisView* (v: CtlT.Any): View; VAR new: View; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisView; PROCEDURE IsView* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A5-0000-0000-C000-000000000046}") END IsView; PROCEDURE ThisZoom* (v: CtlT.Any): Zoom; VAR new: Zoom; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisZoom; PROCEDURE IsZoom* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A6-0000-0000-C000-000000000046}") END IsZoom; PROCEDURE ThisZooms* (v: CtlT.Any): Zooms; VAR new: Zooms; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisZooms; PROCEDURE IsZooms* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A7-0000-0000-C000-000000000046}") END IsZooms; PROCEDURE ThisInlineShape* (v: CtlT.Any): InlineShape; VAR new: InlineShape; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisInlineShape; PROCEDURE IsInlineShape* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A8-0000-0000-C000-000000000046}") END IsInlineShape; PROCEDURE ThisInlineShapes* (v: CtlT.Any): InlineShapes; VAR new: InlineShapes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209A9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisInlineShapes; PROCEDURE IsInlineShapes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209A9-0000-0000-C000-000000000046}") END IsInlineShapes; PROCEDURE ThisSpellingSuggestions* (v: CtlT.Any): SpellingSuggestions; VAR new: SpellingSuggestions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSpellingSuggestions; PROCEDURE IsSpellingSuggestions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AA-0000-0000-C000-000000000046}") END IsSpellingSuggestions; PROCEDURE ThisSpellingSuggestion* (v: CtlT.Any): SpellingSuggestion; VAR new: SpellingSuggestion; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisSpellingSuggestion; PROCEDURE IsSpellingSuggestion* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AB-0000-0000-C000-000000000046}") END IsSpellingSuggestion; PROCEDURE ThisDictionaries* (v: CtlT.Any): Dictionaries; VAR new: Dictionaries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDictionaries; PROCEDURE IsDictionaries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AC-0000-0000-C000-000000000046}") END IsDictionaries; PROCEDURE ThisHangulHanjaConversionDictionaries* (v: CtlT.Any): HangulHanjaConversionDictionaries; VAR new: HangulHanjaConversionDictionaries; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209E0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHangulHanjaConversionDictionaries; PROCEDURE IsHangulHanjaConversionDictionaries* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209E0-0000-0000-C000-000000000046}") END IsHangulHanjaConversionDictionaries; PROCEDURE ThisDictionary* (v: CtlT.Any): Dictionary; VAR new: Dictionary; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDictionary; PROCEDURE IsDictionary* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AD-0000-0000-C000-000000000046}") END IsDictionary; PROCEDURE ThisReadabilityStatistics* (v: CtlT.Any): ReadabilityStatistics; VAR new: ReadabilityStatistics; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisReadabilityStatistics; PROCEDURE IsReadabilityStatistics* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AE-0000-0000-C000-000000000046}") END IsReadabilityStatistics; PROCEDURE ThisReadabilityStatistic* (v: CtlT.Any): ReadabilityStatistic; VAR new: ReadabilityStatistic; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209AF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisReadabilityStatistic; PROCEDURE IsReadabilityStatistic* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209AF-0000-0000-C000-000000000046}") END IsReadabilityStatistic; PROCEDURE ThisVersions* (v: CtlT.Any): Versions; VAR new: Versions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVersions; PROCEDURE IsVersions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B3-0000-0000-C000-000000000046}") END IsVersions; PROCEDURE ThisVersion* (v: CtlT.Any): Version; VAR new: Version; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisVersion; PROCEDURE IsVersion* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B4-0000-0000-C000-000000000046}") END IsVersion; PROCEDURE ThisOptions* (v: CtlT.Any): Options; VAR new: Options; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209B7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOptions; PROCEDURE IsOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209B7-0000-0000-C000-000000000046}") END IsOptions; PROCEDURE ThisMailMessage* (v: CtlT.Any): MailMessage; VAR new: MailMessage; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209BA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailMessage; PROCEDURE IsMailMessage* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209BA-0000-0000-C000-000000000046}") END IsMailMessage; PROCEDURE ThisProofreadingErrors* (v: CtlT.Any): ProofreadingErrors; VAR new: ProofreadingErrors; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209BB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisProofreadingErrors; PROCEDURE IsProofreadingErrors* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209BB-0000-0000-C000-000000000046}") END IsProofreadingErrors; PROCEDURE ThisMailer* (v: CtlT.Any): Mailer; VAR new: Mailer; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209BD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisMailer; PROCEDURE IsMailer* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209BD-0000-0000-C000-000000000046}") END IsMailer; PROCEDURE ThisWrapFormat* (v: CtlT.Any): WrapFormat; VAR new: WrapFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWrapFormat; PROCEDURE IsWrapFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C3-0000-0000-C000-000000000046}") END IsWrapFormat; PROCEDURE ThisHangulAndAlphabetExceptions* (v: CtlT.Any): HangulAndAlphabetExceptions; VAR new: HangulAndAlphabetExceptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209D1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHangulAndAlphabetExceptions; PROCEDURE IsHangulAndAlphabetExceptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209D1-0000-0000-C000-000000000046}") END IsHangulAndAlphabetExceptions; PROCEDURE ThisHangulAndAlphabetException* (v: CtlT.Any): HangulAndAlphabetException; VAR new: HangulAndAlphabetException; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209D2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHangulAndAlphabetException; PROCEDURE IsHangulAndAlphabetException* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209D2-0000-0000-C000-000000000046}") END IsHangulAndAlphabetException; PROCEDURE ThisAdjustments* (v: CtlT.Any): Adjustments; VAR new: Adjustments; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisAdjustments; PROCEDURE IsAdjustments* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C4-0000-0000-C000-000000000046}") END IsAdjustments; PROCEDURE ThisCalloutFormat* (v: CtlT.Any): CalloutFormat; VAR new: CalloutFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C5-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisCalloutFormat; PROCEDURE IsCalloutFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C5-0000-0000-C000-000000000046}") END IsCalloutFormat; PROCEDURE ThisColorFormat* (v: CtlT.Any): ColorFormat; VAR new: ColorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C6-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisColorFormat; PROCEDURE IsColorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C6-0000-0000-C000-000000000046}") END IsColorFormat; PROCEDURE ThisConnectorFormat* (v: CtlT.Any): ConnectorFormat; VAR new: ConnectorFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisConnectorFormat; PROCEDURE IsConnectorFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C7-0000-0000-C000-000000000046}") END IsConnectorFormat; PROCEDURE ThisFillFormat* (v: CtlT.Any): FillFormat; VAR new: FillFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C8-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFillFormat; PROCEDURE IsFillFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C8-0000-0000-C000-000000000046}") END IsFillFormat; PROCEDURE ThisFreeformBuilder* (v: CtlT.Any): FreeformBuilder; VAR new: FreeformBuilder; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209C9-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFreeformBuilder; PROCEDURE IsFreeformBuilder* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209C9-0000-0000-C000-000000000046}") END IsFreeformBuilder; PROCEDURE ThisLineFormat* (v: CtlT.Any): LineFormat; VAR new: LineFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CA-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisLineFormat; PROCEDURE IsLineFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CA-0000-0000-C000-000000000046}") END IsLineFormat; PROCEDURE ThisPictureFormat* (v: CtlT.Any): PictureFormat; VAR new: PictureFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisPictureFormat; PROCEDURE IsPictureFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CB-0000-0000-C000-000000000046}") END IsPictureFormat; PROCEDURE ThisShadowFormat* (v: CtlT.Any): ShadowFormat; VAR new: ShadowFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShadowFormat; PROCEDURE IsShadowFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CC-0000-0000-C000-000000000046}") END IsShadowFormat; PROCEDURE ThisShapeNode* (v: CtlT.Any): ShapeNode; VAR new: ShapeNode; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNode; PROCEDURE IsShapeNode* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CD-0000-0000-C000-000000000046}") END IsShapeNode; PROCEDURE ThisShapeNodes* (v: CtlT.Any): ShapeNodes; VAR new: ShapeNodes; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisShapeNodes; PROCEDURE IsShapeNodes* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CE-0000-0000-C000-000000000046}") END IsShapeNodes; PROCEDURE ThisTextEffectFormat* (v: CtlT.Any): TextEffectFormat; VAR new: TextEffectFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209CF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisTextEffectFormat; PROCEDURE IsTextEffectFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209CF-0000-0000-C000-000000000046}") END IsTextEffectFormat; PROCEDURE ThisThreeDFormat* (v: CtlT.Any): ThreeDFormat; VAR new: ThreeDFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209D0-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisThreeDFormat; PROCEDURE IsThreeDFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209D0-0000-0000-C000-000000000046}") END IsThreeDFormat; PROCEDURE ThisIApplicationEvents* (v: CtlT.Any): IApplicationEvents; VAR new: IApplicationEvents; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209F7-0001-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIApplicationEvents; PROCEDURE IsIApplicationEvents* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209F7-0001-0000-C000-000000000046}") END IsIApplicationEvents; PROCEDURE ThisIApplicationEvents2* (v: CtlT.Any): IApplicationEvents2; VAR new: IApplicationEvents2; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209FE-0001-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisIApplicationEvents2; PROCEDURE IsIApplicationEvents2* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209FE-0001-0000-C000-000000000046}") END IsIApplicationEvents2; PROCEDURE ThisEmailAuthor* (v: CtlT.Any): EmailAuthor; VAR new: EmailAuthor; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209D7-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEmailAuthor; PROCEDURE IsEmailAuthor* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209D7-0000-0000-C000-000000000046}") END IsEmailAuthor; PROCEDURE ThisEmailOptions* (v: CtlT.Any): EmailOptions; VAR new: EmailOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209DB-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEmailOptions; PROCEDURE IsEmailOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209DB-0000-0000-C000-000000000046}") END IsEmailOptions; PROCEDURE ThisEmailSignature* (v: CtlT.Any): EmailSignature; VAR new: EmailSignature; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209DC-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEmailSignature; PROCEDURE IsEmailSignature* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209DC-0000-0000-C000-000000000046}") END IsEmailSignature; PROCEDURE ThisEmail* (v: CtlT.Any): Email; VAR new: Email; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209DD-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisEmail; PROCEDURE IsEmail* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209DD-0000-0000-C000-000000000046}") END IsEmail; PROCEDURE ThisHorizontalLineFormat* (v: CtlT.Any): HorizontalLineFormat; VAR new: HorizontalLineFormat; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209DE-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisHorizontalLineFormat; PROCEDURE IsHorizontalLineFormat* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209DE-0000-0000-C000-000000000046}") END IsHorizontalLineFormat; PROCEDURE ThisFrameset* (v: CtlT.Any): Frameset; VAR new: Frameset; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209E2-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisFrameset; PROCEDURE IsFrameset* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209E2-0000-0000-C000-000000000046}") END IsFrameset; PROCEDURE ThisDefaultWebOptions* (v: CtlT.Any): DefaultWebOptions; VAR new: DefaultWebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209E3-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisDefaultWebOptions; PROCEDURE IsDefaultWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209E3-0000-0000-C000-000000000046}") END IsDefaultWebOptions; PROCEDURE ThisWebOptions* (v: CtlT.Any): WebOptions; VAR new: WebOptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209E4-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisWebOptions; PROCEDURE IsWebOptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209E4-0000-0000-C000-000000000046}") END IsWebOptions; PROCEDURE ThisOtherCorrectionsExceptions* (v: CtlT.Any): OtherCorrectionsExceptions; VAR new: OtherCorrectionsExceptions; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209DF-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOtherCorrectionsExceptions; PROCEDURE IsOtherCorrectionsExceptions* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209DF-0000-0000-C000-000000000046}") END IsOtherCorrectionsExceptions; PROCEDURE ThisOtherCorrectionsException* (v: CtlT.Any): OtherCorrectionsException; VAR new: OtherCorrectionsException; BEGIN IF v # NIL THEN NEW(new); CtlC.InitObj(new, v, "{000209E1-0000-0000-C000-000000000046}"); RETURN new ELSE RETURN NIL END END ThisOtherCorrectionsException; PROCEDURE IsOtherCorrectionsException* (v: CtlT.Any): BOOLEAN; BEGIN RETURN CtlC.IsObj(v, "{000209E1-0000-0000-C000-000000000046}") END IsOtherCorrectionsException; (* ---------- _Application, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Application) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: _Application) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _Application) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _Application) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _Application) Documents* (): Documents, NEW; BEGIN RETURN ThisDocuments(CtlC.GetAny(this, 6)) END Documents; PROCEDURE (this: _Application) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 2)) END Windows; PROCEDURE (this: _Application) ActiveDocument* (): Document, NEW; BEGIN RETURN This_Document(CtlC.GetAny(this, 3)) END ActiveDocument; PROCEDURE (this: _Application) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 4)) END ActiveWindow; PROCEDURE (this: _Application) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 5)) END Selection; PROCEDURE (this: _Application) WordBasic* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END WordBasic; PROCEDURE (this: _Application) RecentFiles* (): RecentFiles, NEW; BEGIN RETURN ThisRecentFiles(CtlC.GetAny(this, 7)) END RecentFiles; PROCEDURE (this: _Application) NormalTemplate* (): Template, NEW; BEGIN RETURN ThisTemplate(CtlC.GetAny(this, 8)) END NormalTemplate; PROCEDURE (this: _Application) System* (): System, NEW; BEGIN RETURN ThisSystem(CtlC.GetAny(this, 9)) END System; PROCEDURE (this: _Application) AutoCorrect* (): AutoCorrect, NEW; BEGIN RETURN ThisAutoCorrect(CtlC.GetAny(this, 10)) END AutoCorrect; PROCEDURE (this: _Application) FontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 11)) END FontNames; PROCEDURE (this: _Application) LandscapeFontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 12)) END LandscapeFontNames; PROCEDURE (this: _Application) PortraitFontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 13)) END PortraitFontNames; PROCEDURE (this: _Application) Languages* (): Languages, NEW; BEGIN RETURN ThisLanguages(CtlC.GetAny(this, 14)) END Languages; PROCEDURE (this: _Application) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 15)) END Assistant; PROCEDURE (this: _Application) Browser* (): Browser, NEW; BEGIN RETURN ThisBrowser(CtlC.GetAny(this, 16)) END Browser; PROCEDURE (this: _Application) FileConverters* (): FileConverters, NEW; BEGIN RETURN ThisFileConverters(CtlC.GetAny(this, 17)) END FileConverters; PROCEDURE (this: _Application) MailingLabel* (): MailingLabel, NEW; BEGIN RETURN ThisMailingLabel(CtlC.GetAny(this, 18)) END MailingLabel; PROCEDURE (this: _Application) Dialogs* (): Dialogs, NEW; BEGIN RETURN ThisDialogs(CtlC.GetAny(this, 19)) END Dialogs; PROCEDURE (this: _Application) CaptionLabels* (): CaptionLabels, NEW; BEGIN RETURN ThisCaptionLabels(CtlC.GetAny(this, 20)) END CaptionLabels; PROCEDURE (this: _Application) AutoCaptions* (): AutoCaptions, NEW; BEGIN RETURN ThisAutoCaptions(CtlC.GetAny(this, 21)) END AutoCaptions; PROCEDURE (this: _Application) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 22)) END AddIns; PROCEDURE (this: _Application) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 23) END Visible; PROCEDURE (this: _Application) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 23, p1) END PUTVisible; PROCEDURE (this: _Application) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 24) END Version; PROCEDURE (this: _Application) ScreenUpdating* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 26) END ScreenUpdating; PROCEDURE (this: _Application) PUTScreenUpdating* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 26, p1) END PUTScreenUpdating; PROCEDURE (this: _Application) PrintPreview* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 27) END PrintPreview; PROCEDURE (this: _Application) PUTPrintPreview* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 27, p1) END PUTPrintPreview; PROCEDURE (this: _Application) Tasks* (): Tasks, NEW; BEGIN RETURN ThisTasks(CtlC.GetAny(this, 28)) END Tasks; PROCEDURE (this: _Application) DisplayStatusBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 29) END DisplayStatusBar; PROCEDURE (this: _Application) PUTDisplayStatusBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 29, p1) END PUTDisplayStatusBar; PROCEDURE (this: _Application) SpecialMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 30) END SpecialMode; PROCEDURE (this: _Application) UsableWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 33) END UsableWidth; PROCEDURE (this: _Application) UsableHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34) END UsableHeight; PROCEDURE (this: _Application) MathCoprocessorAvailable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END MathCoprocessorAvailable; PROCEDURE (this: _Application) MouseAvailable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 37) END MouseAvailable; PROCEDURE (this: _Application) International* (Index: WdInternationalIndex): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 46, arg, ret); RETURN CtlC.VarAny(ret) END International; PROCEDURE (this: _Application) Build* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 47) END Build; PROCEDURE (this: _Application) CapsLock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 48) END CapsLock; PROCEDURE (this: _Application) NumLock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 49) END NumLock; PROCEDURE (this: _Application) UserName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 52) END UserName; PROCEDURE (this: _Application) PUTUserName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 52, p1) END PUTUserName; PROCEDURE (this: _Application) UserInitials* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 53) END UserInitials; PROCEDURE (this: _Application) PUTUserInitials* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 53, p1) END PUTUserInitials; PROCEDURE (this: _Application) UserAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 54) END UserAddress; PROCEDURE (this: _Application) PUTUserAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 54, p1) END PUTUserAddress; PROCEDURE (this: _Application) MacroContainer* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 55) END MacroContainer; PROCEDURE (this: _Application) DisplayRecentFiles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 56) END DisplayRecentFiles; PROCEDURE (this: _Application) PUTDisplayRecentFiles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 56, p1) END PUTDisplayRecentFiles; PROCEDURE (this: _Application) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 57)) END CommandBars; PROCEDURE (this: _Application) SynonymInfo* (Word: ARRAY OF CHAR; (* optional *) LanguageID: CtlT.Any): SynonymInfo, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallGetMethod(this, 59, arg, ret); RETURN ThisSynonymInfo(CtlC.VarAny(ret)) END SynonymInfo; PROCEDURE (this: _Application) VBE* (): CtlVBIDE.VBE, NEW; BEGIN RETURN CtlVBIDE.ThisVBE(CtlC.GetAny(this, 61)) END VBE; PROCEDURE (this: _Application) DefaultSaveFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 64) END DefaultSaveFormat; PROCEDURE (this: _Application) PUTDefaultSaveFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 64, p1) END PUTDefaultSaveFormat; PROCEDURE (this: _Application) ListGalleries* (): ListGalleries, NEW; BEGIN RETURN ThisListGalleries(CtlC.GetAny(this, 65)) END ListGalleries; PROCEDURE (this: _Application) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END ActivePrinter; PROCEDURE (this: _Application) PUTActivePrinter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 66, p1) END PUTActivePrinter; PROCEDURE (this: _Application) Templates* (): Templates, NEW; BEGIN RETURN ThisTemplates(CtlC.GetAny(this, 67)) END Templates; PROCEDURE (this: _Application) CustomizationContext* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 68) END CustomizationContext; PROCEDURE (this: _Application) PUTCustomizationContext* (p1: CtlT.Object), NEW; BEGIN CtlC.PutObj(this, 68, p1) END PUTCustomizationContext; PROCEDURE (this: _Application) KeyBindings* (): KeyBindings, NEW; BEGIN RETURN ThisKeyBindings(CtlC.GetAny(this, 69)) END KeyBindings; PROCEDURE (this: _Application) KeysBoundTo* (KeyCategory: WdKeyCategory; Command: ARRAY OF CHAR; (* optional *) CommandParameter: CtlT.Any): KeysBoundTo, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCategory, arg[2]); CtlC.StrVar(Command, arg[1]); CtlC.AnyVar(CommandParameter, arg[0]); CtlC.CallGetMethod(this, 70, arg, ret); RETURN ThisKeysBoundTo(CtlC.VarAny(ret)) END KeysBoundTo; PROCEDURE (this: _Application) FindKey* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): KeyBinding, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallGetMethod(this, 71, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END FindKey; PROCEDURE (this: _Application) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 80) END Caption; PROCEDURE (this: _Application) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 80, p1) END PUTCaption; PROCEDURE (this: _Application) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 81) END Path; PROCEDURE (this: _Application) DisplayScrollBars* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 82) END DisplayScrollBars; PROCEDURE (this: _Application) PUTDisplayScrollBars* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 82, p1) END PUTDisplayScrollBars; PROCEDURE (this: _Application) StartupPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 83) END StartupPath; PROCEDURE (this: _Application) PUTStartupPath* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 83, p1) END PUTStartupPath; PROCEDURE (this: _Application) BackgroundSavingStatus* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 85) END BackgroundSavingStatus; PROCEDURE (this: _Application) BackgroundPrintingStatus* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 86) END BackgroundPrintingStatus; PROCEDURE (this: _Application) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 87) END Left; PROCEDURE (this: _Application) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 87, p1) END PUTLeft; PROCEDURE (this: _Application) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 88) END Top; PROCEDURE (this: _Application) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 88, p1) END PUTTop; PROCEDURE (this: _Application) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 89) END Width; PROCEDURE (this: _Application) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 89, p1) END PUTWidth; PROCEDURE (this: _Application) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 90) END Height; PROCEDURE (this: _Application) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 90, p1) END PUTHeight; PROCEDURE (this: _Application) WindowState* (): WdWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 91) END WindowState; PROCEDURE (this: _Application) PUTWindowState* (p1: WdWindowState), NEW; BEGIN CtlC.PutInt(this, 91, p1) END PUTWindowState; PROCEDURE (this: _Application) DisplayAutoCompleteTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 92) END DisplayAutoCompleteTips; PROCEDURE (this: _Application) PUTDisplayAutoCompleteTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 92, p1) END PUTDisplayAutoCompleteTips; PROCEDURE (this: _Application) Options* (): Options, NEW; BEGIN RETURN ThisOptions(CtlC.GetAny(this, 93)) END Options; PROCEDURE (this: _Application) DisplayAlerts* (): WdAlertLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 94) END DisplayAlerts; PROCEDURE (this: _Application) PUTDisplayAlerts* (p1: WdAlertLevel), NEW; BEGIN CtlC.PutInt(this, 94, p1) END PUTDisplayAlerts; PROCEDURE (this: _Application) CustomDictionaries* (): Dictionaries, NEW; BEGIN RETURN ThisDictionaries(CtlC.GetAny(this, 95)) END CustomDictionaries; PROCEDURE (this: _Application) PathSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 96) END PathSeparator; PROCEDURE (this: _Application) PUTStatusBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 97, p1) END PUTStatusBar; PROCEDURE (this: _Application) MAPIAvailable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 98) END MAPIAvailable; PROCEDURE (this: _Application) DisplayScreenTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 99) END DisplayScreenTips; PROCEDURE (this: _Application) PUTDisplayScreenTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 99, p1) END PUTDisplayScreenTips; PROCEDURE (this: _Application) EnableCancelKey* (): WdEnableCancelKey, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EnableCancelKey; PROCEDURE (this: _Application) PUTEnableCancelKey* (p1: WdEnableCancelKey), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTEnableCancelKey; PROCEDURE (this: _Application) UserControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 101) END UserControl; PROCEDURE (this: _Application) FileSearch* (): CtlOffice.FileSearch, NEW; BEGIN RETURN CtlOffice.ThisFileSearch(CtlC.GetAny(this, 103)) END FileSearch; PROCEDURE (this: _Application) MailSystem* (): WdMailSystem, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END MailSystem; PROCEDURE (this: _Application) DefaultTableSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 105) END DefaultTableSeparator; PROCEDURE (this: _Application) PUTDefaultTableSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 105, p1) END PUTDefaultTableSeparator; PROCEDURE (this: _Application) ShowVisualBasicEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 106) END ShowVisualBasicEditor; PROCEDURE (this: _Application) PUTShowVisualBasicEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 106, p1) END PUTShowVisualBasicEditor; PROCEDURE (this: _Application) BrowseExtraFileTypes* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END BrowseExtraFileTypes; PROCEDURE (this: _Application) PUTBrowseExtraFileTypes* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTBrowseExtraFileTypes; PROCEDURE (this: _Application) IsObjectValid* (Object: CtlT.Object): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallGetMethod(this, 109, arg, ret); RETURN CtlC.VarBool(ret) END IsObjectValid; PROCEDURE (this: _Application) HangulHanjaDictionaries* (): HangulHanjaConversionDictionaries, NEW; BEGIN RETURN ThisHangulHanjaConversionDictionaries(CtlC.GetAny(this, 110)) END HangulHanjaDictionaries; PROCEDURE (this: _Application) MailMessage* (): MailMessage, NEW; BEGIN RETURN ThisMailMessage(CtlC.GetAny(this, 348)) END MailMessage; PROCEDURE (this: _Application) FocusInMailHeader* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 386) END FocusInMailHeader; PROCEDURE (this: _Application) Quit* ((* optional *) SaveChanges: CtlT.Any; OriginalFormat: CtlT.Any; RouteDocument: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[2]); CtlC.AnyVar(OriginalFormat, arg[1]); CtlC.AnyVar(RouteDocument, arg[0]); CtlC.CallParMethod(this, 1105, arg, NIL); END Quit; PROCEDURE (this: _Application) ScreenRefresh* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END ScreenRefresh; PROCEDURE (this: _Application) PrintOutOld* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; FileName: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any), NEW; VAR arg: ARRAY 15 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[14]); CtlC.AnyVar(Append, arg[13]); CtlC.AnyVar(Range, arg[12]); CtlC.AnyVar(OutputFileName, arg[11]); CtlC.AnyVar(From, arg[10]); CtlC.AnyVar(To, arg[9]); CtlC.AnyVar(Item, arg[8]); CtlC.AnyVar(Copies, arg[7]); CtlC.AnyVar(Pages, arg[6]); CtlC.AnyVar(PageType, arg[5]); CtlC.AnyVar(PrintToFile, arg[4]); CtlC.AnyVar(Collate, arg[3]); CtlC.AnyVar(FileName, arg[2]); CtlC.AnyVar(ActivePrinterMacGX, arg[1]); CtlC.AnyVar(ManualDuplexPrint, arg[0]); CtlC.CallParMethod(this, 302, arg, NIL); END PrintOutOld; PROCEDURE (this: _Application) LookupNameProperties* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 303, arg, NIL); END LookupNameProperties; PROCEDURE (this: _Application) SubstituteFont* (UnavailableFont: ARRAY OF CHAR; SubstituteFont: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(UnavailableFont, arg[1]); CtlC.StrVar(SubstituteFont, arg[0]); CtlC.CallParMethod(this, 304, arg, NIL); END SubstituteFont; PROCEDURE (this: _Application) Repeat* ((* optional *) Times: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Times, arg[0]); CtlC.CallParMethod(this, 305, arg, ret); RETURN CtlC.VarBool(ret) END Repeat; PROCEDURE (this: _Application) DDEExecute* (Channel: INTEGER; Command: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Command, arg[0]); CtlC.CallParMethod(this, 310, arg, NIL); END DDEExecute; PROCEDURE (this: _Application) DDEInitiate* (App: ARRAY OF CHAR; Topic: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(App, arg[1]); CtlC.StrVar(Topic, arg[0]); CtlC.CallParMethod(this, 311, arg, ret); RETURN CtlC.VarInt(ret) END DDEInitiate; PROCEDURE (this: _Application) DDEPoke* (Channel: INTEGER; Item: ARRAY OF CHAR; Data: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[2]); CtlC.StrVar(Item, arg[1]); CtlC.StrVar(Data, arg[0]); CtlC.CallParMethod(this, 312, arg, NIL); END DDEPoke; PROCEDURE (this: _Application) DDERequest* (Channel: INTEGER; Item: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Item, arg[0]); CtlC.CallParMethod(this, 313, arg, ret); RETURN CtlC.VarStr(ret) END DDERequest; PROCEDURE (this: _Application) DDETerminate* (Channel: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[0]); CtlC.CallParMethod(this, 314, arg, NIL); END DDETerminate; PROCEDURE (this: _Application) DDETerminateAll* (), NEW; BEGIN CtlC.CallMethod(this, 315, NIL); END DDETerminateAll; PROCEDURE (this: _Application) BuildKeyCode* (Arg1: WdKey; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 316, arg, ret); RETURN CtlC.VarInt(ret) END BuildKeyCode; PROCEDURE (this: _Application) KeyString* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallParMethod(this, 317, arg, ret); RETURN CtlC.VarStr(ret) END KeyString; PROCEDURE (this: _Application) OrganizerCopy* (Source: ARRAY OF CHAR; Destination: ARRAY OF CHAR; Name: ARRAY OF CHAR; Object: WdOrganizerObject), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Source, arg[3]); CtlC.StrVar(Destination, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.IntVar(Object, arg[0]); CtlC.CallParMethod(this, 318, arg, NIL); END OrganizerCopy; PROCEDURE (this: _Application) OrganizerDelete* (Source: ARRAY OF CHAR; Name: ARRAY OF CHAR; Object: WdOrganizerObject), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Source, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.IntVar(Object, arg[0]); CtlC.CallParMethod(this, 319, arg, NIL); END OrganizerDelete; PROCEDURE (this: _Application) OrganizerRename* (Source: ARRAY OF CHAR; Name: ARRAY OF CHAR; NewName: ARRAY OF CHAR; Object: WdOrganizerObject), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Source, arg[3]); CtlC.StrVar(Name, arg[2]); CtlC.StrVar(NewName, arg[1]); CtlC.IntVar(Object, arg[0]); CtlC.CallParMethod(this, 320, arg, NIL); END OrganizerRename; PROCEDURE (this: _Application) AddAddress* (TagID: CtlT.Any; Value: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(TagID, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 321, arg, NIL); END AddAddress; PROCEDURE (this: _Application) GetAddress* ((* optional *) Name: CtlT.Any; AddressProperties: CtlT.Any; UseAutoText: CtlT.Any; DisplaySelectDialog: CtlT.Any; SelectDialog: CtlT.Any; CheckNamesDialog: CtlT.Any; RecentAddressesChoice: CtlT.Any; UpdateRecentAddresses: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[7]); CtlC.AnyVar(AddressProperties, arg[6]); CtlC.AnyVar(UseAutoText, arg[5]); CtlC.AnyVar(DisplaySelectDialog, arg[4]); CtlC.AnyVar(SelectDialog, arg[3]); CtlC.AnyVar(CheckNamesDialog, arg[2]); CtlC.AnyVar(RecentAddressesChoice, arg[1]); CtlC.AnyVar(UpdateRecentAddresses, arg[0]); CtlC.CallParMethod(this, 322, arg, ret); RETURN CtlC.VarStr(ret) END GetAddress; PROCEDURE (this: _Application) CheckGrammar* (String: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 323, arg, ret); RETURN CtlC.VarBool(ret) END CheckGrammar; PROCEDURE (this: _Application) CheckSpelling* (Word: ARRAY OF CHAR; (* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; MainDictionary: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[12]); CtlC.AnyVar(CustomDictionary, arg[11]); CtlC.AnyVar(IgnoreUppercase, arg[10]); CtlC.AnyVar(MainDictionary, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 324, arg, ret); RETURN CtlC.VarBool(ret) END CheckSpelling; PROCEDURE (this: _Application) ResetIgnoreAll* (), NEW; BEGIN CtlC.CallMethod(this, 326, NIL); END ResetIgnoreAll; PROCEDURE (this: _Application) GetSpellingSuggestions* (Word: ARRAY OF CHAR; (* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; MainDictionary: CtlT.Any; SuggestionMode: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any): SpellingSuggestions, NEW; VAR arg: ARRAY 14 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[13]); CtlC.AnyVar(CustomDictionary, arg[12]); CtlC.AnyVar(IgnoreUppercase, arg[11]); CtlC.AnyVar(MainDictionary, arg[10]); CtlC.AnyVar(SuggestionMode, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 327, arg, ret); RETURN ThisSpellingSuggestions(CtlC.VarAny(ret)) END GetSpellingSuggestions; PROCEDURE (this: _Application) GoBack* (), NEW; BEGIN CtlC.CallMethod(this, 328, NIL); END GoBack; PROCEDURE (this: _Application) Help* (HelpType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(HelpType, arg[0]); CtlC.CallParMethod(this, 329, arg, NIL); END Help; PROCEDURE (this: _Application) AutomaticChange* (), NEW; BEGIN CtlC.CallMethod(this, 330, NIL); END AutomaticChange; PROCEDURE (this: _Application) ShowMe* (), NEW; BEGIN CtlC.CallMethod(this, 331, NIL); END ShowMe; PROCEDURE (this: _Application) HelpTool* (), NEW; BEGIN CtlC.CallMethod(this, 332, NIL); END HelpTool; PROCEDURE (this: _Application) NewWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 345, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: _Application) ListCommands* (ListAllCommands: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(ListAllCommands, arg[0]); CtlC.CallParMethod(this, 346, arg, NIL); END ListCommands; PROCEDURE (this: _Application) ShowClipboard* (), NEW; BEGIN CtlC.CallMethod(this, 349, NIL); END ShowClipboard; PROCEDURE (this: _Application) OnTime* (When: CtlT.Any; Name: ARRAY OF CHAR; (* optional *) Tolerance: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(When, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Tolerance, arg[0]); CtlC.CallParMethod(this, 350, arg, NIL); END OnTime; PROCEDURE (this: _Application) NextLetter* (), NEW; BEGIN CtlC.CallMethod(this, 351, NIL); END NextLetter; PROCEDURE (this: _Application) MountVolume* (Zone: ARRAY OF CHAR; Server: ARRAY OF CHAR; Volume: ARRAY OF CHAR; (* optional *) User: CtlT.Any; UserPassword: CtlT.Any; VolumePassword: CtlT.Any): SHORTINT, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Zone, arg[5]); CtlC.StrVar(Server, arg[4]); CtlC.StrVar(Volume, arg[3]); CtlC.AnyVar(User, arg[2]); CtlC.AnyVar(UserPassword, arg[1]); CtlC.AnyVar(VolumePassword, arg[0]); CtlC.CallParMethod(this, 353, arg, ret); RETURN CtlC.VarSInt(ret) END MountVolume; PROCEDURE (this: _Application) CleanString* (String: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 354, arg, ret); RETURN CtlC.VarStr(ret) END CleanString; PROCEDURE (this: _Application) SendFax* (), NEW; BEGIN CtlC.CallMethod(this, 356, NIL); END SendFax; PROCEDURE (this: _Application) ChangeFileOpenDirectory* (Path: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[0]); CtlC.CallParMethod(this, 357, arg, NIL); END ChangeFileOpenDirectory; PROCEDURE (this: _Application) RunOld* (MacroName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(MacroName, arg[0]); CtlC.CallParMethod(this, 358, arg, NIL); END RunOld; PROCEDURE (this: _Application) GoForward* (), NEW; BEGIN CtlC.CallMethod(this, 359, NIL); END GoForward; PROCEDURE (this: _Application) Move* (Left: INTEGER; Top: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[1]); CtlC.IntVar(Top, arg[0]); CtlC.CallParMethod(this, 360, arg, NIL); END Move; PROCEDURE (this: _Application) Resize* (Width: INTEGER; Height: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 361, arg, NIL); END Resize; PROCEDURE (this: _Application) InchesToPoints* (Inches: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Inches, arg[0]); CtlC.CallParMethod(this, 370, arg, ret); RETURN CtlC.VarSReal(ret) END InchesToPoints; PROCEDURE (this: _Application) CentimetersToPoints* (Centimeters: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Centimeters, arg[0]); CtlC.CallParMethod(this, 371, arg, ret); RETURN CtlC.VarSReal(ret) END CentimetersToPoints; PROCEDURE (this: _Application) MillimetersToPoints* (Millimeters: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Millimeters, arg[0]); CtlC.CallParMethod(this, 372, arg, ret); RETURN CtlC.VarSReal(ret) END MillimetersToPoints; PROCEDURE (this: _Application) PicasToPoints* (Picas: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Picas, arg[0]); CtlC.CallParMethod(this, 373, arg, ret); RETURN CtlC.VarSReal(ret) END PicasToPoints; PROCEDURE (this: _Application) LinesToPoints* (Lines: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Lines, arg[0]); CtlC.CallParMethod(this, 374, arg, ret); RETURN CtlC.VarSReal(ret) END LinesToPoints; PROCEDURE (this: _Application) PointsToInches* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 380, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToInches; PROCEDURE (this: _Application) PointsToCentimeters* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 381, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToCentimeters; PROCEDURE (this: _Application) PointsToMillimeters* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 382, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToMillimeters; PROCEDURE (this: _Application) PointsToPicas* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 383, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToPicas; PROCEDURE (this: _Application) PointsToLines* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 384, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToLines; PROCEDURE (this: _Application) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 385, NIL); END Activate; PROCEDURE (this: _Application) PointsToPixels* (Points: SHORTREAL; (* optional *) fVertical: CtlT.Any): SHORTREAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[1]); CtlC.AnyVar(fVertical, arg[0]); CtlC.CallParMethod(this, 387, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToPixels; PROCEDURE (this: _Application) PixelsToPoints* (Pixels: SHORTREAL; (* optional *) fVertical: CtlT.Any): SHORTREAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Pixels, arg[1]); CtlC.AnyVar(fVertical, arg[0]); CtlC.CallParMethod(this, 388, arg, ret); RETURN CtlC.VarSReal(ret) END PixelsToPoints; PROCEDURE (this: _Application) KeyboardLatin* (), NEW; BEGIN CtlC.CallMethod(this, 400, NIL); END KeyboardLatin; PROCEDURE (this: _Application) KeyboardBidi* (), NEW; BEGIN CtlC.CallMethod(this, 401, NIL); END KeyboardBidi; PROCEDURE (this: _Application) ToggleKeyboard* (), NEW; BEGIN CtlC.CallMethod(this, 402, NIL); END ToggleKeyboard; PROCEDURE (this: _Application) Keyboard* (LangId: INTEGER): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(LangId, arg[0]); CtlC.CallParMethod(this, 446, arg, ret); RETURN CtlC.VarInt(ret) END Keyboard; PROCEDURE (this: _Application) ProductCode* (): CtlT.Strg, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 404, ret); RETURN CtlC.VarStr(ret) END ProductCode; PROCEDURE (this: _Application) DefaultWebOptions* (): DefaultWebOptions, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 405, ret); RETURN ThisDefaultWebOptions(CtlC.VarAny(ret)) END DefaultWebOptions; PROCEDURE (this: _Application) DiscussionSupport* (Range: CtlT.Any; cid: CtlT.Any; piCSE: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[2]); CtlC.AnyVar(cid, arg[1]); CtlC.AnyVar(piCSE, arg[0]); CtlC.CallParMethod(this, 407, arg, NIL); END DiscussionSupport; PROCEDURE (this: _Application) SetDefaultTheme* (Name: ARRAY OF CHAR; DocumentType: WdDocumentMedium), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.IntVar(DocumentType, arg[0]); CtlC.CallParMethod(this, 414, arg, NIL); END SetDefaultTheme; PROCEDURE (this: _Application) GetDefaultTheme* (DocumentType: WdDocumentMedium): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(DocumentType, arg[0]); CtlC.CallParMethod(this, 416, arg, ret); RETURN CtlC.VarStr(ret) END GetDefaultTheme; PROCEDURE (this: _Application) EmailOptions* (): EmailOptions, NEW; BEGIN RETURN ThisEmailOptions(CtlC.GetAny(this, 389)) END EmailOptions; PROCEDURE (this: _Application) Language* (): CtlOffice.MsoLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 391) END Language; PROCEDURE (this: _Application) COMAddIns* (): CtlOffice.COMAddIns, NEW; BEGIN RETURN CtlOffice.ThisCOMAddIns(CtlC.GetAny(this, 111)) END COMAddIns; PROCEDURE (this: _Application) CheckLanguage* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 112) END CheckLanguage; PROCEDURE (this: _Application) PUTCheckLanguage* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 112, p1) END PUTCheckLanguage; PROCEDURE (this: _Application) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 403)) END LanguageSettings; PROCEDURE (this: _Application) Dummy1* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 406) END Dummy1; PROCEDURE (this: _Application) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 409)) END AnswerWizard; PROCEDURE (this: _Application) FeatureInstall* (): CtlOffice.MsoFeatureInstall, NEW; BEGIN RETURN CtlC.GetInt(this, 447) END FeatureInstall; PROCEDURE (this: _Application) PUTFeatureInstall* (p1: CtlOffice.MsoFeatureInstall), NEW; BEGIN CtlC.PutInt(this, 447, p1) END PUTFeatureInstall; PROCEDURE (this: _Application) PrintOut* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; FileName: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any; PrintZoomColumn: CtlT.Any; PrintZoomRow: CtlT.Any; PrintZoomPaperWidth: CtlT.Any; PrintZoomPaperHeight: CtlT.Any), NEW; VAR arg: ARRAY 19 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[18]); CtlC.AnyVar(Append, arg[17]); CtlC.AnyVar(Range, arg[16]); CtlC.AnyVar(OutputFileName, arg[15]); CtlC.AnyVar(From, arg[14]); CtlC.AnyVar(To, arg[13]); CtlC.AnyVar(Item, arg[12]); CtlC.AnyVar(Copies, arg[11]); CtlC.AnyVar(Pages, arg[10]); CtlC.AnyVar(PageType, arg[9]); CtlC.AnyVar(PrintToFile, arg[8]); CtlC.AnyVar(Collate, arg[7]); CtlC.AnyVar(FileName, arg[6]); CtlC.AnyVar(ActivePrinterMacGX, arg[5]); CtlC.AnyVar(ManualDuplexPrint, arg[4]); CtlC.AnyVar(PrintZoomColumn, arg[3]); CtlC.AnyVar(PrintZoomRow, arg[2]); CtlC.AnyVar(PrintZoomPaperWidth, arg[1]); CtlC.AnyVar(PrintZoomPaperHeight, arg[0]); CtlC.CallParMethod(this, 444, arg, NIL); END PrintOut; PROCEDURE (this: _Application) Run* (MacroName: ARRAY OF CHAR; (* optional *) varg1: CtlT.Any; varg2: CtlT.Any; varg3: CtlT.Any; varg4: CtlT.Any; varg5: CtlT.Any; varg6: CtlT.Any; varg7: CtlT.Any; varg8: CtlT.Any; varg9: CtlT.Any; varg10: CtlT.Any; varg11: CtlT.Any; varg12: CtlT.Any; varg13: CtlT.Any; varg14: CtlT.Any; varg15: CtlT.Any; varg16: CtlT.Any; varg17: CtlT.Any; varg18: CtlT.Any; varg19: CtlT.Any; varg20: CtlT.Any; varg21: CtlT.Any; varg22: CtlT.Any; varg23: CtlT.Any; varg24: CtlT.Any; varg25: CtlT.Any; varg26: CtlT.Any; varg27: CtlT.Any; varg28: CtlT.Any; varg29: CtlT.Any; varg30: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(MacroName, arg[30]); CtlC.AnyVar(varg1, arg[29]); CtlC.AnyVar(varg2, arg[28]); CtlC.AnyVar(varg3, arg[27]); CtlC.AnyVar(varg4, arg[26]); CtlC.AnyVar(varg5, arg[25]); CtlC.AnyVar(varg6, arg[24]); CtlC.AnyVar(varg7, arg[23]); CtlC.AnyVar(varg8, arg[22]); CtlC.AnyVar(varg9, arg[21]); CtlC.AnyVar(varg10, arg[20]); CtlC.AnyVar(varg11, arg[19]); CtlC.AnyVar(varg12, arg[18]); CtlC.AnyVar(varg13, arg[17]); CtlC.AnyVar(varg14, arg[16]); CtlC.AnyVar(varg15, arg[15]); CtlC.AnyVar(varg16, arg[14]); CtlC.AnyVar(varg17, arg[13]); CtlC.AnyVar(varg18, arg[12]); CtlC.AnyVar(varg19, arg[11]); CtlC.AnyVar(varg20, arg[10]); CtlC.AnyVar(varg21, arg[9]); CtlC.AnyVar(varg22, arg[8]); CtlC.AnyVar(varg23, arg[7]); CtlC.AnyVar(varg24, arg[6]); CtlC.AnyVar(varg25, arg[5]); CtlC.AnyVar(varg26, arg[4]); CtlC.AnyVar(varg27, arg[3]); CtlC.AnyVar(varg28, arg[2]); CtlC.AnyVar(varg29, arg[1]); CtlC.AnyVar(varg30, arg[0]); CtlC.CallParMethod(this, 445, arg, ret); RETURN CtlC.VarAny(ret) END Run; (* ---------- _Global, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Global) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: _Global) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _Global) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _Global) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _Global) Documents* (): Documents, NEW; BEGIN RETURN ThisDocuments(CtlC.GetAny(this, 1)) END Documents; PROCEDURE (this: _Global) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 2)) END Windows; PROCEDURE (this: _Global) ActiveDocument* (): Document, NEW; BEGIN RETURN This_Document(CtlC.GetAny(this, 3)) END ActiveDocument; PROCEDURE (this: _Global) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 4)) END ActiveWindow; PROCEDURE (this: _Global) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 5)) END Selection; PROCEDURE (this: _Global) WordBasic* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 6) END WordBasic; PROCEDURE (this: _Global) PrintPreview* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 27) END PrintPreview; PROCEDURE (this: _Global) PUTPrintPreview* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 27, p1) END PUTPrintPreview; PROCEDURE (this: _Global) RecentFiles* (): RecentFiles, NEW; BEGIN RETURN ThisRecentFiles(CtlC.GetAny(this, 7)) END RecentFiles; PROCEDURE (this: _Global) NormalTemplate* (): Template, NEW; BEGIN RETURN ThisTemplate(CtlC.GetAny(this, 8)) END NormalTemplate; PROCEDURE (this: _Global) System* (): System, NEW; BEGIN RETURN ThisSystem(CtlC.GetAny(this, 9)) END System; PROCEDURE (this: _Global) AutoCorrect* (): AutoCorrect, NEW; BEGIN RETURN ThisAutoCorrect(CtlC.GetAny(this, 10)) END AutoCorrect; PROCEDURE (this: _Global) FontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 11)) END FontNames; PROCEDURE (this: _Global) LandscapeFontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 12)) END LandscapeFontNames; PROCEDURE (this: _Global) PortraitFontNames* (): FontNames, NEW; BEGIN RETURN ThisFontNames(CtlC.GetAny(this, 13)) END PortraitFontNames; PROCEDURE (this: _Global) Languages* (): Languages, NEW; BEGIN RETURN ThisLanguages(CtlC.GetAny(this, 14)) END Languages; PROCEDURE (this: _Global) Assistant* (): CtlOffice.Assistant, NEW; BEGIN RETURN CtlOffice.ThisAssistant(CtlC.GetAny(this, 15)) END Assistant; PROCEDURE (this: _Global) FileConverters* (): FileConverters, NEW; BEGIN RETURN ThisFileConverters(CtlC.GetAny(this, 17)) END FileConverters; PROCEDURE (this: _Global) Dialogs* (): Dialogs, NEW; BEGIN RETURN ThisDialogs(CtlC.GetAny(this, 19)) END Dialogs; PROCEDURE (this: _Global) CaptionLabels* (): CaptionLabels, NEW; BEGIN RETURN ThisCaptionLabels(CtlC.GetAny(this, 20)) END CaptionLabels; PROCEDURE (this: _Global) AutoCaptions* (): AutoCaptions, NEW; BEGIN RETURN ThisAutoCaptions(CtlC.GetAny(this, 21)) END AutoCaptions; PROCEDURE (this: _Global) AddIns* (): AddIns, NEW; BEGIN RETURN ThisAddIns(CtlC.GetAny(this, 22)) END AddIns; PROCEDURE (this: _Global) Tasks* (): Tasks, NEW; BEGIN RETURN ThisTasks(CtlC.GetAny(this, 28)) END Tasks; PROCEDURE (this: _Global) MacroContainer* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 55) END MacroContainer; PROCEDURE (this: _Global) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 57)) END CommandBars; PROCEDURE (this: _Global) SynonymInfo* (Word: ARRAY OF CHAR; (* optional *) LanguageID: CtlT.Any): SynonymInfo, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallGetMethod(this, 59, arg, ret); RETURN ThisSynonymInfo(CtlC.VarAny(ret)) END SynonymInfo; PROCEDURE (this: _Global) VBE* (): CtlVBIDE.VBE, NEW; BEGIN RETURN CtlVBIDE.ThisVBE(CtlC.GetAny(this, 61)) END VBE; PROCEDURE (this: _Global) ListGalleries* (): ListGalleries, NEW; BEGIN RETURN ThisListGalleries(CtlC.GetAny(this, 65)) END ListGalleries; PROCEDURE (this: _Global) ActivePrinter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 66) END ActivePrinter; PROCEDURE (this: _Global) PUTActivePrinter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 66, p1) END PUTActivePrinter; PROCEDURE (this: _Global) Templates* (): Templates, NEW; BEGIN RETURN ThisTemplates(CtlC.GetAny(this, 67)) END Templates; PROCEDURE (this: _Global) CustomizationContext* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 68) END CustomizationContext; PROCEDURE (this: _Global) PUTCustomizationContext* (p1: CtlT.Object), NEW; BEGIN CtlC.PutObj(this, 68, p1) END PUTCustomizationContext; PROCEDURE (this: _Global) KeyBindings* (): KeyBindings, NEW; BEGIN RETURN ThisKeyBindings(CtlC.GetAny(this, 69)) END KeyBindings; PROCEDURE (this: _Global) KeysBoundTo* (KeyCategory: WdKeyCategory; Command: ARRAY OF CHAR; (* optional *) CommandParameter: CtlT.Any): KeysBoundTo, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCategory, arg[2]); CtlC.StrVar(Command, arg[1]); CtlC.AnyVar(CommandParameter, arg[0]); CtlC.CallGetMethod(this, 70, arg, ret); RETURN ThisKeysBoundTo(CtlC.VarAny(ret)) END KeysBoundTo; PROCEDURE (this: _Global) FindKey* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): KeyBinding, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallGetMethod(this, 71, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END FindKey; PROCEDURE (this: _Global) Options* (): Options, NEW; BEGIN RETURN ThisOptions(CtlC.GetAny(this, 93)) END Options; PROCEDURE (this: _Global) CustomDictionaries* (): Dictionaries, NEW; BEGIN RETURN ThisDictionaries(CtlC.GetAny(this, 95)) END CustomDictionaries; PROCEDURE (this: _Global) PUTStatusBar* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 97, p1) END PUTStatusBar; PROCEDURE (this: _Global) ShowVisualBasicEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 104) END ShowVisualBasicEditor; PROCEDURE (this: _Global) PUTShowVisualBasicEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 104, p1) END PUTShowVisualBasicEditor; PROCEDURE (this: _Global) IsObjectValid* (Object: CtlT.Object): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Object, arg[0]); CtlC.CallGetMethod(this, 109, arg, ret); RETURN CtlC.VarBool(ret) END IsObjectValid; PROCEDURE (this: _Global) HangulHanjaDictionaries* (): HangulHanjaConversionDictionaries, NEW; BEGIN RETURN ThisHangulHanjaConversionDictionaries(CtlC.GetAny(this, 110)) END HangulHanjaDictionaries; PROCEDURE (this: _Global) Repeat* ((* optional *) Times: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Times, arg[0]); CtlC.CallParMethod(this, 305, arg, ret); RETURN CtlC.VarBool(ret) END Repeat; PROCEDURE (this: _Global) DDEExecute* (Channel: INTEGER; Command: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Command, arg[0]); CtlC.CallParMethod(this, 310, arg, NIL); END DDEExecute; PROCEDURE (this: _Global) DDEInitiate* (App: ARRAY OF CHAR; Topic: ARRAY OF CHAR): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(App, arg[1]); CtlC.StrVar(Topic, arg[0]); CtlC.CallParMethod(this, 311, arg, ret); RETURN CtlC.VarInt(ret) END DDEInitiate; PROCEDURE (this: _Global) DDEPoke* (Channel: INTEGER; Item: ARRAY OF CHAR; Data: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[2]); CtlC.StrVar(Item, arg[1]); CtlC.StrVar(Data, arg[0]); CtlC.CallParMethod(this, 312, arg, NIL); END DDEPoke; PROCEDURE (this: _Global) DDERequest* (Channel: INTEGER; Item: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[1]); CtlC.StrVar(Item, arg[0]); CtlC.CallParMethod(this, 313, arg, ret); RETURN CtlC.VarStr(ret) END DDERequest; PROCEDURE (this: _Global) DDETerminate* (Channel: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Channel, arg[0]); CtlC.CallParMethod(this, 314, arg, NIL); END DDETerminate; PROCEDURE (this: _Global) DDETerminateAll* (), NEW; BEGIN CtlC.CallMethod(this, 315, NIL); END DDETerminateAll; PROCEDURE (this: _Global) BuildKeyCode* (Arg1: WdKey; (* optional *) Arg2: CtlT.Any; Arg3: CtlT.Any; Arg4: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Arg1, arg[3]); CtlC.AnyVar(Arg2, arg[2]); CtlC.AnyVar(Arg3, arg[1]); CtlC.AnyVar(Arg4, arg[0]); CtlC.CallParMethod(this, 316, arg, ret); RETURN CtlC.VarInt(ret) END BuildKeyCode; PROCEDURE (this: _Global) KeyString* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallParMethod(this, 317, arg, ret); RETURN CtlC.VarStr(ret) END KeyString; PROCEDURE (this: _Global) CheckSpelling* (Word: ARRAY OF CHAR; (* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; MainDictionary: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[12]); CtlC.AnyVar(CustomDictionary, arg[11]); CtlC.AnyVar(IgnoreUppercase, arg[10]); CtlC.AnyVar(MainDictionary, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 324, arg, ret); RETURN CtlC.VarBool(ret) END CheckSpelling; PROCEDURE (this: _Global) GetSpellingSuggestions* (Word: ARRAY OF CHAR; (* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; MainDictionary: CtlT.Any; SuggestionMode: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any): SpellingSuggestions, NEW; VAR arg: ARRAY 14 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Word, arg[13]); CtlC.AnyVar(CustomDictionary, arg[12]); CtlC.AnyVar(IgnoreUppercase, arg[11]); CtlC.AnyVar(MainDictionary, arg[10]); CtlC.AnyVar(SuggestionMode, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 327, arg, ret); RETURN ThisSpellingSuggestions(CtlC.VarAny(ret)) END GetSpellingSuggestions; PROCEDURE (this: _Global) Help* (HelpType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(HelpType, arg[0]); CtlC.CallParMethod(this, 329, arg, NIL); END Help; PROCEDURE (this: _Global) NewWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 345, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: _Global) CleanString* (String: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(String, arg[0]); CtlC.CallParMethod(this, 354, arg, ret); RETURN CtlC.VarStr(ret) END CleanString; PROCEDURE (this: _Global) ChangeFileOpenDirectory* (Path: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[0]); CtlC.CallParMethod(this, 355, arg, NIL); END ChangeFileOpenDirectory; PROCEDURE (this: _Global) InchesToPoints* (Inches: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Inches, arg[0]); CtlC.CallParMethod(this, 370, arg, ret); RETURN CtlC.VarSReal(ret) END InchesToPoints; PROCEDURE (this: _Global) CentimetersToPoints* (Centimeters: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Centimeters, arg[0]); CtlC.CallParMethod(this, 371, arg, ret); RETURN CtlC.VarSReal(ret) END CentimetersToPoints; PROCEDURE (this: _Global) MillimetersToPoints* (Millimeters: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Millimeters, arg[0]); CtlC.CallParMethod(this, 372, arg, ret); RETURN CtlC.VarSReal(ret) END MillimetersToPoints; PROCEDURE (this: _Global) PicasToPoints* (Picas: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Picas, arg[0]); CtlC.CallParMethod(this, 373, arg, ret); RETURN CtlC.VarSReal(ret) END PicasToPoints; PROCEDURE (this: _Global) LinesToPoints* (Lines: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Lines, arg[0]); CtlC.CallParMethod(this, 374, arg, ret); RETURN CtlC.VarSReal(ret) END LinesToPoints; PROCEDURE (this: _Global) PointsToInches* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 380, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToInches; PROCEDURE (this: _Global) PointsToCentimeters* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 381, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToCentimeters; PROCEDURE (this: _Global) PointsToMillimeters* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 382, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToMillimeters; PROCEDURE (this: _Global) PointsToPicas* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 383, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToPicas; PROCEDURE (this: _Global) PointsToLines* (Points: SHORTREAL): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[0]); CtlC.CallParMethod(this, 384, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToLines; PROCEDURE (this: _Global) PointsToPixels* (Points: SHORTREAL; (* optional *) fVertical: CtlT.Any): SHORTREAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Points, arg[1]); CtlC.AnyVar(fVertical, arg[0]); CtlC.CallParMethod(this, 385, arg, ret); RETURN CtlC.VarSReal(ret) END PointsToPixels; PROCEDURE (this: _Global) PixelsToPoints* (Pixels: SHORTREAL; (* optional *) fVertical: CtlT.Any): SHORTREAL, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Pixels, arg[1]); CtlC.AnyVar(fVertical, arg[0]); CtlC.CallParMethod(this, 386, arg, ret); RETURN CtlC.VarSReal(ret) END PixelsToPoints; PROCEDURE (this: _Global) LanguageSettings* (): CtlOffice.LanguageSettings, NEW; BEGIN RETURN CtlOffice.ThisLanguageSettings(CtlC.GetAny(this, 111)) END LanguageSettings; PROCEDURE (this: _Global) AnswerWizard* (): CtlOffice.AnswerWizard, NEW; BEGIN RETURN CtlOffice.ThisAnswerWizard(CtlC.GetAny(this, 112)) END AnswerWizard; (* ---------- FontNames, dual, nonextensible ---------- *) PROCEDURE (this: FontNames) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FontNames) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: FontNames) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FontNames) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FontNames) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FontNames) Item* (Index: INTEGER): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN CtlC.VarStr(ret) END Item; (* ---------- Languages, dual, nonextensible ---------- *) PROCEDURE (this: Languages) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Languages) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Languages) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Languages) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Languages) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Languages) Item* (Index: CtlT.Any): Language, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisLanguage(CtlC.VarAny(ret)) END Item; (* ---------- Language, dual, nonextensible ---------- *) PROCEDURE (this: Language) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Language) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Language) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Language) ID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END ID; PROCEDURE (this: Language) NameLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END NameLocal; PROCEDURE (this: Language) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END Name; PROCEDURE (this: Language) ActiveGrammarDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 13)) END ActiveGrammarDictionary; PROCEDURE (this: Language) ActiveHyphenationDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 14)) END ActiveHyphenationDictionary; PROCEDURE (this: Language) ActiveSpellingDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 15)) END ActiveSpellingDictionary; PROCEDURE (this: Language) ActiveThesaurusDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 16)) END ActiveThesaurusDictionary; PROCEDURE (this: Language) DefaultWritingStyle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 17) END DefaultWritingStyle; PROCEDURE (this: Language) PUTDefaultWritingStyle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 17, p1) END PUTDefaultWritingStyle; PROCEDURE (this: Language) WritingStyleList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 18) END WritingStyleList; PROCEDURE (this: Language) SpellingDictionaryType* (): WdDictionaryType, NEW; BEGIN RETURN CtlC.GetInt(this, 19) END SpellingDictionaryType; PROCEDURE (this: Language) PUTSpellingDictionaryType* (p1: WdDictionaryType), NEW; BEGIN CtlC.PutInt(this, 19, p1) END PUTSpellingDictionaryType; (* ---------- Documents, dual, nonextensible ---------- *) PROCEDURE (this: Documents) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Documents) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Documents) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Documents) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Documents) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Documents) Item* (Index: CtlT.Any): Document, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Documents) Close* ((* optional *) SaveChanges: CtlT.Any; OriginalFormat: CtlT.Any; RouteDocument: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[2]); CtlC.AnyVar(OriginalFormat, arg[1]); CtlC.AnyVar(RouteDocument, arg[0]); CtlC.CallParMethod(this, 1105, arg, NIL); END Close; PROCEDURE (this: Documents) AddOld* ((* optional *) Template: CtlT.Any; NewTemplate: CtlT.Any): Document, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Template, arg[1]); CtlC.AnyVar(NewTemplate, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END AddOld; PROCEDURE (this: Documents) OpenOld* (FileName: CtlT.Any; (* optional *) ConfirmConversions: CtlT.Any; ReadOnly: CtlT.Any; AddToRecentFiles: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; Revert: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any; Format: CtlT.Any): Document, NEW; VAR arg: ARRAY 10 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[9]); CtlC.AnyVar(ConfirmConversions, arg[8]); CtlC.AnyVar(ReadOnly, arg[7]); CtlC.AnyVar(AddToRecentFiles, arg[6]); CtlC.AnyVar(PasswordDocument, arg[5]); CtlC.AnyVar(PasswordTemplate, arg[4]); CtlC.AnyVar(Revert, arg[3]); CtlC.AnyVar(WritePasswordDocument, arg[2]); CtlC.AnyVar(WritePasswordTemplate, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END OpenOld; PROCEDURE (this: Documents) Save* ((* optional *) NoPrompt: CtlT.Any; OriginalFormat: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(NoPrompt, arg[1]); CtlC.AnyVar(OriginalFormat, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Save; PROCEDURE (this: Documents) Add* ((* optional *) Template: CtlT.Any; NewTemplate: CtlT.Any; DocumentType: CtlT.Any; Visible: CtlT.Any): Document, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Template, arg[3]); CtlC.AnyVar(NewTemplate, arg[2]); CtlC.AnyVar(DocumentType, arg[1]); CtlC.AnyVar(Visible, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Documents) Open* (FileName: CtlT.Any; (* optional *) ConfirmConversions: CtlT.Any; ReadOnly: CtlT.Any; AddToRecentFiles: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; Revert: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any; Format: CtlT.Any; Encoding: CtlT.Any; Visible: CtlT.Any): Document, NEW; VAR arg: ARRAY 12 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[11]); CtlC.AnyVar(ConfirmConversions, arg[10]); CtlC.AnyVar(ReadOnly, arg[9]); CtlC.AnyVar(AddToRecentFiles, arg[8]); CtlC.AnyVar(PasswordDocument, arg[7]); CtlC.AnyVar(PasswordTemplate, arg[6]); CtlC.AnyVar(Revert, arg[5]); CtlC.AnyVar(WritePasswordDocument, arg[4]); CtlC.AnyVar(WritePasswordTemplate, arg[3]); CtlC.AnyVar(Format, arg[2]); CtlC.AnyVar(Encoding, arg[1]); CtlC.AnyVar(Visible, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END Open; (* ---------- _Document, hidden, dual ---------- *) PROCEDURE (this: _Document) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: _Document) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1)) END Application; PROCEDURE (this: _Document) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _Document) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _Document) BuiltInDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1000) END BuiltInDocumentProperties; PROCEDURE (this: _Document) CustomDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 2) END CustomDocumentProperties; PROCEDURE (this: _Document) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Path; PROCEDURE (this: _Document) Bookmarks* (): Bookmarks, NEW; BEGIN RETURN ThisBookmarks(CtlC.GetAny(this, 4)) END Bookmarks; PROCEDURE (this: _Document) Tables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 6)) END Tables; PROCEDURE (this: _Document) Footnotes* (): Footnotes, NEW; BEGIN RETURN ThisFootnotes(CtlC.GetAny(this, 7)) END Footnotes; PROCEDURE (this: _Document) Endnotes* (): Endnotes, NEW; BEGIN RETURN ThisEndnotes(CtlC.GetAny(this, 8)) END Endnotes; PROCEDURE (this: _Document) Comments* (): Comments, NEW; BEGIN RETURN ThisComments(CtlC.GetAny(this, 9)) END Comments; PROCEDURE (this: _Document) Type* (): WdDocumentType, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Type; PROCEDURE (this: _Document) AutoHyphenation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END AutoHyphenation; PROCEDURE (this: _Document) PUTAutoHyphenation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 11, p1) END PUTAutoHyphenation; PROCEDURE (this: _Document) HyphenateCaps* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END HyphenateCaps; PROCEDURE (this: _Document) PUTHyphenateCaps* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTHyphenateCaps; PROCEDURE (this: _Document) HyphenationZone* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END HyphenationZone; PROCEDURE (this: _Document) PUTHyphenationZone* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTHyphenationZone; PROCEDURE (this: _Document) ConsecutiveHyphensLimit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 14) END ConsecutiveHyphensLimit; PROCEDURE (this: _Document) PUTConsecutiveHyphensLimit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 14, p1) END PUTConsecutiveHyphensLimit; PROCEDURE (this: _Document) Sections* (): Sections, NEW; BEGIN RETURN ThisSections(CtlC.GetAny(this, 15)) END Sections; PROCEDURE (this: _Document) Paragraphs* (): Paragraphs, NEW; BEGIN RETURN ThisParagraphs(CtlC.GetAny(this, 16)) END Paragraphs; PROCEDURE (this: _Document) Words* (): Words, NEW; BEGIN RETURN ThisWords(CtlC.GetAny(this, 17)) END Words; PROCEDURE (this: _Document) Sentences* (): Sentences, NEW; BEGIN RETURN ThisSentences(CtlC.GetAny(this, 18)) END Sentences; PROCEDURE (this: _Document) Characters* (): Characters, NEW; BEGIN RETURN ThisCharacters(CtlC.GetAny(this, 19)) END Characters; PROCEDURE (this: _Document) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 20)) END Fields; PROCEDURE (this: _Document) FormFields* (): FormFields, NEW; BEGIN RETURN ThisFormFields(CtlC.GetAny(this, 21)) END FormFields; PROCEDURE (this: _Document) Styles* (): Styles, NEW; BEGIN RETURN ThisStyles(CtlC.GetAny(this, 22)) END Styles; PROCEDURE (this: _Document) Frames* (): Frames, NEW; BEGIN RETURN ThisFrames(CtlC.GetAny(this, 23)) END Frames; PROCEDURE (this: _Document) TablesOfFigures* (): TablesOfFigures, NEW; BEGIN RETURN ThisTablesOfFigures(CtlC.GetAny(this, 25)) END TablesOfFigures; PROCEDURE (this: _Document) Variables* (): Variables, NEW; BEGIN RETURN ThisVariables(CtlC.GetAny(this, 26)) END Variables; PROCEDURE (this: _Document) MailMerge* (): MailMerge, NEW; BEGIN RETURN ThisMailMerge(CtlC.GetAny(this, 27)) END MailMerge; PROCEDURE (this: _Document) Envelope* (): Envelope, NEW; BEGIN RETURN ThisEnvelope(CtlC.GetAny(this, 28)) END Envelope; PROCEDURE (this: _Document) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 29) END FullName; PROCEDURE (this: _Document) Revisions* (): Revisions, NEW; BEGIN RETURN ThisRevisions(CtlC.GetAny(this, 30)) END Revisions; PROCEDURE (this: _Document) TablesOfContents* (): TablesOfContents, NEW; BEGIN RETURN ThisTablesOfContents(CtlC.GetAny(this, 31)) END TablesOfContents; PROCEDURE (this: _Document) TablesOfAuthorities* (): TablesOfAuthorities, NEW; BEGIN RETURN ThisTablesOfAuthorities(CtlC.GetAny(this, 32)) END TablesOfAuthorities; PROCEDURE (this: _Document) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1101)) END PageSetup; PROCEDURE (this: _Document) PUTPageSetup* (p1: PageSetup), NEW; BEGIN CtlC.PutObj(this, 1101, p1) END PUTPageSetup; PROCEDURE (this: _Document) Windows* (): Windows, NEW; BEGIN RETURN ThisWindows(CtlC.GetAny(this, 34)) END Windows; PROCEDURE (this: _Document) HasRoutingSlip* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END HasRoutingSlip; PROCEDURE (this: _Document) PUTHasRoutingSlip* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 35, p1) END PUTHasRoutingSlip; PROCEDURE (this: _Document) RoutingSlip* (): RoutingSlip, NEW; BEGIN RETURN ThisRoutingSlip(CtlC.GetAny(this, 36)) END RoutingSlip; PROCEDURE (this: _Document) Routed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 37) END Routed; PROCEDURE (this: _Document) TablesOfAuthoritiesCategories* (): TablesOfAuthoritiesCategories, NEW; BEGIN RETURN ThisTablesOfAuthoritiesCategories(CtlC.GetAny(this, 38)) END TablesOfAuthoritiesCategories; PROCEDURE (this: _Document) Indexes* (): Indexes, NEW; BEGIN RETURN ThisIndexes(CtlC.GetAny(this, 39)) END Indexes; PROCEDURE (this: _Document) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 40) END Saved; PROCEDURE (this: _Document) PUTSaved* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 40, p1) END PUTSaved; PROCEDURE (this: _Document) Content* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 41)) END Content; PROCEDURE (this: _Document) ActiveWindow* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 42)) END ActiveWindow; PROCEDURE (this: _Document) Kind* (): WdDocumentKind, NEW; BEGIN RETURN CtlC.GetInt(this, 43) END Kind; PROCEDURE (this: _Document) PUTKind* (p1: WdDocumentKind), NEW; BEGIN CtlC.PutInt(this, 43, p1) END PUTKind; PROCEDURE (this: _Document) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 44) END ReadOnly; PROCEDURE (this: _Document) Subdocuments* (): Subdocuments, NEW; BEGIN RETURN ThisSubdocuments(CtlC.GetAny(this, 45)) END Subdocuments; PROCEDURE (this: _Document) IsMasterDocument* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 46) END IsMasterDocument; PROCEDURE (this: _Document) DefaultTabStop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 48) END DefaultTabStop; PROCEDURE (this: _Document) PUTDefaultTabStop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 48, p1) END PUTDefaultTabStop; PROCEDURE (this: _Document) EmbedTrueTypeFonts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 50) END EmbedTrueTypeFonts; PROCEDURE (this: _Document) PUTEmbedTrueTypeFonts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 50, p1) END PUTEmbedTrueTypeFonts; PROCEDURE (this: _Document) SaveFormsData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 51) END SaveFormsData; PROCEDURE (this: _Document) PUTSaveFormsData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 51, p1) END PUTSaveFormsData; PROCEDURE (this: _Document) ReadOnlyRecommended* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 52) END ReadOnlyRecommended; PROCEDURE (this: _Document) PUTReadOnlyRecommended* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 52, p1) END PUTReadOnlyRecommended; PROCEDURE (this: _Document) SaveSubsetFonts* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 53) END SaveSubsetFonts; PROCEDURE (this: _Document) PUTSaveSubsetFonts* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 53, p1) END PUTSaveSubsetFonts; PROCEDURE (this: _Document) Compatibility* (Type: WdCompatibility): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallGetMethod(this, 55, arg, ret); RETURN CtlC.VarBool(ret) END Compatibility; PROCEDURE (this: _Document) PUTCompatibility* (Type: WdCompatibility; p2: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[1]); CtlC.BoolVar(p2, arg[0]); CtlC.CallPutMethod(this, 55, arg, NIL); END PUTCompatibility; PROCEDURE (this: _Document) StoryRanges* (): StoryRanges, NEW; BEGIN RETURN ThisStoryRanges(CtlC.GetAny(this, 56)) END StoryRanges; PROCEDURE (this: _Document) CommandBars* (): CtlOffice.CommandBars, NEW; BEGIN RETURN CtlOffice.This_CommandBars(CtlC.GetAny(this, 57)) END CommandBars; PROCEDURE (this: _Document) IsSubdocument* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 58) END IsSubdocument; PROCEDURE (this: _Document) SaveFormat* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 59) END SaveFormat; PROCEDURE (this: _Document) ProtectionType* (): WdProtectionType, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END ProtectionType; PROCEDURE (this: _Document) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 61)) END Hyperlinks; PROCEDURE (this: _Document) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 62)) END Shapes; PROCEDURE (this: _Document) ListTemplates* (): ListTemplates, NEW; BEGIN RETURN ThisListTemplates(CtlC.GetAny(this, 63)) END ListTemplates; PROCEDURE (this: _Document) Lists* (): Lists, NEW; BEGIN RETURN ThisLists(CtlC.GetAny(this, 64)) END Lists; PROCEDURE (this: _Document) UpdateStylesOnOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 66) END UpdateStylesOnOpen; PROCEDURE (this: _Document) PUTUpdateStylesOnOpen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 66, p1) END PUTUpdateStylesOnOpen; PROCEDURE (this: _Document) AttachedTemplate* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 67) END AttachedTemplate; PROCEDURE (this: _Document) PUTAttachedTemplate* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 67, p1) END PUTAttachedTemplate; PROCEDURE (this: _Document) InlineShapes* (): InlineShapes, NEW; BEGIN RETURN ThisInlineShapes(CtlC.GetAny(this, 68)) END InlineShapes; PROCEDURE (this: _Document) Background* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 69)) END Background; PROCEDURE (this: _Document) PUTBackground* (p1: Shape), NEW; BEGIN CtlC.PutObj(this, 69, p1) END PUTBackground; PROCEDURE (this: _Document) GrammarChecked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 70) END GrammarChecked; PROCEDURE (this: _Document) PUTGrammarChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 70, p1) END PUTGrammarChecked; PROCEDURE (this: _Document) SpellingChecked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 71) END SpellingChecked; PROCEDURE (this: _Document) PUTSpellingChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 71, p1) END PUTSpellingChecked; PROCEDURE (this: _Document) ShowGrammaticalErrors* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 72) END ShowGrammaticalErrors; PROCEDURE (this: _Document) PUTShowGrammaticalErrors* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 72, p1) END PUTShowGrammaticalErrors; PROCEDURE (this: _Document) ShowSpellingErrors* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 73) END ShowSpellingErrors; PROCEDURE (this: _Document) PUTShowSpellingErrors* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 73, p1) END PUTShowSpellingErrors; PROCEDURE (this: _Document) Versions* (): Versions, NEW; BEGIN RETURN ThisVersions(CtlC.GetAny(this, 75)) END Versions; PROCEDURE (this: _Document) ShowSummary* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 76) END ShowSummary; PROCEDURE (this: _Document) PUTShowSummary* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 76, p1) END PUTShowSummary; PROCEDURE (this: _Document) SummaryViewMode* (): WdSummaryMode, NEW; BEGIN RETURN CtlC.GetInt(this, 77) END SummaryViewMode; PROCEDURE (this: _Document) PUTSummaryViewMode* (p1: WdSummaryMode), NEW; BEGIN CtlC.PutInt(this, 77, p1) END PUTSummaryViewMode; PROCEDURE (this: _Document) SummaryLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 78) END SummaryLength; PROCEDURE (this: _Document) PUTSummaryLength* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 78, p1) END PUTSummaryLength; PROCEDURE (this: _Document) PrintFractionalWidths* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 79) END PrintFractionalWidths; PROCEDURE (this: _Document) PUTPrintFractionalWidths* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 79, p1) END PUTPrintFractionalWidths; PROCEDURE (this: _Document) PrintPostScriptOverText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 80) END PrintPostScriptOverText; PROCEDURE (this: _Document) PUTPrintPostScriptOverText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 80, p1) END PUTPrintPostScriptOverText; PROCEDURE (this: _Document) Container* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 82) END Container; PROCEDURE (this: _Document) PrintFormsData* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 83) END PrintFormsData; PROCEDURE (this: _Document) PUTPrintFormsData* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 83, p1) END PUTPrintFormsData; PROCEDURE (this: _Document) ListParagraphs* (): ListParagraphs, NEW; BEGIN RETURN ThisListParagraphs(CtlC.GetAny(this, 84)) END ListParagraphs; PROCEDURE (this: _Document) PUTPassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 85, p1) END PUTPassword; PROCEDURE (this: _Document) PUTWritePassword* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 86, p1) END PUTWritePassword; PROCEDURE (this: _Document) HasPassword* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 87) END HasPassword; PROCEDURE (this: _Document) WriteReserved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 88) END WriteReserved; PROCEDURE (this: _Document) ActiveWritingStyle* (LanguageID: CtlT.Any): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallGetMethod(this, 90, arg, ret); RETURN CtlC.VarStr(ret) END ActiveWritingStyle; PROCEDURE (this: _Document) PUTActiveWritingStyle* (LanguageID: CtlT.Any; p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(LanguageID, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, 90, arg, NIL); END PUTActiveWritingStyle; PROCEDURE (this: _Document) UserControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 92) END UserControl; PROCEDURE (this: _Document) PUTUserControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 92, p1) END PUTUserControl; PROCEDURE (this: _Document) HasMailer* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 93) END HasMailer; PROCEDURE (this: _Document) PUTHasMailer* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 93, p1) END PUTHasMailer; PROCEDURE (this: _Document) Mailer* (): Mailer, NEW; BEGIN RETURN ThisMailer(CtlC.GetAny(this, 94)) END Mailer; PROCEDURE (this: _Document) ReadabilityStatistics* (): ReadabilityStatistics, NEW; BEGIN RETURN ThisReadabilityStatistics(CtlC.GetAny(this, 96)) END ReadabilityStatistics; PROCEDURE (this: _Document) GrammaticalErrors* (): ProofreadingErrors, NEW; BEGIN RETURN ThisProofreadingErrors(CtlC.GetAny(this, 97)) END GrammaticalErrors; PROCEDURE (this: _Document) SpellingErrors* (): ProofreadingErrors, NEW; BEGIN RETURN ThisProofreadingErrors(CtlC.GetAny(this, 98)) END SpellingErrors; PROCEDURE (this: _Document) VBProject* (): CtlVBIDE.VBProject, NEW; BEGIN RETURN CtlVBIDE.This_VBProject(CtlC.GetAny(this, 99)) END VBProject; PROCEDURE (this: _Document) FormsDesign* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 100) END FormsDesign; PROCEDURE (this: _Document) _CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END _CodeName; PROCEDURE (this: _Document) PUT_CodeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUT_CodeName; PROCEDURE (this: _Document) CodeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 262) END CodeName; PROCEDURE (this: _Document) SnapToGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 300) END SnapToGrid; PROCEDURE (this: _Document) PUTSnapToGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 300, p1) END PUTSnapToGrid; PROCEDURE (this: _Document) SnapToShapes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 301) END SnapToShapes; PROCEDURE (this: _Document) PUTSnapToShapes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 301, p1) END PUTSnapToShapes; PROCEDURE (this: _Document) GridDistanceHorizontal* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 302) END GridDistanceHorizontal; PROCEDURE (this: _Document) PUTGridDistanceHorizontal* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 302, p1) END PUTGridDistanceHorizontal; PROCEDURE (this: _Document) GridDistanceVertical* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 303) END GridDistanceVertical; PROCEDURE (this: _Document) PUTGridDistanceVertical* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 303, p1) END PUTGridDistanceVertical; PROCEDURE (this: _Document) GridOriginHorizontal* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 304) END GridOriginHorizontal; PROCEDURE (this: _Document) PUTGridOriginHorizontal* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 304, p1) END PUTGridOriginHorizontal; PROCEDURE (this: _Document) GridOriginVertical* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 305) END GridOriginVertical; PROCEDURE (this: _Document) PUTGridOriginVertical* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 305, p1) END PUTGridOriginVertical; PROCEDURE (this: _Document) GridSpaceBetweenHorizontalLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 306) END GridSpaceBetweenHorizontalLines; PROCEDURE (this: _Document) PUTGridSpaceBetweenHorizontalLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 306, p1) END PUTGridSpaceBetweenHorizontalLines; PROCEDURE (this: _Document) GridSpaceBetweenVerticalLines* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 307) END GridSpaceBetweenVerticalLines; PROCEDURE (this: _Document) PUTGridSpaceBetweenVerticalLines* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 307, p1) END PUTGridSpaceBetweenVerticalLines; PROCEDURE (this: _Document) GridOriginFromMargin* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 308) END GridOriginFromMargin; PROCEDURE (this: _Document) PUTGridOriginFromMargin* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 308, p1) END PUTGridOriginFromMargin; PROCEDURE (this: _Document) KerningByAlgorithm* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 309) END KerningByAlgorithm; PROCEDURE (this: _Document) PUTKerningByAlgorithm* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 309, p1) END PUTKerningByAlgorithm; PROCEDURE (this: _Document) JustificationMode* (): WdJustificationMode, NEW; BEGIN RETURN CtlC.GetInt(this, 310) END JustificationMode; PROCEDURE (this: _Document) PUTJustificationMode* (p1: WdJustificationMode), NEW; BEGIN CtlC.PutInt(this, 310, p1) END PUTJustificationMode; PROCEDURE (this: _Document) FarEastLineBreakLevel* (): WdFarEastLineBreakLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 311) END FarEastLineBreakLevel; PROCEDURE (this: _Document) PUTFarEastLineBreakLevel* (p1: WdFarEastLineBreakLevel), NEW; BEGIN CtlC.PutInt(this, 311, p1) END PUTFarEastLineBreakLevel; PROCEDURE (this: _Document) NoLineBreakBefore* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 312) END NoLineBreakBefore; PROCEDURE (this: _Document) PUTNoLineBreakBefore* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 312, p1) END PUTNoLineBreakBefore; PROCEDURE (this: _Document) NoLineBreakAfter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 313) END NoLineBreakAfter; PROCEDURE (this: _Document) PUTNoLineBreakAfter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 313, p1) END PUTNoLineBreakAfter; PROCEDURE (this: _Document) TrackRevisions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 314) END TrackRevisions; PROCEDURE (this: _Document) PUTTrackRevisions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 314, p1) END PUTTrackRevisions; PROCEDURE (this: _Document) PrintRevisions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 315) END PrintRevisions; PROCEDURE (this: _Document) PUTPrintRevisions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 315, p1) END PUTPrintRevisions; PROCEDURE (this: _Document) ShowRevisions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 316) END ShowRevisions; PROCEDURE (this: _Document) PUTShowRevisions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 316, p1) END PUTShowRevisions; PROCEDURE (this: _Document) Close* ((* optional *) SaveChanges: CtlT.Any; OriginalFormat: CtlT.Any; RouteDocument: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[2]); CtlC.AnyVar(OriginalFormat, arg[1]); CtlC.AnyVar(RouteDocument, arg[0]); CtlC.CallParMethod(this, 1105, arg, NIL); END Close; PROCEDURE (this: _Document) SaveAs* ((* optional *) FileName: CtlT.Any; FileFormat: CtlT.Any; LockComments: CtlT.Any; Password: CtlT.Any; AddToRecentFiles: CtlT.Any; WritePassword: CtlT.Any; ReadOnlyRecommended: CtlT.Any; EmbedTrueTypeFonts: CtlT.Any; SaveNativePictureFormat: CtlT.Any; SaveFormsData: CtlT.Any; SaveAsAOCELetter: CtlT.Any), NEW; VAR arg: ARRAY 11 OF CtlT.Variant; BEGIN CtlC.AnyVar(FileName, arg[10]); CtlC.AnyVar(FileFormat, arg[9]); CtlC.AnyVar(LockComments, arg[8]); CtlC.AnyVar(Password, arg[7]); CtlC.AnyVar(AddToRecentFiles, arg[6]); CtlC.AnyVar(WritePassword, arg[5]); CtlC.AnyVar(ReadOnlyRecommended, arg[4]); CtlC.AnyVar(EmbedTrueTypeFonts, arg[3]); CtlC.AnyVar(SaveNativePictureFormat, arg[2]); CtlC.AnyVar(SaveFormsData, arg[1]); CtlC.AnyVar(SaveAsAOCELetter, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END SaveAs; PROCEDURE (this: _Document) Repaginate* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Repaginate; PROCEDURE (this: _Document) FitToPages* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END FitToPages; PROCEDURE (this: _Document) ManualHyphenation* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END ManualHyphenation; PROCEDURE (this: _Document) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: _Document) DataForm* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END DataForm; PROCEDURE (this: _Document) Route* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END Route; PROCEDURE (this: _Document) Save* (), NEW; BEGIN CtlC.CallMethod(this, 108, NIL); END Save; PROCEDURE (this: _Document) PrintOutOld* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[13]); CtlC.AnyVar(Append, arg[12]); CtlC.AnyVar(Range, arg[11]); CtlC.AnyVar(OutputFileName, arg[10]); CtlC.AnyVar(From, arg[9]); CtlC.AnyVar(To, arg[8]); CtlC.AnyVar(Item, arg[7]); CtlC.AnyVar(Copies, arg[6]); CtlC.AnyVar(Pages, arg[5]); CtlC.AnyVar(PageType, arg[4]); CtlC.AnyVar(PrintToFile, arg[3]); CtlC.AnyVar(Collate, arg[2]); CtlC.AnyVar(ActivePrinterMacGX, arg[1]); CtlC.AnyVar(ManualDuplexPrint, arg[0]); CtlC.CallParMethod(this, 109, arg, NIL); END PrintOutOld; PROCEDURE (this: _Document) SendMail* (), NEW; BEGIN CtlC.CallMethod(this, 110, NIL); END SendMail; PROCEDURE (this: _Document) Range* ((* optional *) Start: CtlT.Any; End: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Start, arg[1]); CtlC.AnyVar(End, arg[0]); CtlC.CallParMethod(this, 2000, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: _Document) RunAutoMacro* (Which: WdAutoMacros), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Which, arg[0]); CtlC.CallParMethod(this, 112, arg, NIL); END RunAutoMacro; PROCEDURE (this: _Document) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 113, NIL); END Activate; PROCEDURE (this: _Document) PrintPreview* (), NEW; BEGIN CtlC.CallMethod(this, 114, NIL); END PrintPreview; PROCEDURE (this: _Document) GoTo* ((* optional *) What: CtlT.Any; Which: CtlT.Any; Count: CtlT.Any; Name: CtlT.Any): Range, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(What, arg[3]); CtlC.AnyVar(Which, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 115, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoTo; PROCEDURE (this: _Document) Undo* ((* optional *) Times: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Times, arg[0]); CtlC.CallParMethod(this, 116, arg, ret); RETURN CtlC.VarBool(ret) END Undo; PROCEDURE (this: _Document) Redo* ((* optional *) Times: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Times, arg[0]); CtlC.CallParMethod(this, 117, arg, ret); RETURN CtlC.VarBool(ret) END Redo; PROCEDURE (this: _Document) ComputeStatistics* (Statistic: WdStatistic; (* optional *) IncludeFootnotesAndEndnotes: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Statistic, arg[1]); CtlC.AnyVar(IncludeFootnotesAndEndnotes, arg[0]); CtlC.CallParMethod(this, 118, arg, ret); RETURN CtlC.VarInt(ret) END ComputeStatistics; PROCEDURE (this: _Document) MakeCompatibilityDefault* (), NEW; BEGIN CtlC.CallMethod(this, 119, NIL); END MakeCompatibilityDefault; PROCEDURE (this: _Document) Protect* (Type: WdProtectionType; (* optional *) NoReset: CtlT.Any; Password: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[2]); CtlC.AnyVar(NoReset, arg[1]); CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 120, arg, NIL); END Protect; PROCEDURE (this: _Document) Unprotect* ((* optional *) Password: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 121, arg, NIL); END Unprotect; PROCEDURE (this: _Document) EditionOptions* (Type: WdEditionType; Option: WdEditionOption; Name: ARRAY OF CHAR; (* optional *) Format: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.IntVar(Option, arg[2]); CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 122, arg, NIL); END EditionOptions; PROCEDURE (this: _Document) RunLetterWizard* ((* optional *) LetterContent: CtlT.Any; WizardMode: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(LetterContent, arg[1]); CtlC.AnyVar(WizardMode, arg[0]); CtlC.CallParMethod(this, 123, arg, NIL); END RunLetterWizard; PROCEDURE (this: _Document) GetLetterContent* (): LetterContent, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 124, ret); RETURN This_LetterContent(CtlC.VarAny(ret)) END GetLetterContent; PROCEDURE (this: _Document) SetLetterContent* (LetterContent: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(LetterContent, arg[0]); CtlC.CallParMethod(this, 125, arg, NIL); END SetLetterContent; PROCEDURE (this: _Document) CopyStylesFromTemplate* (Template: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Template, arg[0]); CtlC.CallParMethod(this, 126, arg, NIL); END CopyStylesFromTemplate; PROCEDURE (this: _Document) UpdateStyles* (), NEW; BEGIN CtlC.CallMethod(this, 127, NIL); END UpdateStyles; PROCEDURE (this: _Document) CheckGrammar* (), NEW; BEGIN CtlC.CallMethod(this, 131, NIL); END CheckGrammar; PROCEDURE (this: _Document) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any), NEW; VAR arg: ARRAY 12 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[11]); CtlC.AnyVar(IgnoreUppercase, arg[10]); CtlC.AnyVar(AlwaysSuggest, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 132, arg, NIL); END CheckSpelling; PROCEDURE (this: _Document) FollowHyperlink* ((* optional *) Address: CtlT.Any; SubAddress: CtlT.Any; NewWindow: CtlT.Any; AddHistory: CtlT.Any; ExtraInfo: CtlT.Any; Method: CtlT.Any; HeaderInfo: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(Address, arg[6]); CtlC.AnyVar(SubAddress, arg[5]); CtlC.AnyVar(NewWindow, arg[4]); CtlC.AnyVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.AnyVar(Method, arg[1]); CtlC.AnyVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 135, arg, NIL); END FollowHyperlink; PROCEDURE (this: _Document) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 136, NIL); END AddToFavorites; PROCEDURE (this: _Document) Reload* (), NEW; BEGIN CtlC.CallMethod(this, 137, NIL); END Reload; PROCEDURE (this: _Document) AutoSummarize* ((* optional *) Length: CtlT.Any; Mode: CtlT.Any; UpdateProperties: CtlT.Any): Range, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Length, arg[2]); CtlC.AnyVar(Mode, arg[1]); CtlC.AnyVar(UpdateProperties, arg[0]); CtlC.CallParMethod(this, 138, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END AutoSummarize; PROCEDURE (this: _Document) RemoveNumbers* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 140, arg, NIL); END RemoveNumbers; PROCEDURE (this: _Document) ConvertNumbersToText* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 141, arg, NIL); END ConvertNumbersToText; PROCEDURE (this: _Document) CountNumberedItems* ((* optional *) NumberType: CtlT.Any; Level: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[1]); CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 142, arg, ret); RETURN CtlC.VarInt(ret) END CountNumberedItems; PROCEDURE (this: _Document) Post* (), NEW; BEGIN CtlC.CallMethod(this, 143, NIL); END Post; PROCEDURE (this: _Document) ToggleFormsDesign* (), NEW; BEGIN CtlC.CallMethod(this, 144, NIL); END ToggleFormsDesign; PROCEDURE (this: _Document) Compare* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 145, arg, NIL); END Compare; PROCEDURE (this: _Document) UpdateSummaryProperties* (), NEW; BEGIN CtlC.CallMethod(this, 146, NIL); END UpdateSummaryProperties; PROCEDURE (this: _Document) GetCrossReferenceItems* (ReferenceType: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ReferenceType, arg[0]); CtlC.CallParMethod(this, 147, arg, ret); RETURN CtlC.VarAny(ret) END GetCrossReferenceItems; PROCEDURE (this: _Document) AutoFormat* (), NEW; BEGIN CtlC.CallMethod(this, 148, NIL); END AutoFormat; PROCEDURE (this: _Document) ViewCode* (), NEW; BEGIN CtlC.CallMethod(this, 149, NIL); END ViewCode; PROCEDURE (this: _Document) ViewPropertyBrowser* (), NEW; BEGIN CtlC.CallMethod(this, 150, NIL); END ViewPropertyBrowser; PROCEDURE (this: _Document) ForwardMailer* (), NEW; BEGIN CtlC.CallMethod(this, 250, NIL); END ForwardMailer; PROCEDURE (this: _Document) Reply* (), NEW; BEGIN CtlC.CallMethod(this, 251, NIL); END Reply; PROCEDURE (this: _Document) ReplyAll* (), NEW; BEGIN CtlC.CallMethod(this, 252, NIL); END ReplyAll; PROCEDURE (this: _Document) SendMailer* ((* optional *) FileFormat: CtlT.Any; Priority: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FileFormat, arg[1]); CtlC.AnyVar(Priority, arg[0]); CtlC.CallParMethod(this, 253, arg, NIL); END SendMailer; PROCEDURE (this: _Document) UndoClear* (), NEW; BEGIN CtlC.CallMethod(this, 254, NIL); END UndoClear; PROCEDURE (this: _Document) PresentIt* (), NEW; BEGIN CtlC.CallMethod(this, 255, NIL); END PresentIt; PROCEDURE (this: _Document) SendFax* (Address: ARRAY OF CHAR; (* optional *) Subject: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Address, arg[1]); CtlC.AnyVar(Subject, arg[0]); CtlC.CallParMethod(this, 256, arg, NIL); END SendFax; PROCEDURE (this: _Document) Merge* (FileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 257, arg, NIL); END Merge; PROCEDURE (this: _Document) ClosePrintPreview* (), NEW; BEGIN CtlC.CallMethod(this, 258, NIL); END ClosePrintPreview; PROCEDURE (this: _Document) CheckConsistency* (), NEW; BEGIN CtlC.CallMethod(this, 259, NIL); END CheckConsistency; PROCEDURE (this: _Document) CreateLetterContent* (DateFormat: ARRAY OF CHAR; IncludeHeaderFooter: BOOLEAN; PageDesign: ARRAY OF CHAR; LetterStyle: WdLetterStyle; Letterhead: BOOLEAN; LetterheadLocation: WdLetterheadLocation; LetterheadSize: SHORTREAL; RecipientName: ARRAY OF CHAR; RecipientAddress: ARRAY OF CHAR; Salutation: ARRAY OF CHAR; SalutationType: WdSalutationType; RecipientReference: ARRAY OF CHAR; MailingInstructions: ARRAY OF CHAR; AttentionLine: ARRAY OF CHAR; Subject: ARRAY OF CHAR; CCList: ARRAY OF CHAR; ReturnAddress: ARRAY OF CHAR; SenderName: ARRAY OF CHAR; Closing: ARRAY OF CHAR; SenderCompany: ARRAY OF CHAR; SenderJobTitle: ARRAY OF CHAR; SenderInitials: ARRAY OF CHAR; EnclosureNumber: INTEGER; (* optional *) InfoBlock: CtlT.Any; RecipientCode: CtlT.Any; RecipientGender: CtlT.Any; ReturnAddressShortForm: CtlT.Any; SenderCity: CtlT.Any; SenderCode: CtlT.Any; SenderGender: CtlT.Any; SenderReference: CtlT.Any): LetterContent, NEW; VAR arg: ARRAY 31 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(DateFormat, arg[30]); CtlC.BoolVar(IncludeHeaderFooter, arg[29]); CtlC.StrVar(PageDesign, arg[28]); CtlC.IntVar(LetterStyle, arg[27]); CtlC.BoolVar(Letterhead, arg[26]); CtlC.IntVar(LetterheadLocation, arg[25]); CtlC.SRealVar(LetterheadSize, arg[24]); CtlC.StrVar(RecipientName, arg[23]); CtlC.StrVar(RecipientAddress, arg[22]); CtlC.StrVar(Salutation, arg[21]); CtlC.IntVar(SalutationType, arg[20]); CtlC.StrVar(RecipientReference, arg[19]); CtlC.StrVar(MailingInstructions, arg[18]); CtlC.StrVar(AttentionLine, arg[17]); CtlC.StrVar(Subject, arg[16]); CtlC.StrVar(CCList, arg[15]); CtlC.StrVar(ReturnAddress, arg[14]); CtlC.StrVar(SenderName, arg[13]); CtlC.StrVar(Closing, arg[12]); CtlC.StrVar(SenderCompany, arg[11]); CtlC.StrVar(SenderJobTitle, arg[10]); CtlC.StrVar(SenderInitials, arg[9]); CtlC.IntVar(EnclosureNumber, arg[8]); CtlC.AnyVar(InfoBlock, arg[7]); CtlC.AnyVar(RecipientCode, arg[6]); CtlC.AnyVar(RecipientGender, arg[5]); CtlC.AnyVar(ReturnAddressShortForm, arg[4]); CtlC.AnyVar(SenderCity, arg[3]); CtlC.AnyVar(SenderCode, arg[2]); CtlC.AnyVar(SenderGender, arg[1]); CtlC.AnyVar(SenderReference, arg[0]); CtlC.CallParMethod(this, 260, arg, ret); RETURN This_LetterContent(CtlC.VarAny(ret)) END CreateLetterContent; PROCEDURE (this: _Document) AcceptAllRevisions* (), NEW; BEGIN CtlC.CallMethod(this, 317, NIL); END AcceptAllRevisions; PROCEDURE (this: _Document) RejectAllRevisions* (), NEW; BEGIN CtlC.CallMethod(this, 318, NIL); END RejectAllRevisions; PROCEDURE (this: _Document) DetectLanguage* (), NEW; BEGIN CtlC.CallMethod(this, 151, NIL); END DetectLanguage; PROCEDURE (this: _Document) ApplyTheme* (Name: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 322, arg, NIL); END ApplyTheme; PROCEDURE (this: _Document) RemoveTheme* (), NEW; BEGIN CtlC.CallMethod(this, 323, NIL); END RemoveTheme; PROCEDURE (this: _Document) WebPagePreview* (), NEW; BEGIN CtlC.CallMethod(this, 325, NIL); END WebPagePreview; PROCEDURE (this: _Document) ReloadAs* (Encoding: CtlOffice.MsoEncoding), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Encoding, arg[0]); CtlC.CallParMethod(this, 331, arg, NIL); END ReloadAs; PROCEDURE (this: _Document) ActiveTheme* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 540) END ActiveTheme; PROCEDURE (this: _Document) ActiveThemeDisplayName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 541) END ActiveThemeDisplayName; PROCEDURE (this: _Document) Email* (): Email, NEW; BEGIN RETURN ThisEmail(CtlC.GetAny(this, 319)) END Email; PROCEDURE (this: _Document) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 320)) END Scripts; PROCEDURE (this: _Document) LanguageDetected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 321) END LanguageDetected; PROCEDURE (this: _Document) PUTLanguageDetected* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 321, p1) END PUTLanguageDetected; PROCEDURE (this: _Document) FarEastLineBreakLanguage* (): WdFarEastLineBreakLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 326) END FarEastLineBreakLanguage; PROCEDURE (this: _Document) PUTFarEastLineBreakLanguage* (p1: WdFarEastLineBreakLanguageID), NEW; BEGIN CtlC.PutInt(this, 326, p1) END PUTFarEastLineBreakLanguage; PROCEDURE (this: _Document) Frameset* (): Frameset, NEW; BEGIN RETURN ThisFrameset(CtlC.GetAny(this, 327)) END Frameset; PROCEDURE (this: _Document) ClickAndTypeParagraphStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 328) END ClickAndTypeParagraphStyle; PROCEDURE (this: _Document) PUTClickAndTypeParagraphStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 328, p1) END PUTClickAndTypeParagraphStyle; PROCEDURE (this: _Document) HTMLProject* (): CtlOffice.HTMLProject, NEW; BEGIN RETURN CtlOffice.ThisHTMLProject(CtlC.GetAny(this, 329)) END HTMLProject; PROCEDURE (this: _Document) WebOptions* (): WebOptions, NEW; BEGIN RETURN ThisWebOptions(CtlC.GetAny(this, 330)) END WebOptions; PROCEDURE (this: _Document) OpenEncoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 332) END OpenEncoding; PROCEDURE (this: _Document) SaveEncoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 333) END SaveEncoding; PROCEDURE (this: _Document) PUTSaveEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 333, p1) END PUTSaveEncoding; PROCEDURE (this: _Document) OptimizeForWord97* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 334) END OptimizeForWord97; PROCEDURE (this: _Document) PUTOptimizeForWord97* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 334, p1) END PUTOptimizeForWord97; PROCEDURE (this: _Document) VBASigned* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 335) END VBASigned; PROCEDURE (this: _Document) PrintOut* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any; PrintZoomColumn: CtlT.Any; PrintZoomRow: CtlT.Any; PrintZoomPaperWidth: CtlT.Any; PrintZoomPaperHeight: CtlT.Any), NEW; VAR arg: ARRAY 18 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[17]); CtlC.AnyVar(Append, arg[16]); CtlC.AnyVar(Range, arg[15]); CtlC.AnyVar(OutputFileName, arg[14]); CtlC.AnyVar(From, arg[13]); CtlC.AnyVar(To, arg[12]); CtlC.AnyVar(Item, arg[11]); CtlC.AnyVar(Copies, arg[10]); CtlC.AnyVar(Pages, arg[9]); CtlC.AnyVar(PageType, arg[8]); CtlC.AnyVar(PrintToFile, arg[7]); CtlC.AnyVar(Collate, arg[6]); CtlC.AnyVar(ActivePrinterMacGX, arg[5]); CtlC.AnyVar(ManualDuplexPrint, arg[4]); CtlC.AnyVar(PrintZoomColumn, arg[3]); CtlC.AnyVar(PrintZoomRow, arg[2]); CtlC.AnyVar(PrintZoomPaperWidth, arg[1]); CtlC.AnyVar(PrintZoomPaperHeight, arg[0]); CtlC.CallParMethod(this, 444, arg, NIL); END PrintOut; PROCEDURE (this: _Document) sblt* (s: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(s, arg[0]); CtlC.CallParMethod(this, 445, arg, NIL); END sblt; (* ---------- Template, dual, nonextensible ---------- *) PROCEDURE (this: Template) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Template) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Template) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Template) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Template) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Path; PROCEDURE (this: Template) AutoTextEntries* (): AutoTextEntries, NEW; BEGIN RETURN ThisAutoTextEntries(CtlC.GetAny(this, 2)) END AutoTextEntries; PROCEDURE (this: Template) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END LanguageID; PROCEDURE (this: Template) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTLanguageID; PROCEDURE (this: Template) Saved* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Saved; PROCEDURE (this: Template) PUTSaved* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTSaved; PROCEDURE (this: Template) Type* (): WdTemplateType, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Type; PROCEDURE (this: Template) FullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END FullName; PROCEDURE (this: Template) BuiltInDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 8) END BuiltInDocumentProperties; PROCEDURE (this: Template) CustomDocumentProperties* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 9) END CustomDocumentProperties; PROCEDURE (this: Template) ListTemplates* (): ListTemplates, NEW; BEGIN RETURN ThisListTemplates(CtlC.GetAny(this, 10)) END ListTemplates; PROCEDURE (this: Template) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END LanguageIDFarEast; PROCEDURE (this: Template) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Template) VBProject* (): CtlVBIDE.VBProject, NEW; BEGIN RETURN CtlVBIDE.This_VBProject(CtlC.GetAny(this, 99)) END VBProject; PROCEDURE (this: Template) KerningByAlgorithm* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END KerningByAlgorithm; PROCEDURE (this: Template) PUTKerningByAlgorithm* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTKerningByAlgorithm; PROCEDURE (this: Template) JustificationMode* (): WdJustificationMode, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END JustificationMode; PROCEDURE (this: Template) PUTJustificationMode* (p1: WdJustificationMode), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTJustificationMode; PROCEDURE (this: Template) FarEastLineBreakLevel* (): WdFarEastLineBreakLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 14) END FarEastLineBreakLevel; PROCEDURE (this: Template) PUTFarEastLineBreakLevel* (p1: WdFarEastLineBreakLevel), NEW; BEGIN CtlC.PutInt(this, 14, p1) END PUTFarEastLineBreakLevel; PROCEDURE (this: Template) NoLineBreakBefore* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 15) END NoLineBreakBefore; PROCEDURE (this: Template) PUTNoLineBreakBefore* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 15, p1) END PUTNoLineBreakBefore; PROCEDURE (this: Template) NoLineBreakAfter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 16) END NoLineBreakAfter; PROCEDURE (this: Template) PUTNoLineBreakAfter* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 16, p1) END PUTNoLineBreakAfter; PROCEDURE (this: Template) OpenAsDocument* (): Document, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 100, ret); RETURN This_Document(CtlC.VarAny(ret)) END OpenAsDocument; PROCEDURE (this: Template) Save* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Save; PROCEDURE (this: Template) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 17) END NoProofing; PROCEDURE (this: Template) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 17, p1) END PUTNoProofing; PROCEDURE (this: Template) FarEastLineBreakLanguage* (): WdFarEastLineBreakLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END FarEastLineBreakLanguage; PROCEDURE (this: Template) PUTFarEastLineBreakLanguage* (p1: WdFarEastLineBreakLanguageID), NEW; BEGIN CtlC.PutInt(this, 18, p1) END PUTFarEastLineBreakLanguage; (* ---------- Templates, dual, nonextensible ---------- *) PROCEDURE (this: Templates) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Templates) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Templates) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Templates) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Templates) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Templates) Item* (Index: CtlT.Any): Template, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTemplate(CtlC.VarAny(ret)) END Item; (* ---------- RoutingSlip, dual, nonextensible ---------- *) PROCEDURE (this: RoutingSlip) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: RoutingSlip) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: RoutingSlip) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: RoutingSlip) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Subject; PROCEDURE (this: RoutingSlip) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTSubject; PROCEDURE (this: RoutingSlip) Message* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Message; PROCEDURE (this: RoutingSlip) PUTMessage* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTMessage; PROCEDURE (this: RoutingSlip) Delivery* (): WdRoutingSlipDelivery, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Delivery; PROCEDURE (this: RoutingSlip) PUTDelivery* (p1: WdRoutingSlipDelivery), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTDelivery; PROCEDURE (this: RoutingSlip) TrackStatus* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END TrackStatus; PROCEDURE (this: RoutingSlip) PUTTrackStatus* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTTrackStatus; PROCEDURE (this: RoutingSlip) Protect* (): WdProtectionType, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Protect; PROCEDURE (this: RoutingSlip) PUTProtect* (p1: WdProtectionType), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTProtect; PROCEDURE (this: RoutingSlip) ReturnWhenDone* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END ReturnWhenDone; PROCEDURE (this: RoutingSlip) PUTReturnWhenDone* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTReturnWhenDone; PROCEDURE (this: RoutingSlip) Status* (): WdRoutingSlipStatus, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END Status; PROCEDURE (this: RoutingSlip) Recipients* ((* optional *) Index: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallGetMethod(this, 9, arg, ret); RETURN CtlC.VarAny(ret) END Recipients; PROCEDURE (this: RoutingSlip) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Reset; PROCEDURE (this: RoutingSlip) AddRecipient* (Recipient: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Recipient, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END AddRecipient; (* ---------- Bookmark, dual, nonextensible ---------- *) PROCEDURE (this: Bookmark) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Bookmark) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1)) END Range; PROCEDURE (this: Bookmark) Empty* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Empty; PROCEDURE (this: Bookmark) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Start; PROCEDURE (this: Bookmark) PUTStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTStart; PROCEDURE (this: Bookmark) End* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END End; PROCEDURE (this: Bookmark) PUTEnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTEnd; PROCEDURE (this: Bookmark) Column* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Column; PROCEDURE (this: Bookmark) StoryType* (): WdStoryType, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END StoryType; PROCEDURE (this: Bookmark) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Bookmark) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Bookmark) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Bookmark) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Bookmark) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; PROCEDURE (this: Bookmark) Copy* (Name: ARRAY OF CHAR): Bookmark, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN ThisBookmark(CtlC.VarAny(ret)) END Copy; (* ---------- Bookmarks, dual, nonextensible ---------- *) PROCEDURE (this: Bookmarks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Bookmarks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Bookmarks) DefaultSorting* (): WdBookmarkSortBy, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END DefaultSorting; PROCEDURE (this: Bookmarks) PUTDefaultSorting* (p1: WdBookmarkSortBy), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTDefaultSorting; PROCEDURE (this: Bookmarks) ShowHidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END ShowHidden; PROCEDURE (this: Bookmarks) PUTShowHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTShowHidden; PROCEDURE (this: Bookmarks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Bookmarks) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Bookmarks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Bookmarks) Item* (Index: CtlT.Any): Bookmark, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisBookmark(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Bookmarks) Add* (Name: ARRAY OF CHAR; (* optional *) Range: CtlT.Any): Bookmark, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 5, arg, ret); RETURN ThisBookmark(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Bookmarks) Exists* (Name: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 6, arg, ret); RETURN CtlC.VarBool(ret) END Exists; (* ---------- Variable, dual, nonextensible ---------- *) PROCEDURE (this: Variable) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Variable) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Variable) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Variable) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Name; PROCEDURE (this: Variable) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: Variable) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: Variable) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Index; PROCEDURE (this: Variable) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; (* ---------- Variables, dual, nonextensible ---------- *) PROCEDURE (this: Variables) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Variables) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Variables) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Variables) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Variables) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Variables) Item* (Index: CtlT.Any): Variable, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisVariable(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Variables) Add* (Name: ARRAY OF CHAR; (* optional *) Value: CtlT.Any): Variable, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Value, arg[0]); CtlC.CallParMethod(this, 7, arg, ret); RETURN ThisVariable(CtlC.VarAny(ret)) END Add; (* ---------- RecentFile, dual, nonextensible ---------- *) PROCEDURE (this: RecentFile) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: RecentFile) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: RecentFile) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: RecentFile) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: RecentFile) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: RecentFile) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END ReadOnly; PROCEDURE (this: RecentFile) PUTReadOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTReadOnly; PROCEDURE (this: RecentFile) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Path; PROCEDURE (this: RecentFile) Open* (): Document, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 4, ret); RETURN This_Document(CtlC.VarAny(ret)) END Open; PROCEDURE (this: RecentFile) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 5, NIL); END Delete; (* ---------- RecentFiles, dual, nonextensible ---------- *) PROCEDURE (this: RecentFiles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: RecentFiles) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: RecentFiles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: RecentFiles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: RecentFiles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: RecentFiles) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Maximum; PROCEDURE (this: RecentFiles) PUTMaximum* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTMaximum; PROCEDURE (this: RecentFiles) Item* (Index: INTEGER): RecentFile, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRecentFile(CtlC.VarAny(ret)) END Item; PROCEDURE (this: RecentFiles) Add* (Document: CtlT.Any; (* optional *) ReadOnly: CtlT.Any): RecentFile, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Document, arg[1]); CtlC.AnyVar(ReadOnly, arg[0]); CtlC.CallParMethod(this, 3, arg, ret); RETURN ThisRecentFile(CtlC.VarAny(ret)) END Add; (* ---------- Window, dual, nonextensible ---------- *) PROCEDURE (this: Window) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Window) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Window) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Window) ActivePane* (): Pane, NEW; BEGIN RETURN ThisPane(CtlC.GetAny(this, 1)) END ActivePane; PROCEDURE (this: Window) Document* (): Document, NEW; BEGIN RETURN This_Document(CtlC.GetAny(this, 2)) END Document; PROCEDURE (this: Window) Panes* (): Panes, NEW; BEGIN RETURN ThisPanes(CtlC.GetAny(this, 3)) END Panes; PROCEDURE (this: Window) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 4)) END Selection; PROCEDURE (this: Window) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Left; PROCEDURE (this: Window) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTLeft; PROCEDURE (this: Window) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Top; PROCEDURE (this: Window) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTTop; PROCEDURE (this: Window) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END Width; PROCEDURE (this: Window) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTWidth; PROCEDURE (this: Window) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END Height; PROCEDURE (this: Window) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTHeight; PROCEDURE (this: Window) Split* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END Split; PROCEDURE (this: Window) PUTSplit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTSplit; PROCEDURE (this: Window) SplitVertical* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END SplitVertical; PROCEDURE (this: Window) PUTSplitVertical* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTSplitVertical; PROCEDURE (this: Window) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Caption; PROCEDURE (this: Window) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTCaption; PROCEDURE (this: Window) WindowState* (): WdWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END WindowState; PROCEDURE (this: Window) PUTWindowState* (p1: WdWindowState), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTWindowState; PROCEDURE (this: Window) DisplayRulers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END DisplayRulers; PROCEDURE (this: Window) PUTDisplayRulers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTDisplayRulers; PROCEDURE (this: Window) DisplayVerticalRuler* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END DisplayVerticalRuler; PROCEDURE (this: Window) PUTDisplayVerticalRuler* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTDisplayVerticalRuler; PROCEDURE (this: Window) View* (): View, NEW; BEGIN RETURN ThisView(CtlC.GetAny(this, 14)) END View; PROCEDURE (this: Window) Type* (): WdWindowType, NEW; BEGIN RETURN CtlC.GetInt(this, 15) END Type; PROCEDURE (this: Window) Next* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 16)) END Next; PROCEDURE (this: Window) Previous* (): Window, NEW; BEGIN RETURN ThisWindow(CtlC.GetAny(this, 17)) END Previous; PROCEDURE (this: Window) WindowNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END WindowNumber; PROCEDURE (this: Window) DisplayVerticalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 19) END DisplayVerticalScrollBar; PROCEDURE (this: Window) PUTDisplayVerticalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 19, p1) END PUTDisplayVerticalScrollBar; PROCEDURE (this: Window) DisplayHorizontalScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END DisplayHorizontalScrollBar; PROCEDURE (this: Window) PUTDisplayHorizontalScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTDisplayHorizontalScrollBar; PROCEDURE (this: Window) StyleAreaWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 21) END StyleAreaWidth; PROCEDURE (this: Window) PUTStyleAreaWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 21, p1) END PUTStyleAreaWidth; PROCEDURE (this: Window) DisplayScreenTips* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 22) END DisplayScreenTips; PROCEDURE (this: Window) PUTDisplayScreenTips* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 22, p1) END PUTDisplayScreenTips; PROCEDURE (this: Window) HorizontalPercentScrolled* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END HorizontalPercentScrolled; PROCEDURE (this: Window) PUTHorizontalPercentScrolled* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTHorizontalPercentScrolled; PROCEDURE (this: Window) VerticalPercentScrolled* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 24) END VerticalPercentScrolled; PROCEDURE (this: Window) PUTVerticalPercentScrolled* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 24, p1) END PUTVerticalPercentScrolled; PROCEDURE (this: Window) DocumentMap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END DocumentMap; PROCEDURE (this: Window) PUTDocumentMap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTDocumentMap; PROCEDURE (this: Window) Active* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 26) END Active; PROCEDURE (this: Window) DocumentMapPercentWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END DocumentMapPercentWidth; PROCEDURE (this: Window) PUTDocumentMapPercentWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTDocumentMapPercentWidth; PROCEDURE (this: Window) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END Index; PROCEDURE (this: Window) IMEMode* (): WdIMEMode, NEW; BEGIN RETURN CtlC.GetInt(this, 30) END IMEMode; PROCEDURE (this: Window) PUTIMEMode* (p1: WdIMEMode), NEW; BEGIN CtlC.PutInt(this, 30, p1) END PUTIMEMode; PROCEDURE (this: Window) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Activate; PROCEDURE (this: Window) Close* ((* optional *) SaveChanges: CtlT.Any; RouteDocument: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(SaveChanges, arg[1]); CtlC.AnyVar(RouteDocument, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END Close; PROCEDURE (this: Window) LargeScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 103, arg, NIL); END LargeScroll; PROCEDURE (this: Window) SmallScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END SmallScroll; PROCEDURE (this: Window) NewWindow* (): Window, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 105, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END NewWindow; PROCEDURE (this: Window) PrintOutOld* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[13]); CtlC.AnyVar(Append, arg[12]); CtlC.AnyVar(Range, arg[11]); CtlC.AnyVar(OutputFileName, arg[10]); CtlC.AnyVar(From, arg[9]); CtlC.AnyVar(To, arg[8]); CtlC.AnyVar(Item, arg[7]); CtlC.AnyVar(Copies, arg[6]); CtlC.AnyVar(Pages, arg[5]); CtlC.AnyVar(PageType, arg[4]); CtlC.AnyVar(PrintToFile, arg[3]); CtlC.AnyVar(Collate, arg[2]); CtlC.AnyVar(ActivePrinterMacGX, arg[1]); CtlC.AnyVar(ManualDuplexPrint, arg[0]); CtlC.CallParMethod(this, 107, arg, NIL); END PrintOutOld; PROCEDURE (this: Window) PageScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[1]); CtlC.AnyVar(Up, arg[0]); CtlC.CallParMethod(this, 108, arg, NIL); END PageScroll; PROCEDURE (this: Window) SetFocus* (), NEW; BEGIN CtlC.CallMethod(this, 109, NIL); END SetFocus; PROCEDURE (this: Window) RangeFromPoint* (x: INTEGER; y: INTEGER): CtlT.Object, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(x, arg[1]); CtlC.IntVar(y, arg[0]); CtlC.CallParMethod(this, 110, arg, ret); RETURN CtlC.VarObj(ret) END RangeFromPoint; PROCEDURE (this: Window) ScrollIntoView* (obj: CtlT.Object; (* optional *) Start: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(obj, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 111, arg, NIL); END ScrollIntoView; PROCEDURE (this: Window) GetPoint* (OUT ScreenPixelsLeft: INTEGER; OUT ScreenPixelsTop: INTEGER; OUT ScreenPixelsWidth: INTEGER; OUT ScreenPixelsHeight: INTEGER; obj: CtlT.Object), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.RefIntVar(ScreenPixelsLeft, arg[4]); CtlC.RefIntVar(ScreenPixelsTop, arg[3]); CtlC.RefIntVar(ScreenPixelsWidth, arg[2]); CtlC.RefIntVar(ScreenPixelsHeight, arg[1]); CtlC.ObjVar(obj, arg[0]); CtlC.CallParMethod(this, 112, arg, NIL); END GetPoint; PROCEDURE (this: Window) PrintOut* ((* optional *) Background: CtlT.Any; Append: CtlT.Any; Range: CtlT.Any; OutputFileName: CtlT.Any; From: CtlT.Any; To: CtlT.Any; Item: CtlT.Any; Copies: CtlT.Any; Pages: CtlT.Any; PageType: CtlT.Any; PrintToFile: CtlT.Any; Collate: CtlT.Any; ActivePrinterMacGX: CtlT.Any; ManualDuplexPrint: CtlT.Any; PrintZoomColumn: CtlT.Any; PrintZoomRow: CtlT.Any; PrintZoomPaperWidth: CtlT.Any; PrintZoomPaperHeight: CtlT.Any), NEW; VAR arg: ARRAY 18 OF CtlT.Variant; BEGIN CtlC.AnyVar(Background, arg[17]); CtlC.AnyVar(Append, arg[16]); CtlC.AnyVar(Range, arg[15]); CtlC.AnyVar(OutputFileName, arg[14]); CtlC.AnyVar(From, arg[13]); CtlC.AnyVar(To, arg[12]); CtlC.AnyVar(Item, arg[11]); CtlC.AnyVar(Copies, arg[10]); CtlC.AnyVar(Pages, arg[9]); CtlC.AnyVar(PageType, arg[8]); CtlC.AnyVar(PrintToFile, arg[7]); CtlC.AnyVar(Collate, arg[6]); CtlC.AnyVar(ActivePrinterMacGX, arg[5]); CtlC.AnyVar(ManualDuplexPrint, arg[4]); CtlC.AnyVar(PrintZoomColumn, arg[3]); CtlC.AnyVar(PrintZoomRow, arg[2]); CtlC.AnyVar(PrintZoomPaperWidth, arg[1]); CtlC.AnyVar(PrintZoomPaperHeight, arg[0]); CtlC.CallParMethod(this, 444, arg, NIL); END PrintOut; PROCEDURE (this: Window) UsableWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 31) END UsableWidth; PROCEDURE (this: Window) UsableHeight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32) END UsableHeight; PROCEDURE (this: Window) EnvelopeVisible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END EnvelopeVisible; PROCEDURE (this: Window) PUTEnvelopeVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTEnvelopeVisible; PROCEDURE (this: Window) DisplayRightRuler* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END DisplayRightRuler; PROCEDURE (this: Window) PUTDisplayRightRuler* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 35, p1) END PUTDisplayRightRuler; PROCEDURE (this: Window) DisplayLeftScrollBar* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34) END DisplayLeftScrollBar; PROCEDURE (this: Window) PUTDisplayLeftScrollBar* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34, p1) END PUTDisplayLeftScrollBar; PROCEDURE (this: Window) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END Visible; PROCEDURE (this: Window) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTVisible; (* ---------- Windows, dual, nonextensible ---------- *) PROCEDURE (this: Windows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Windows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Windows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Windows) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Windows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Windows) Item* (Index: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Windows) Add* ((* optional *) window: CtlT.Any): Window, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(window, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN ThisWindow(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Windows) Arrange* ((* optional *) ArrangeStyle: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ArrangeStyle, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Arrange; (* ---------- Pane, dual, nonextensible ---------- *) PROCEDURE (this: Pane) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Pane) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Pane) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Pane) Document* (): Document, NEW; BEGIN RETURN This_Document(CtlC.GetAny(this, 1)) END Document; PROCEDURE (this: Pane) Selection* (): Selection, NEW; BEGIN RETURN ThisSelection(CtlC.GetAny(this, 3)) END Selection; PROCEDURE (this: Pane) DisplayRulers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END DisplayRulers; PROCEDURE (this: Pane) PUTDisplayRulers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTDisplayRulers; PROCEDURE (this: Pane) DisplayVerticalRuler* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END DisplayVerticalRuler; PROCEDURE (this: Pane) PUTDisplayVerticalRuler* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTDisplayVerticalRuler; PROCEDURE (this: Pane) Zooms* (): Zooms, NEW; BEGIN RETURN ThisZooms(CtlC.GetAny(this, 7)) END Zooms; PROCEDURE (this: Pane) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END Index; PROCEDURE (this: Pane) View* (): View, NEW; BEGIN RETURN ThisView(CtlC.GetAny(this, 10)) END View; PROCEDURE (this: Pane) Next* (): Pane, NEW; BEGIN RETURN ThisPane(CtlC.GetAny(this, 11)) END Next; PROCEDURE (this: Pane) Previous* (): Pane, NEW; BEGIN RETURN ThisPane(CtlC.GetAny(this, 12)) END Previous; PROCEDURE (this: Pane) HorizontalPercentScrolled* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END HorizontalPercentScrolled; PROCEDURE (this: Pane) PUTHorizontalPercentScrolled* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTHorizontalPercentScrolled; PROCEDURE (this: Pane) VerticalPercentScrolled* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 14) END VerticalPercentScrolled; PROCEDURE (this: Pane) PUTVerticalPercentScrolled* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 14, p1) END PUTVerticalPercentScrolled; PROCEDURE (this: Pane) MinimumFontSize* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 15) END MinimumFontSize; PROCEDURE (this: Pane) PUTMinimumFontSize* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 15, p1) END PUTMinimumFontSize; PROCEDURE (this: Pane) BrowseToWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END BrowseToWindow; PROCEDURE (this: Pane) PUTBrowseToWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTBrowseToWindow; PROCEDURE (this: Pane) BrowseWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 17) END BrowseWidth; PROCEDURE (this: Pane) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Activate; PROCEDURE (this: Pane) Close* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Close; PROCEDURE (this: Pane) LargeScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END LargeScroll; PROCEDURE (this: Pane) SmallScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any; ToRight: CtlT.Any; ToLeft: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[3]); CtlC.AnyVar(Up, arg[2]); CtlC.AnyVar(ToRight, arg[1]); CtlC.AnyVar(ToLeft, arg[0]); CtlC.CallParMethod(this, 103, arg, NIL); END SmallScroll; PROCEDURE (this: Pane) AutoScroll* (Velocity: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Velocity, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END AutoScroll; PROCEDURE (this: Pane) PageScroll* ((* optional *) Down: CtlT.Any; Up: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Down, arg[1]); CtlC.AnyVar(Up, arg[0]); CtlC.CallParMethod(this, 105, arg, NIL); END PageScroll; PROCEDURE (this: Pane) NewFrameset* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END NewFrameset; PROCEDURE (this: Pane) TOCInFrameset* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END TOCInFrameset; PROCEDURE (this: Pane) Frameset* (): Frameset, NEW; BEGIN RETURN ThisFrameset(CtlC.GetAny(this, 18)) END Frameset; (* ---------- Panes, dual, nonextensible ---------- *) PROCEDURE (this: Panes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Panes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Panes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Panes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Panes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Panes) Item* (Index: INTEGER): Pane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPane(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Panes) Add* ((* optional *) SplitVertical: CtlT.Any): Pane, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SplitVertical, arg[0]); CtlC.CallParMethod(this, 3, arg, ret); RETURN ThisPane(CtlC.VarAny(ret)) END Add; (* ---------- Range, dual, nonextensible ---------- *) PROCEDURE (this: Range) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Text; PROCEDURE (this: Range) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTText; PROCEDURE (this: Range) FormattedText* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 2)) END FormattedText; PROCEDURE (this: Range) PUTFormattedText* (p1: Range), NEW; BEGIN CtlC.PutObj(this, 2, p1) END PUTFormattedText; PROCEDURE (this: Range) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Start; PROCEDURE (this: Range) PUTStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTStart; PROCEDURE (this: Range) End* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END End; PROCEDURE (this: Range) PUTEnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTEnd; PROCEDURE (this: Range) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 5)) END Font; PROCEDURE (this: Range) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 5, p1) END PUTFont; PROCEDURE (this: Range) Duplicate* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 6)) END Duplicate; PROCEDURE (this: Range) StoryType* (): WdStoryType, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END StoryType; PROCEDURE (this: Range) Tables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 50)) END Tables; PROCEDURE (this: Range) Words* (): Words, NEW; BEGIN RETURN ThisWords(CtlC.GetAny(this, 51)) END Words; PROCEDURE (this: Range) Sentences* (): Sentences, NEW; BEGIN RETURN ThisSentences(CtlC.GetAny(this, 52)) END Sentences; PROCEDURE (this: Range) Characters* (): Characters, NEW; BEGIN RETURN ThisCharacters(CtlC.GetAny(this, 53)) END Characters; PROCEDURE (this: Range) Footnotes* (): Footnotes, NEW; BEGIN RETURN ThisFootnotes(CtlC.GetAny(this, 54)) END Footnotes; PROCEDURE (this: Range) Endnotes* (): Endnotes, NEW; BEGIN RETURN ThisEndnotes(CtlC.GetAny(this, 55)) END Endnotes; PROCEDURE (this: Range) Comments* (): Comments, NEW; BEGIN RETURN ThisComments(CtlC.GetAny(this, 56)) END Comments; PROCEDURE (this: Range) Cells* (): Cells, NEW; BEGIN RETURN ThisCells(CtlC.GetAny(this, 57)) END Cells; PROCEDURE (this: Range) Sections* (): Sections, NEW; BEGIN RETURN ThisSections(CtlC.GetAny(this, 58)) END Sections; PROCEDURE (this: Range) Paragraphs* (): Paragraphs, NEW; BEGIN RETURN ThisParagraphs(CtlC.GetAny(this, 59)) END Paragraphs; PROCEDURE (this: Range) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Range) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Range) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 61)) END Shading; PROCEDURE (this: Range) TextRetrievalMode* (): TextRetrievalMode, NEW; BEGIN RETURN ThisTextRetrievalMode(CtlC.GetAny(this, 62)) END TextRetrievalMode; PROCEDURE (this: Range) PUTTextRetrievalMode* (p1: TextRetrievalMode), NEW; BEGIN CtlC.PutObj(this, 62, p1) END PUTTextRetrievalMode; PROCEDURE (this: Range) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 64)) END Fields; PROCEDURE (this: Range) FormFields* (): FormFields, NEW; BEGIN RETURN ThisFormFields(CtlC.GetAny(this, 65)) END FormFields; PROCEDURE (this: Range) Frames* (): Frames, NEW; BEGIN RETURN ThisFrames(CtlC.GetAny(this, 66)) END Frames; PROCEDURE (this: Range) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 1102)) END ParagraphFormat; PROCEDURE (this: Range) PUTParagraphFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 1102, p1) END PUTParagraphFormat; PROCEDURE (this: Range) ListFormat* (): ListFormat, NEW; BEGIN RETURN ThisListFormat(CtlC.GetAny(this, 68)) END ListFormat; PROCEDURE (this: Range) Bookmarks* (): Bookmarks, NEW; BEGIN RETURN ThisBookmarks(CtlC.GetAny(this, 75)) END Bookmarks; PROCEDURE (this: Range) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Range) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Range) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Range) Bold* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 130) END Bold; PROCEDURE (this: Range) PUTBold* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 130, p1) END PUTBold; PROCEDURE (this: Range) Italic* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END Italic; PROCEDURE (this: Range) PUTItalic* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTItalic; PROCEDURE (this: Range) Underline* (): WdUnderline, NEW; BEGIN RETURN CtlC.GetInt(this, 139) END Underline; PROCEDURE (this: Range) PUTUnderline* (p1: WdUnderline), NEW; BEGIN CtlC.PutInt(this, 139, p1) END PUTUnderline; PROCEDURE (this: Range) EmphasisMark* (): WdEmphasisMark, NEW; BEGIN RETURN CtlC.GetInt(this, 140) END EmphasisMark; PROCEDURE (this: Range) PUTEmphasisMark* (p1: WdEmphasisMark), NEW; BEGIN CtlC.PutInt(this, 140, p1) END PUTEmphasisMark; PROCEDURE (this: Range) DisableCharacterSpaceGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 141) END DisableCharacterSpaceGrid; PROCEDURE (this: Range) PUTDisableCharacterSpaceGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 141, p1) END PUTDisableCharacterSpaceGrid; PROCEDURE (this: Range) Revisions* (): Revisions, NEW; BEGIN RETURN ThisRevisions(CtlC.GetAny(this, 150)) END Revisions; PROCEDURE (this: Range) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 151) END Style; PROCEDURE (this: Range) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 151, p1) END PUTStyle; PROCEDURE (this: Range) StoryLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 152) END StoryLength; PROCEDURE (this: Range) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 153) END LanguageID; PROCEDURE (this: Range) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 153, p1) END PUTLanguageID; PROCEDURE (this: Range) SynonymInfo* (): SynonymInfo, NEW; BEGIN RETURN ThisSynonymInfo(CtlC.GetAny(this, 155)) END SynonymInfo; PROCEDURE (this: Range) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 156)) END Hyperlinks; PROCEDURE (this: Range) ListParagraphs* (): ListParagraphs, NEW; BEGIN RETURN ThisListParagraphs(CtlC.GetAny(this, 157)) END ListParagraphs; PROCEDURE (this: Range) Subdocuments* (): Subdocuments, NEW; BEGIN RETURN ThisSubdocuments(CtlC.GetAny(this, 159)) END Subdocuments; PROCEDURE (this: Range) GrammarChecked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 260) END GrammarChecked; PROCEDURE (this: Range) PUTGrammarChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 260, p1) END PUTGrammarChecked; PROCEDURE (this: Range) SpellingChecked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 261) END SpellingChecked; PROCEDURE (this: Range) PUTSpellingChecked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 261, p1) END PUTSpellingChecked; PROCEDURE (this: Range) HighlightColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 301) END HighlightColorIndex; PROCEDURE (this: Range) PUTHighlightColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 301, p1) END PUTHighlightColorIndex; PROCEDURE (this: Range) Columns* (): Columns, NEW; BEGIN RETURN ThisColumns(CtlC.GetAny(this, 302)) END Columns; PROCEDURE (this: Range) Rows* (): Rows, NEW; BEGIN RETURN ThisRows(CtlC.GetAny(this, 303)) END Rows; PROCEDURE (this: Range) CanEdit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 304) END CanEdit; PROCEDURE (this: Range) CanPaste* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 305) END CanPaste; PROCEDURE (this: Range) IsEndOfRowMark* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 307) END IsEndOfRowMark; PROCEDURE (this: Range) BookmarkID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 308) END BookmarkID; PROCEDURE (this: Range) PreviousBookmarkID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 309) END PreviousBookmarkID; PROCEDURE (this: Range) Find* (): Find, NEW; BEGIN RETURN ThisFind(CtlC.GetAny(this, 262)) END Find; PROCEDURE (this: Range) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1101)) END PageSetup; PROCEDURE (this: Range) PUTPageSetup* (p1: PageSetup), NEW; BEGIN CtlC.PutObj(this, 1101, p1) END PUTPageSetup; PROCEDURE (this: Range) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 311)) END ShapeRange; PROCEDURE (this: Range) Case* (): WdCharacterCase, NEW; BEGIN RETURN CtlC.GetInt(this, 312) END Case; PROCEDURE (this: Range) PUTCase* (p1: WdCharacterCase), NEW; BEGIN CtlC.PutInt(this, 312, p1) END PUTCase; PROCEDURE (this: Range) Information* (Type: WdInformation): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallGetMethod(this, 313, arg, ret); RETURN CtlC.VarAny(ret) END Information; PROCEDURE (this: Range) ReadabilityStatistics* (): ReadabilityStatistics, NEW; BEGIN RETURN ThisReadabilityStatistics(CtlC.GetAny(this, 314)) END ReadabilityStatistics; PROCEDURE (this: Range) GrammaticalErrors* (): ProofreadingErrors, NEW; BEGIN RETURN ThisProofreadingErrors(CtlC.GetAny(this, 315)) END GrammaticalErrors; PROCEDURE (this: Range) SpellingErrors* (): ProofreadingErrors, NEW; BEGIN RETURN ThisProofreadingErrors(CtlC.GetAny(this, 316)) END SpellingErrors; PROCEDURE (this: Range) Orientation* (): WdTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 317) END Orientation; PROCEDURE (this: Range) PUTOrientation* (p1: WdTextOrientation), NEW; BEGIN CtlC.PutInt(this, 317, p1) END PUTOrientation; PROCEDURE (this: Range) InlineShapes* (): InlineShapes, NEW; BEGIN RETURN ThisInlineShapes(CtlC.GetAny(this, 319)) END InlineShapes; PROCEDURE (this: Range) NextStoryRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 320)) END NextStoryRange; PROCEDURE (this: Range) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 321) END LanguageIDFarEast; PROCEDURE (this: Range) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 321, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Range) LanguageIDOther* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 322) END LanguageIDOther; PROCEDURE (this: Range) PUTLanguageIDOther* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 322, p1) END PUTLanguageIDOther; PROCEDURE (this: Range) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Range) SetRange* (Start: INTEGER; End: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(End, arg[0]); CtlC.CallParMethod(this, 100, arg, NIL); END SetRange; PROCEDURE (this: Range) Collapse* ((* optional *) Direction: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Direction, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END Collapse; PROCEDURE (this: Range) InsertBefore* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END InsertBefore; PROCEDURE (this: Range) InsertAfter* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END InsertAfter; PROCEDURE (this: Range) Next* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Next; PROCEDURE (this: Range) Previous* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 106, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Previous; PROCEDURE (this: Range) StartOf* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 107, arg, ret); RETURN CtlC.VarInt(ret) END StartOf; PROCEDURE (this: Range) EndOf* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 108, arg, ret); RETURN CtlC.VarInt(ret) END EndOf; PROCEDURE (this: Range) Move* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 109, arg, ret); RETURN CtlC.VarInt(ret) END Move; PROCEDURE (this: Range) MoveStart* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 110, arg, ret); RETURN CtlC.VarInt(ret) END MoveStart; PROCEDURE (this: Range) MoveEnd* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 111, arg, ret); RETURN CtlC.VarInt(ret) END MoveEnd; PROCEDURE (this: Range) MoveWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 112, arg, ret); RETURN CtlC.VarInt(ret) END MoveWhile; PROCEDURE (this: Range) MoveStartWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 113, arg, ret); RETURN CtlC.VarInt(ret) END MoveStartWhile; PROCEDURE (this: Range) MoveEndWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 114, arg, ret); RETURN CtlC.VarInt(ret) END MoveEndWhile; PROCEDURE (this: Range) MoveUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 115, arg, ret); RETURN CtlC.VarInt(ret) END MoveUntil; PROCEDURE (this: Range) MoveStartUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 116, arg, ret); RETURN CtlC.VarInt(ret) END MoveStartUntil; PROCEDURE (this: Range) MoveEndUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 117, arg, ret); RETURN CtlC.VarInt(ret) END MoveEndUntil; PROCEDURE (this: Range) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 119, NIL); END Cut; PROCEDURE (this: Range) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 120, NIL); END Copy; PROCEDURE (this: Range) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 121, NIL); END Paste; PROCEDURE (this: Range) InsertBreak* ((* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 122, arg, NIL); END InsertBreak; PROCEDURE (this: Range) InsertFile* (FileName: ARRAY OF CHAR; (* optional *) Range: CtlT.Any; ConfirmConversions: CtlT.Any; Link: CtlT.Any; Attachment: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[4]); CtlC.AnyVar(Range, arg[3]); CtlC.AnyVar(ConfirmConversions, arg[2]); CtlC.AnyVar(Link, arg[1]); CtlC.AnyVar(Attachment, arg[0]); CtlC.CallParMethod(this, 123, arg, NIL); END InsertFile; PROCEDURE (this: Range) InStory* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 125, arg, ret); RETURN CtlC.VarBool(ret) END InStory; PROCEDURE (this: Range) InRange* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 126, arg, ret); RETURN CtlC.VarBool(ret) END InRange; PROCEDURE (this: Range) Delete* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 127, arg, ret); RETURN CtlC.VarInt(ret) END Delete; PROCEDURE (this: Range) WholeStory* (), NEW; BEGIN CtlC.CallMethod(this, 128, NIL); END WholeStory; PROCEDURE (this: Range) Expand* ((* optional *) Unit: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[0]); CtlC.CallParMethod(this, 129, arg, ret); RETURN CtlC.VarInt(ret) END Expand; PROCEDURE (this: Range) InsertParagraph* (), NEW; BEGIN CtlC.CallMethod(this, 160, NIL); END InsertParagraph; PROCEDURE (this: Range) InsertParagraphAfter* (), NEW; BEGIN CtlC.CallMethod(this, 161, NIL); END InsertParagraphAfter; PROCEDURE (this: Range) ConvertToTableOld* ((* optional *) Separator: CtlT.Any; NumRows: CtlT.Any; NumColumns: CtlT.Any; InitialColumnWidth: CtlT.Any; Format: CtlT.Any; ApplyBorders: CtlT.Any; ApplyShading: CtlT.Any; ApplyFont: CtlT.Any; ApplyColor: CtlT.Any; ApplyHeadingRows: CtlT.Any; ApplyLastRow: CtlT.Any; ApplyFirstColumn: CtlT.Any; ApplyLastColumn: CtlT.Any; AutoFit: CtlT.Any): Table, NEW; VAR arg: ARRAY 14 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[13]); CtlC.AnyVar(NumRows, arg[12]); CtlC.AnyVar(NumColumns, arg[11]); CtlC.AnyVar(InitialColumnWidth, arg[10]); CtlC.AnyVar(Format, arg[9]); CtlC.AnyVar(ApplyBorders, arg[8]); CtlC.AnyVar(ApplyShading, arg[7]); CtlC.AnyVar(ApplyFont, arg[6]); CtlC.AnyVar(ApplyColor, arg[5]); CtlC.AnyVar(ApplyHeadingRows, arg[4]); CtlC.AnyVar(ApplyLastRow, arg[3]); CtlC.AnyVar(ApplyFirstColumn, arg[2]); CtlC.AnyVar(ApplyLastColumn, arg[1]); CtlC.AnyVar(AutoFit, arg[0]); CtlC.CallParMethod(this, 162, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END ConvertToTableOld; PROCEDURE (this: Range) InsertDateTimeOld* ((* optional *) DateTimeFormat: CtlT.Any; InsertAsField: CtlT.Any; InsertAsFullWidth: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(DateTimeFormat, arg[2]); CtlC.AnyVar(InsertAsField, arg[1]); CtlC.AnyVar(InsertAsFullWidth, arg[0]); CtlC.CallParMethod(this, 163, arg, NIL); END InsertDateTimeOld; PROCEDURE (this: Range) InsertSymbol* (CharacterNumber: INTEGER; (* optional *) Font: CtlT.Any; Unicode: CtlT.Any; Bias: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(CharacterNumber, arg[3]); CtlC.AnyVar(Font, arg[2]); CtlC.AnyVar(Unicode, arg[1]); CtlC.AnyVar(Bias, arg[0]); CtlC.CallParMethod(this, 164, arg, NIL); END InsertSymbol; PROCEDURE (this: Range) InsertCrossReference* (ReferenceType: CtlT.Any; ReferenceKind: WdReferenceKind; ReferenceItem: CtlT.Any; (* optional *) InsertAsHyperlink: CtlT.Any; IncludePosition: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(ReferenceType, arg[4]); CtlC.IntVar(ReferenceKind, arg[3]); CtlC.AnyVar(ReferenceItem, arg[2]); CtlC.AnyVar(InsertAsHyperlink, arg[1]); CtlC.AnyVar(IncludePosition, arg[0]); CtlC.CallParMethod(this, 165, arg, NIL); END InsertCrossReference; PROCEDURE (this: Range) InsertCaption* (Label: CtlT.Any; (* optional *) Title: CtlT.Any; TitleAutoText: CtlT.Any; Position: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Label, arg[3]); CtlC.AnyVar(Title, arg[2]); CtlC.AnyVar(TitleAutoText, arg[1]); CtlC.AnyVar(Position, arg[0]); CtlC.CallParMethod(this, 166, arg, NIL); END InsertCaption; PROCEDURE (this: Range) CopyAsPicture* (), NEW; BEGIN CtlC.CallMethod(this, 167, NIL); END CopyAsPicture; PROCEDURE (this: Range) SortOld* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; SortColumn: CtlT.Any; Separator: CtlT.Any; CaseSensitive: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[13]); CtlC.AnyVar(FieldNumber, arg[12]); CtlC.AnyVar(SortFieldType, arg[11]); CtlC.AnyVar(SortOrder, arg[10]); CtlC.AnyVar(FieldNumber2, arg[9]); CtlC.AnyVar(SortFieldType2, arg[8]); CtlC.AnyVar(SortOrder2, arg[7]); CtlC.AnyVar(FieldNumber3, arg[6]); CtlC.AnyVar(SortFieldType3, arg[5]); CtlC.AnyVar(SortOrder3, arg[4]); CtlC.AnyVar(SortColumn, arg[3]); CtlC.AnyVar(Separator, arg[2]); CtlC.AnyVar(CaseSensitive, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 168, arg, NIL); END SortOld; PROCEDURE (this: Range) SortAscending* (), NEW; BEGIN CtlC.CallMethod(this, 169, NIL); END SortAscending; PROCEDURE (this: Range) SortDescending* (), NEW; BEGIN CtlC.CallMethod(this, 170, NIL); END SortDescending; PROCEDURE (this: Range) IsEqual* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 171, arg, ret); RETURN CtlC.VarBool(ret) END IsEqual; PROCEDURE (this: Range) Calculate* (): SHORTREAL, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 172, ret); RETURN CtlC.VarSReal(ret) END Calculate; PROCEDURE (this: Range) GoTo* ((* optional *) What: CtlT.Any; Which: CtlT.Any; Count: CtlT.Any; Name: CtlT.Any): Range, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(What, arg[3]); CtlC.AnyVar(Which, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 173, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoTo; PROCEDURE (this: Range) GoToNext* (What: WdGoToItem): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(What, arg[0]); CtlC.CallParMethod(this, 174, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoToNext; PROCEDURE (this: Range) GoToPrevious* (What: WdGoToItem): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(What, arg[0]); CtlC.CallParMethod(this, 175, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoToPrevious; PROCEDURE (this: Range) PasteSpecial* ((* optional *) IconIndex: CtlT.Any; Link: CtlT.Any; Placement: CtlT.Any; DisplayAsIcon: CtlT.Any; DataType: CtlT.Any; IconFileName: CtlT.Any; IconLabel: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(IconIndex, arg[6]); CtlC.AnyVar(Link, arg[5]); CtlC.AnyVar(Placement, arg[4]); CtlC.AnyVar(DisplayAsIcon, arg[3]); CtlC.AnyVar(DataType, arg[2]); CtlC.AnyVar(IconFileName, arg[1]); CtlC.AnyVar(IconLabel, arg[0]); CtlC.CallParMethod(this, 176, arg, NIL); END PasteSpecial; PROCEDURE (this: Range) LookupNameProperties* (), NEW; BEGIN CtlC.CallMethod(this, 177, NIL); END LookupNameProperties; PROCEDURE (this: Range) ComputeStatistics* (Statistic: WdStatistic): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Statistic, arg[0]); CtlC.CallParMethod(this, 178, arg, ret); RETURN CtlC.VarInt(ret) END ComputeStatistics; PROCEDURE (this: Range) Relocate* (Direction: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Direction, arg[0]); CtlC.CallParMethod(this, 179, arg, NIL); END Relocate; PROCEDURE (this: Range) CheckSynonyms* (), NEW; BEGIN CtlC.CallMethod(this, 180, NIL); END CheckSynonyms; PROCEDURE (this: Range) SubscribeTo* (Edition: ARRAY OF CHAR; (* optional *) Format: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.StrVar(Edition, arg[1]); CtlC.AnyVar(Format, arg[0]); CtlC.CallParMethod(this, 181, arg, NIL); END SubscribeTo; PROCEDURE (this: Range) CreatePublisher* ((* optional *) Edition: CtlT.Any; ContainsPICT: CtlT.Any; ContainsRTF: CtlT.Any; ContainsText: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Edition, arg[3]); CtlC.AnyVar(ContainsPICT, arg[2]); CtlC.AnyVar(ContainsRTF, arg[1]); CtlC.AnyVar(ContainsText, arg[0]); CtlC.CallParMethod(this, 182, arg, NIL); END CreatePublisher; PROCEDURE (this: Range) InsertAutoText* (), NEW; BEGIN CtlC.CallMethod(this, 183, NIL); END InsertAutoText; PROCEDURE (this: Range) InsertDatabase* ((* optional *) Format: CtlT.Any; Style: CtlT.Any; LinkToSource: CtlT.Any; Connection: CtlT.Any; SQLStatement: CtlT.Any; SQLStatement1: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any; DataSource: CtlT.Any; From: CtlT.Any; To: CtlT.Any; IncludeFields: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[13]); CtlC.AnyVar(Style, arg[12]); CtlC.AnyVar(LinkToSource, arg[11]); CtlC.AnyVar(Connection, arg[10]); CtlC.AnyVar(SQLStatement, arg[9]); CtlC.AnyVar(SQLStatement1, arg[8]); CtlC.AnyVar(PasswordDocument, arg[7]); CtlC.AnyVar(PasswordTemplate, arg[6]); CtlC.AnyVar(WritePasswordDocument, arg[5]); CtlC.AnyVar(WritePasswordTemplate, arg[4]); CtlC.AnyVar(DataSource, arg[3]); CtlC.AnyVar(From, arg[2]); CtlC.AnyVar(To, arg[1]); CtlC.AnyVar(IncludeFields, arg[0]); CtlC.CallParMethod(this, 194, arg, NIL); END InsertDatabase; PROCEDURE (this: Range) AutoFormat* (), NEW; BEGIN CtlC.CallMethod(this, 195, NIL); END AutoFormat; PROCEDURE (this: Range) CheckGrammar* (), NEW; BEGIN CtlC.CallMethod(this, 204, NIL); END CheckGrammar; PROCEDURE (this: Range) CheckSpelling* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; AlwaysSuggest: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any), NEW; VAR arg: ARRAY 12 OF CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[11]); CtlC.AnyVar(IgnoreUppercase, arg[10]); CtlC.AnyVar(AlwaysSuggest, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 205, arg, NIL); END CheckSpelling; PROCEDURE (this: Range) GetSpellingSuggestions* ((* optional *) CustomDictionary: CtlT.Any; IgnoreUppercase: CtlT.Any; MainDictionary: CtlT.Any; SuggestionMode: CtlT.Any; CustomDictionary2: CtlT.Any; CustomDictionary3: CtlT.Any; CustomDictionary4: CtlT.Any; CustomDictionary5: CtlT.Any; CustomDictionary6: CtlT.Any; CustomDictionary7: CtlT.Any; CustomDictionary8: CtlT.Any; CustomDictionary9: CtlT.Any; CustomDictionary10: CtlT.Any): SpellingSuggestions, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(CustomDictionary, arg[12]); CtlC.AnyVar(IgnoreUppercase, arg[11]); CtlC.AnyVar(MainDictionary, arg[10]); CtlC.AnyVar(SuggestionMode, arg[9]); CtlC.AnyVar(CustomDictionary2, arg[8]); CtlC.AnyVar(CustomDictionary3, arg[7]); CtlC.AnyVar(CustomDictionary4, arg[6]); CtlC.AnyVar(CustomDictionary5, arg[5]); CtlC.AnyVar(CustomDictionary6, arg[4]); CtlC.AnyVar(CustomDictionary7, arg[3]); CtlC.AnyVar(CustomDictionary8, arg[2]); CtlC.AnyVar(CustomDictionary9, arg[1]); CtlC.AnyVar(CustomDictionary10, arg[0]); CtlC.CallParMethod(this, 209, arg, ret); RETURN ThisSpellingSuggestions(CtlC.VarAny(ret)) END GetSpellingSuggestions; PROCEDURE (this: Range) InsertParagraphBefore* (), NEW; BEGIN CtlC.CallMethod(this, 212, NIL); END InsertParagraphBefore; PROCEDURE (this: Range) NextSubdocument* (), NEW; BEGIN CtlC.CallMethod(this, 219, NIL); END NextSubdocument; PROCEDURE (this: Range) PreviousSubdocument* (), NEW; BEGIN CtlC.CallMethod(this, 220, NIL); END PreviousSubdocument; PROCEDURE (this: Range) ConvertHangulAndHanja* ((* optional *) ConversionsMode: CtlT.Any; FastConversion: CtlT.Any; CheckHangulEnding: CtlT.Any; EnableRecentOrdering: CtlT.Any; CustomDictionary: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(ConversionsMode, arg[4]); CtlC.AnyVar(FastConversion, arg[3]); CtlC.AnyVar(CheckHangulEnding, arg[2]); CtlC.AnyVar(EnableRecentOrdering, arg[1]); CtlC.AnyVar(CustomDictionary, arg[0]); CtlC.CallParMethod(this, 221, arg, NIL); END ConvertHangulAndHanja; PROCEDURE (this: Range) PasteAsNestedTable* (), NEW; BEGIN CtlC.CallMethod(this, 222, NIL); END PasteAsNestedTable; PROCEDURE (this: Range) ModifyEnclosure* (Style: CtlT.Any; (* optional *) Symbol: CtlT.Any; EnclosedText: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(Style, arg[2]); CtlC.AnyVar(Symbol, arg[1]); CtlC.AnyVar(EnclosedText, arg[0]); CtlC.CallParMethod(this, 223, arg, NIL); END ModifyEnclosure; PROCEDURE (this: Range) PhoneticGuide* (Text: ARRAY OF CHAR; Alignment: WdPhoneticGuideAlignmentType; Raise: INTEGER; FontSize: INTEGER; FontName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[4]); CtlC.IntVar(Alignment, arg[3]); CtlC.IntVar(Raise, arg[2]); CtlC.IntVar(FontSize, arg[1]); CtlC.StrVar(FontName, arg[0]); CtlC.CallParMethod(this, 224, arg, NIL); END PhoneticGuide; PROCEDURE (this: Range) InsertDateTime* ((* optional *) DateTimeFormat: CtlT.Any; InsertAsField: CtlT.Any; InsertAsFullWidth: CtlT.Any; DateLanguage: CtlT.Any; CalendarType: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(DateTimeFormat, arg[4]); CtlC.AnyVar(InsertAsField, arg[3]); CtlC.AnyVar(InsertAsFullWidth, arg[2]); CtlC.AnyVar(DateLanguage, arg[1]); CtlC.AnyVar(CalendarType, arg[0]); CtlC.CallParMethod(this, 444, arg, NIL); END InsertDateTime; PROCEDURE (this: Range) Sort* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; SortColumn: CtlT.Any; Separator: CtlT.Any; CaseSensitive: CtlT.Any; BidiSort: CtlT.Any; IgnoreThe: CtlT.Any; IgnoreKashida: CtlT.Any; IgnoreDiacritics: CtlT.Any; IgnoreHe: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 19 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[18]); CtlC.AnyVar(FieldNumber, arg[17]); CtlC.AnyVar(SortFieldType, arg[16]); CtlC.AnyVar(SortOrder, arg[15]); CtlC.AnyVar(FieldNumber2, arg[14]); CtlC.AnyVar(SortFieldType2, arg[13]); CtlC.AnyVar(SortOrder2, arg[12]); CtlC.AnyVar(FieldNumber3, arg[11]); CtlC.AnyVar(SortFieldType3, arg[10]); CtlC.AnyVar(SortOrder3, arg[9]); CtlC.AnyVar(SortColumn, arg[8]); CtlC.AnyVar(Separator, arg[7]); CtlC.AnyVar(CaseSensitive, arg[6]); CtlC.AnyVar(BidiSort, arg[5]); CtlC.AnyVar(IgnoreThe, arg[4]); CtlC.AnyVar(IgnoreKashida, arg[3]); CtlC.AnyVar(IgnoreDiacritics, arg[2]); CtlC.AnyVar(IgnoreHe, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 484, arg, NIL); END Sort; PROCEDURE (this: Range) DetectLanguage* (), NEW; BEGIN CtlC.CallMethod(this, 203, NIL); END DetectLanguage; PROCEDURE (this: Range) ConvertToTable* ((* optional *) Separator: CtlT.Any; NumRows: CtlT.Any; NumColumns: CtlT.Any; InitialColumnWidth: CtlT.Any; Format: CtlT.Any; ApplyBorders: CtlT.Any; ApplyShading: CtlT.Any; ApplyFont: CtlT.Any; ApplyColor: CtlT.Any; ApplyHeadingRows: CtlT.Any; ApplyLastRow: CtlT.Any; ApplyFirstColumn: CtlT.Any; ApplyLastColumn: CtlT.Any; AutoFit: CtlT.Any; AutoFitBehavior: CtlT.Any; DefaultTableBehavior: CtlT.Any): Table, NEW; VAR arg: ARRAY 16 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[15]); CtlC.AnyVar(NumRows, arg[14]); CtlC.AnyVar(NumColumns, arg[13]); CtlC.AnyVar(InitialColumnWidth, arg[12]); CtlC.AnyVar(Format, arg[11]); CtlC.AnyVar(ApplyBorders, arg[10]); CtlC.AnyVar(ApplyShading, arg[9]); CtlC.AnyVar(ApplyFont, arg[8]); CtlC.AnyVar(ApplyColor, arg[7]); CtlC.AnyVar(ApplyHeadingRows, arg[6]); CtlC.AnyVar(ApplyLastRow, arg[5]); CtlC.AnyVar(ApplyFirstColumn, arg[4]); CtlC.AnyVar(ApplyLastColumn, arg[3]); CtlC.AnyVar(AutoFit, arg[2]); CtlC.AnyVar(AutoFitBehavior, arg[1]); CtlC.AnyVar(DefaultTableBehavior, arg[0]); CtlC.CallParMethod(this, 498, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END ConvertToTable; PROCEDURE (this: Range) TCSCConverter* (wdTCSCConverterDirection: WdTCSCConverterDirection; CommonTerms: BOOLEAN; UseVariants: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(wdTCSCConverterDirection, arg[2]); CtlC.BoolVar(CommonTerms, arg[1]); CtlC.BoolVar(UseVariants, arg[0]); CtlC.CallParMethod(this, 499, arg, NIL); END TCSCConverter; PROCEDURE (this: Range) LanguageDetected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 263) END LanguageDetected; PROCEDURE (this: Range) PUTLanguageDetected* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 263, p1) END PUTLanguageDetected; PROCEDURE (this: Range) FitTextWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 264) END FitTextWidth; PROCEDURE (this: Range) PUTFitTextWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 264, p1) END PUTFitTextWidth; PROCEDURE (this: Range) HorizontalInVertical* (): WdHorizontalInVerticalType, NEW; BEGIN RETURN CtlC.GetInt(this, 265) END HorizontalInVertical; PROCEDURE (this: Range) PUTHorizontalInVertical* (p1: WdHorizontalInVerticalType), NEW; BEGIN CtlC.PutInt(this, 265, p1) END PUTHorizontalInVertical; PROCEDURE (this: Range) TwoLinesInOne* (): WdTwoLinesInOneType, NEW; BEGIN RETURN CtlC.GetInt(this, 266) END TwoLinesInOne; PROCEDURE (this: Range) PUTTwoLinesInOne* (p1: WdTwoLinesInOneType), NEW; BEGIN CtlC.PutInt(this, 266, p1) END PUTTwoLinesInOne; PROCEDURE (this: Range) CombineCharacters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 267) END CombineCharacters; PROCEDURE (this: Range) PUTCombineCharacters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 267, p1) END PUTCombineCharacters; PROCEDURE (this: Range) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 323) END NoProofing; PROCEDURE (this: Range) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 323, p1) END PUTNoProofing; PROCEDURE (this: Range) TopLevelTables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 324)) END TopLevelTables; PROCEDURE (this: Range) Scripts* (): CtlOffice.Scripts, NEW; BEGIN RETURN CtlOffice.ThisScripts(CtlC.GetAny(this, 325)) END Scripts; PROCEDURE (this: Range) CharacterWidth* (): WdCharacterWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 326) END CharacterWidth; PROCEDURE (this: Range) PUTCharacterWidth* (p1: WdCharacterWidth), NEW; BEGIN CtlC.PutInt(this, 326, p1) END PUTCharacterWidth; PROCEDURE (this: Range) Kana* (): WdKana, NEW; BEGIN RETURN CtlC.GetInt(this, 327) END Kana; PROCEDURE (this: Range) PUTKana* (p1: WdKana), NEW; BEGIN CtlC.PutInt(this, 327, p1) END PUTKana; PROCEDURE (this: Range) BoldBi* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 400) END BoldBi; PROCEDURE (this: Range) PUTBoldBi* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 400, p1) END PUTBoldBi; PROCEDURE (this: Range) ItalicBi* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 401) END ItalicBi; PROCEDURE (this: Range) PUTItalicBi* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 401, p1) END PUTItalicBi; PROCEDURE (this: Range) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 405) END ID; PROCEDURE (this: Range) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 405, p1) END PUTID; (* ---------- ListFormat, dual, nonextensible ---------- *) PROCEDURE (this: ListFormat) ListLevelNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 68) END ListLevelNumber; PROCEDURE (this: ListFormat) PUTListLevelNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 68, p1) END PUTListLevelNumber; PROCEDURE (this: ListFormat) List* (): List, NEW; BEGIN RETURN ThisList(CtlC.GetAny(this, 69)) END List; PROCEDURE (this: ListFormat) ListTemplate* (): ListTemplate, NEW; BEGIN RETURN ThisListTemplate(CtlC.GetAny(this, 70)) END ListTemplate; PROCEDURE (this: ListFormat) ListValue* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 71) END ListValue; PROCEDURE (this: ListFormat) SingleList* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 72) END SingleList; PROCEDURE (this: ListFormat) SingleListTemplate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 73) END SingleListTemplate; PROCEDURE (this: ListFormat) ListType* (): WdListType, NEW; BEGIN RETURN CtlC.GetInt(this, 74) END ListType; PROCEDURE (this: ListFormat) ListString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 75) END ListString; PROCEDURE (this: ListFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListFormat) CanContinuePreviousList* (listTemplate: ListTemplate): WdContinue, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[0]); CtlC.CallParMethod(this, 184, arg, ret); RETURN CtlC.VarInt(ret) END CanContinuePreviousList; PROCEDURE (this: ListFormat) RemoveNumbers* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 185, arg, NIL); END RemoveNumbers; PROCEDURE (this: ListFormat) ConvertNumbersToText* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 186, arg, NIL); END ConvertNumbersToText; PROCEDURE (this: ListFormat) CountNumberedItems* ((* optional *) NumberType: CtlT.Any; Level: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[1]); CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 187, arg, ret); RETURN CtlC.VarInt(ret) END CountNumberedItems; PROCEDURE (this: ListFormat) ApplyBulletDefaultOld* (), NEW; BEGIN CtlC.CallMethod(this, 188, NIL); END ApplyBulletDefaultOld; PROCEDURE (this: ListFormat) ApplyNumberDefaultOld* (), NEW; BEGIN CtlC.CallMethod(this, 189, NIL); END ApplyNumberDefaultOld; PROCEDURE (this: ListFormat) ApplyOutlineNumberDefaultOld* (), NEW; BEGIN CtlC.CallMethod(this, 190, NIL); END ApplyOutlineNumberDefaultOld; PROCEDURE (this: ListFormat) ApplyListTemplateOld* (listTemplate: ListTemplate; (* optional *) ContinuePreviousList: CtlT.Any; ApplyTo: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[2]); CtlC.AnyVar(ContinuePreviousList, arg[1]); CtlC.AnyVar(ApplyTo, arg[0]); CtlC.CallParMethod(this, 191, arg, NIL); END ApplyListTemplateOld; PROCEDURE (this: ListFormat) ListOutdent* (), NEW; BEGIN CtlC.CallMethod(this, 210, NIL); END ListOutdent; PROCEDURE (this: ListFormat) ListIndent* (), NEW; BEGIN CtlC.CallMethod(this, 211, NIL); END ListIndent; PROCEDURE (this: ListFormat) ApplyBulletDefault* ((* optional *) DefaultListBehavior: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(DefaultListBehavior, arg[0]); CtlC.CallParMethod(this, 212, arg, NIL); END ApplyBulletDefault; PROCEDURE (this: ListFormat) ApplyNumberDefault* ((* optional *) DefaultListBehavior: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(DefaultListBehavior, arg[0]); CtlC.CallParMethod(this, 213, arg, NIL); END ApplyNumberDefault; PROCEDURE (this: ListFormat) ApplyOutlineNumberDefault* ((* optional *) DefaultListBehavior: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(DefaultListBehavior, arg[0]); CtlC.CallParMethod(this, 214, arg, NIL); END ApplyOutlineNumberDefault; PROCEDURE (this: ListFormat) ApplyListTemplate* (listTemplate: ListTemplate; (* optional *) ContinuePreviousList: CtlT.Any; ApplyTo: CtlT.Any; DefaultListBehavior: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[3]); CtlC.AnyVar(ContinuePreviousList, arg[2]); CtlC.AnyVar(ApplyTo, arg[1]); CtlC.AnyVar(DefaultListBehavior, arg[0]); CtlC.CallParMethod(this, 215, arg, NIL); END ApplyListTemplate; (* ---------- Find, dual, nonextensible ---------- *) PROCEDURE (this: Find) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Find) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Find) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Find) Forward* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END Forward; PROCEDURE (this: Find) PUTForward* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTForward; PROCEDURE (this: Find) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 11)) END Font; PROCEDURE (this: Find) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 11, p1) END PUTFont; PROCEDURE (this: Find) Found* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END Found; PROCEDURE (this: Find) MatchAllWordForms* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END MatchAllWordForms; PROCEDURE (this: Find) PUTMatchAllWordForms* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTMatchAllWordForms; PROCEDURE (this: Find) MatchCase* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END MatchCase; PROCEDURE (this: Find) PUTMatchCase* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTMatchCase; PROCEDURE (this: Find) MatchWildcards* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 15) END MatchWildcards; PROCEDURE (this: Find) PUTMatchWildcards* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 15, p1) END PUTMatchWildcards; PROCEDURE (this: Find) MatchSoundsLike* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END MatchSoundsLike; PROCEDURE (this: Find) PUTMatchSoundsLike* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTMatchSoundsLike; PROCEDURE (this: Find) MatchWholeWord* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 17) END MatchWholeWord; PROCEDURE (this: Find) PUTMatchWholeWord* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 17, p1) END PUTMatchWholeWord; PROCEDURE (this: Find) MatchFuzzy* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 40) END MatchFuzzy; PROCEDURE (this: Find) PUTMatchFuzzy* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 40, p1) END PUTMatchFuzzy; PROCEDURE (this: Find) MatchByte* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 41) END MatchByte; PROCEDURE (this: Find) PUTMatchByte* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 41, p1) END PUTMatchByte; PROCEDURE (this: Find) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 18)) END ParagraphFormat; PROCEDURE (this: Find) PUTParagraphFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 18, p1) END PUTParagraphFormat; PROCEDURE (this: Find) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 19) END Style; PROCEDURE (this: Find) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 19, p1) END PUTStyle; PROCEDURE (this: Find) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END Text; PROCEDURE (this: Find) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 22, p1) END PUTText; PROCEDURE (this: Find) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END LanguageID; PROCEDURE (this: Find) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTLanguageID; PROCEDURE (this: Find) Highlight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 24) END Highlight; PROCEDURE (this: Find) PUTHighlight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 24, p1) END PUTHighlight; PROCEDURE (this: Find) Replacement* (): Replacement, NEW; BEGIN RETURN ThisReplacement(CtlC.GetAny(this, 25)) END Replacement; PROCEDURE (this: Find) Frame* (): Frame, NEW; BEGIN RETURN ThisFrame(CtlC.GetAny(this, 26)) END Frame; PROCEDURE (this: Find) Wrap* (): WdFindWrap, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END Wrap; PROCEDURE (this: Find) PUTWrap* (p1: WdFindWrap), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTWrap; PROCEDURE (this: Find) Format* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END Format; PROCEDURE (this: Find) PUTFormat* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTFormat; PROCEDURE (this: Find) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 29) END LanguageIDFarEast; PROCEDURE (this: Find) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 29, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Find) LanguageIDOther* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END LanguageIDOther; PROCEDURE (this: Find) PUTLanguageIDOther* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 60, p1) END PUTLanguageIDOther; PROCEDURE (this: Find) CorrectHangulEndings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 61) END CorrectHangulEndings; PROCEDURE (this: Find) PUTCorrectHangulEndings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 61, p1) END PUTCorrectHangulEndings; PROCEDURE (this: Find) ExecuteOld* ((* optional *) FindText: CtlT.Any; MatchCase: CtlT.Any; MatchWholeWord: CtlT.Any; MatchWildcards: CtlT.Any; MatchSoundsLike: CtlT.Any; MatchAllWordForms: CtlT.Any; Forward: CtlT.Any; Wrap: CtlT.Any; Format: CtlT.Any; ReplaceWith: CtlT.Any; Replace: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FindText, arg[10]); CtlC.AnyVar(MatchCase, arg[9]); CtlC.AnyVar(MatchWholeWord, arg[8]); CtlC.AnyVar(MatchWildcards, arg[7]); CtlC.AnyVar(MatchSoundsLike, arg[6]); CtlC.AnyVar(MatchAllWordForms, arg[5]); CtlC.AnyVar(Forward, arg[4]); CtlC.AnyVar(Wrap, arg[3]); CtlC.AnyVar(Format, arg[2]); CtlC.AnyVar(ReplaceWith, arg[1]); CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 30, arg, ret); RETURN CtlC.VarBool(ret) END ExecuteOld; PROCEDURE (this: Find) ClearFormatting* (), NEW; BEGIN CtlC.CallMethod(this, 31, NIL); END ClearFormatting; PROCEDURE (this: Find) SetAllFuzzyOptions* (), NEW; BEGIN CtlC.CallMethod(this, 32, NIL); END SetAllFuzzyOptions; PROCEDURE (this: Find) ClearAllFuzzyOptions* (), NEW; BEGIN CtlC.CallMethod(this, 33, NIL); END ClearAllFuzzyOptions; PROCEDURE (this: Find) Execute* ((* optional *) FindText: CtlT.Any; MatchCase: CtlT.Any; MatchWholeWord: CtlT.Any; MatchWildcards: CtlT.Any; MatchSoundsLike: CtlT.Any; MatchAllWordForms: CtlT.Any; Forward: CtlT.Any; Wrap: CtlT.Any; Format: CtlT.Any; ReplaceWith: CtlT.Any; Replace: CtlT.Any; MatchKashida: CtlT.Any; MatchDiacritics: CtlT.Any; MatchAlefHamza: CtlT.Any; MatchControl: CtlT.Any): BOOLEAN, NEW; VAR arg: ARRAY 15 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(FindText, arg[14]); CtlC.AnyVar(MatchCase, arg[13]); CtlC.AnyVar(MatchWholeWord, arg[12]); CtlC.AnyVar(MatchWildcards, arg[11]); CtlC.AnyVar(MatchSoundsLike, arg[10]); CtlC.AnyVar(MatchAllWordForms, arg[9]); CtlC.AnyVar(Forward, arg[8]); CtlC.AnyVar(Wrap, arg[7]); CtlC.AnyVar(Format, arg[6]); CtlC.AnyVar(ReplaceWith, arg[5]); CtlC.AnyVar(Replace, arg[4]); CtlC.AnyVar(MatchKashida, arg[3]); CtlC.AnyVar(MatchDiacritics, arg[2]); CtlC.AnyVar(MatchAlefHamza, arg[1]); CtlC.AnyVar(MatchControl, arg[0]); CtlC.CallParMethod(this, 444, arg, ret); RETURN CtlC.VarBool(ret) END Execute; PROCEDURE (this: Find) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 34) END NoProofing; PROCEDURE (this: Find) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 34, p1) END PUTNoProofing; PROCEDURE (this: Find) MatchKashida* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 100) END MatchKashida; PROCEDURE (this: Find) PUTMatchKashida* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 100, p1) END PUTMatchKashida; PROCEDURE (this: Find) MatchDiacritics* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 101) END MatchDiacritics; PROCEDURE (this: Find) PUTMatchDiacritics* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 101, p1) END PUTMatchDiacritics; PROCEDURE (this: Find) MatchAlefHamza* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 102) END MatchAlefHamza; PROCEDURE (this: Find) PUTMatchAlefHamza* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 102, p1) END PUTMatchAlefHamza; PROCEDURE (this: Find) MatchControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END MatchControl; PROCEDURE (this: Find) PUTMatchControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTMatchControl; (* ---------- Replacement, dual, nonextensible ---------- *) PROCEDURE (this: Replacement) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Replacement) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Replacement) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Replacement) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 10)) END Font; PROCEDURE (this: Replacement) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 10, p1) END PUTFont; PROCEDURE (this: Replacement) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 11)) END ParagraphFormat; PROCEDURE (this: Replacement) PUTParagraphFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 11, p1) END PUTParagraphFormat; PROCEDURE (this: Replacement) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 12) END Style; PROCEDURE (this: Replacement) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 12, p1) END PUTStyle; PROCEDURE (this: Replacement) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 15) END Text; PROCEDURE (this: Replacement) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 15, p1) END PUTText; PROCEDURE (this: Replacement) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END LanguageID; PROCEDURE (this: Replacement) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 16, p1) END PUTLanguageID; PROCEDURE (this: Replacement) Highlight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 17) END Highlight; PROCEDURE (this: Replacement) PUTHighlight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 17, p1) END PUTHighlight; PROCEDURE (this: Replacement) Frame* (): Frame, NEW; BEGIN RETURN ThisFrame(CtlC.GetAny(this, 18)) END Frame; PROCEDURE (this: Replacement) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 19) END LanguageIDFarEast; PROCEDURE (this: Replacement) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 19, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Replacement) ClearFormatting* (), NEW; BEGIN CtlC.CallMethod(this, 20, NIL); END ClearFormatting; PROCEDURE (this: Replacement) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 21) END NoProofing; PROCEDURE (this: Replacement) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 21, p1) END PUTNoProofing; (* ---------- Characters, dual, nonextensible ---------- *) PROCEDURE (this: Characters) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Characters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Characters) First* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 3)) END First; PROCEDURE (this: Characters) Last* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Last; PROCEDURE (this: Characters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Characters) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Characters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Characters) Item* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; (* ---------- Words, dual, nonextensible ---------- *) PROCEDURE (this: Words) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Words) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Words) First* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 3)) END First; PROCEDURE (this: Words) Last* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Last; PROCEDURE (this: Words) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Words) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Words) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Words) Item* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; (* ---------- Sentences, dual, nonextensible ---------- *) PROCEDURE (this: Sentences) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Sentences) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Sentences) First* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 3)) END First; PROCEDURE (this: Sentences) Last* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Last; PROCEDURE (this: Sentences) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Sentences) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Sentences) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Sentences) Item* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; (* ---------- Sections, dual, nonextensible ---------- *) PROCEDURE (this: Sections) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Sections) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Sections) First* (): Section, NEW; BEGIN RETURN ThisSection(CtlC.GetAny(this, 3)) END First; PROCEDURE (this: Sections) Last* (): Section, NEW; BEGIN RETURN ThisSection(CtlC.GetAny(this, 4)) END Last; PROCEDURE (this: Sections) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Sections) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Sections) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Sections) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1101)) END PageSetup; PROCEDURE (this: Sections) PUTPageSetup* (p1: PageSetup), NEW; BEGIN CtlC.PutObj(this, 1101, p1) END PUTPageSetup; PROCEDURE (this: Sections) Item* (Index: INTEGER): Section, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisSection(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Sections) Add* ((* optional *) Range: CtlT.Any; Start: CtlT.Any): Section, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[1]); CtlC.AnyVar(Start, arg[0]); CtlC.CallParMethod(this, 5, arg, ret); RETURN ThisSection(CtlC.VarAny(ret)) END Add; (* ---------- Section, dual, nonextensible ---------- *) PROCEDURE (this: Section) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: Section) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Section) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Section) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Section) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1101)) END PageSetup; PROCEDURE (this: Section) PUTPageSetup* (p1: PageSetup), NEW; BEGIN CtlC.PutObj(this, 1101, p1) END PUTPageSetup; PROCEDURE (this: Section) Headers* (): HeadersFooters, NEW; BEGIN RETURN ThisHeadersFooters(CtlC.GetAny(this, 121)) END Headers; PROCEDURE (this: Section) Footers* (): HeadersFooters, NEW; BEGIN RETURN ThisHeadersFooters(CtlC.GetAny(this, 122)) END Footers; PROCEDURE (this: Section) ProtectedForForms* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 123) END ProtectedForForms; PROCEDURE (this: Section) PUTProtectedForForms* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 123, p1) END PUTProtectedForForms; PROCEDURE (this: Section) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Index; PROCEDURE (this: Section) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Section) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; (* ---------- Paragraphs, dual, nonextensible ---------- *) PROCEDURE (this: Paragraphs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Paragraphs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Paragraphs) First* (): Paragraph, NEW; BEGIN RETURN ThisParagraph(CtlC.GetAny(this, 3)) END First; PROCEDURE (this: Paragraphs) Last* (): Paragraph, NEW; BEGIN RETURN ThisParagraph(CtlC.GetAny(this, 4)) END Last; PROCEDURE (this: Paragraphs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Paragraphs) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Paragraphs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Paragraphs) Format* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 1102)) END Format; PROCEDURE (this: Paragraphs) PUTFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 1102, p1) END PUTFormat; PROCEDURE (this: Paragraphs) TabStops* (): TabStops, NEW; BEGIN RETURN ThisTabStops(CtlC.GetAny(this, 1103)) END TabStops; PROCEDURE (this: Paragraphs) PUTTabStops* (p1: TabStops), NEW; BEGIN CtlC.PutObj(this, 1103, p1) END PUTTabStops; PROCEDURE (this: Paragraphs) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Paragraphs) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Paragraphs) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END Style; PROCEDURE (this: Paragraphs) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTStyle; PROCEDURE (this: Paragraphs) Alignment* (): WdParagraphAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Alignment; PROCEDURE (this: Paragraphs) PUTAlignment* (p1: WdParagraphAlignment), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAlignment; PROCEDURE (this: Paragraphs) KeepTogether* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END KeepTogether; PROCEDURE (this: Paragraphs) PUTKeepTogether* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTKeepTogether; PROCEDURE (this: Paragraphs) KeepWithNext* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END KeepWithNext; PROCEDURE (this: Paragraphs) PUTKeepWithNext* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTKeepWithNext; PROCEDURE (this: Paragraphs) PageBreakBefore* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PageBreakBefore; PROCEDURE (this: Paragraphs) PUTPageBreakBefore* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTPageBreakBefore; PROCEDURE (this: Paragraphs) NoLineNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END NoLineNumber; PROCEDURE (this: Paragraphs) PUTNoLineNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTNoLineNumber; PROCEDURE (this: Paragraphs) RightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END RightIndent; PROCEDURE (this: Paragraphs) PUTRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTRightIndent; PROCEDURE (this: Paragraphs) LeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END LeftIndent; PROCEDURE (this: Paragraphs) PUTLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTLeftIndent; PROCEDURE (this: Paragraphs) FirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END FirstLineIndent; PROCEDURE (this: Paragraphs) PUTFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 108, p1) END PUTFirstLineIndent; PROCEDURE (this: Paragraphs) LineSpacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END LineSpacing; PROCEDURE (this: Paragraphs) PUTLineSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTLineSpacing; PROCEDURE (this: Paragraphs) LineSpacingRule* (): WdLineSpacing, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END LineSpacingRule; PROCEDURE (this: Paragraphs) PUTLineSpacingRule* (p1: WdLineSpacing), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTLineSpacingRule; PROCEDURE (this: Paragraphs) SpaceBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END SpaceBefore; PROCEDURE (this: Paragraphs) PUTSpaceBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTSpaceBefore; PROCEDURE (this: Paragraphs) SpaceAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 112) END SpaceAfter; PROCEDURE (this: Paragraphs) PUTSpaceAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 112, p1) END PUTSpaceAfter; PROCEDURE (this: Paragraphs) Hyphenation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Hyphenation; PROCEDURE (this: Paragraphs) PUTHyphenation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTHyphenation; PROCEDURE (this: Paragraphs) WidowControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 114) END WidowControl; PROCEDURE (this: Paragraphs) PUTWidowControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 114, p1) END PUTWidowControl; PROCEDURE (this: Paragraphs) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 116)) END Shading; PROCEDURE (this: Paragraphs) FarEastLineBreakControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END FarEastLineBreakControl; PROCEDURE (this: Paragraphs) PUTFarEastLineBreakControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTFarEastLineBreakControl; PROCEDURE (this: Paragraphs) WordWrap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END WordWrap; PROCEDURE (this: Paragraphs) PUTWordWrap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 118, p1) END PUTWordWrap; PROCEDURE (this: Paragraphs) HangingPunctuation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 119) END HangingPunctuation; PROCEDURE (this: Paragraphs) PUTHangingPunctuation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 119, p1) END PUTHangingPunctuation; PROCEDURE (this: Paragraphs) HalfWidthPunctuationOnTopOfLine* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 120) END HalfWidthPunctuationOnTopOfLine; PROCEDURE (this: Paragraphs) PUTHalfWidthPunctuationOnTopOfLine* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 120, p1) END PUTHalfWidthPunctuationOnTopOfLine; PROCEDURE (this: Paragraphs) AddSpaceBetweenFarEastAndAlpha* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 121) END AddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: Paragraphs) PUTAddSpaceBetweenFarEastAndAlpha* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 121, p1) END PUTAddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: Paragraphs) AddSpaceBetweenFarEastAndDigit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END AddSpaceBetweenFarEastAndDigit; PROCEDURE (this: Paragraphs) PUTAddSpaceBetweenFarEastAndDigit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTAddSpaceBetweenFarEastAndDigit; PROCEDURE (this: Paragraphs) BaseLineAlignment* (): WdBaselineAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 123) END BaseLineAlignment; PROCEDURE (this: Paragraphs) PUTBaseLineAlignment* (p1: WdBaselineAlignment), NEW; BEGIN CtlC.PutInt(this, 123, p1) END PUTBaseLineAlignment; PROCEDURE (this: Paragraphs) AutoAdjustRightIndent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END AutoAdjustRightIndent; PROCEDURE (this: Paragraphs) PUTAutoAdjustRightIndent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 124, p1) END PUTAutoAdjustRightIndent; PROCEDURE (this: Paragraphs) DisableLineHeightGrid* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END DisableLineHeightGrid; PROCEDURE (this: Paragraphs) PUTDisableLineHeightGrid* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 125, p1) END PUTDisableLineHeightGrid; PROCEDURE (this: Paragraphs) OutlineLevel* (): WdOutlineLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END OutlineLevel; PROCEDURE (this: Paragraphs) PUTOutlineLevel* (p1: WdOutlineLevel), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTOutlineLevel; PROCEDURE (this: Paragraphs) Item* (Index: INTEGER): Paragraph, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisParagraph(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Paragraphs) Add* ((* optional *) Range: CtlT.Any): Paragraph, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 5, arg, ret); RETURN ThisParagraph(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Paragraphs) CloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END CloseUp; PROCEDURE (this: Paragraphs) OpenUp* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END OpenUp; PROCEDURE (this: Paragraphs) OpenOrCloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 303, NIL); END OpenOrCloseUp; PROCEDURE (this: Paragraphs) TabHangingIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 304, arg, NIL); END TabHangingIndent; PROCEDURE (this: Paragraphs) TabIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 306, arg, NIL); END TabIndent; PROCEDURE (this: Paragraphs) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 312, NIL); END Reset; PROCEDURE (this: Paragraphs) Space1* (), NEW; BEGIN CtlC.CallMethod(this, 313, NIL); END Space1; PROCEDURE (this: Paragraphs) Space15* (), NEW; BEGIN CtlC.CallMethod(this, 314, NIL); END Space15; PROCEDURE (this: Paragraphs) Space2* (), NEW; BEGIN CtlC.CallMethod(this, 315, NIL); END Space2; PROCEDURE (this: Paragraphs) IndentCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 320, arg, NIL); END IndentCharWidth; PROCEDURE (this: Paragraphs) IndentFirstLineCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 322, arg, NIL); END IndentFirstLineCharWidth; PROCEDURE (this: Paragraphs) OutlinePromote* (), NEW; BEGIN CtlC.CallMethod(this, 324, NIL); END OutlinePromote; PROCEDURE (this: Paragraphs) OutlineDemote* (), NEW; BEGIN CtlC.CallMethod(this, 325, NIL); END OutlineDemote; PROCEDURE (this: Paragraphs) OutlineDemoteToBody* (), NEW; BEGIN CtlC.CallMethod(this, 326, NIL); END OutlineDemoteToBody; PROCEDURE (this: Paragraphs) Indent* (), NEW; BEGIN CtlC.CallMethod(this, 333, NIL); END Indent; PROCEDURE (this: Paragraphs) Outdent* (), NEW; BEGIN CtlC.CallMethod(this, 334, NIL); END Outdent; PROCEDURE (this: Paragraphs) CharacterUnitRightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 126) END CharacterUnitRightIndent; PROCEDURE (this: Paragraphs) PUTCharacterUnitRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 126, p1) END PUTCharacterUnitRightIndent; PROCEDURE (this: Paragraphs) CharacterUnitLeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 127) END CharacterUnitLeftIndent; PROCEDURE (this: Paragraphs) PUTCharacterUnitLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 127, p1) END PUTCharacterUnitLeftIndent; PROCEDURE (this: Paragraphs) CharacterUnitFirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END CharacterUnitFirstLineIndent; PROCEDURE (this: Paragraphs) PUTCharacterUnitFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTCharacterUnitFirstLineIndent; PROCEDURE (this: Paragraphs) LineUnitBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 129) END LineUnitBefore; PROCEDURE (this: Paragraphs) PUTLineUnitBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 129, p1) END PUTLineUnitBefore; PROCEDURE (this: Paragraphs) LineUnitAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 130) END LineUnitAfter; PROCEDURE (this: Paragraphs) PUTLineUnitAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 130, p1) END PUTLineUnitAfter; PROCEDURE (this: Paragraphs) ReadingOrder* (): WdReadingOrder, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END ReadingOrder; PROCEDURE (this: Paragraphs) PUTReadingOrder* (p1: WdReadingOrder), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTReadingOrder; PROCEDURE (this: Paragraphs) SpaceBeforeAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 132) END SpaceBeforeAuto; PROCEDURE (this: Paragraphs) PUTSpaceBeforeAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 132, p1) END PUTSpaceBeforeAuto; PROCEDURE (this: Paragraphs) SpaceAfterAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END SpaceAfterAuto; PROCEDURE (this: Paragraphs) PUTSpaceAfterAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTSpaceAfterAuto; (* ---------- Paragraph, dual, nonextensible ---------- *) PROCEDURE (this: Paragraph) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: Paragraph) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Paragraph) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Paragraph) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Paragraph) Format* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 1102)) END Format; PROCEDURE (this: Paragraph) PUTFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 1102, p1) END PUTFormat; PROCEDURE (this: Paragraph) TabStops* (): TabStops, NEW; BEGIN RETURN ThisTabStops(CtlC.GetAny(this, 1103)) END TabStops; PROCEDURE (this: Paragraph) PUTTabStops* (p1: TabStops), NEW; BEGIN CtlC.PutObj(this, 1103, p1) END PUTTabStops; PROCEDURE (this: Paragraph) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Paragraph) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Paragraph) DropCap* (): DropCap, NEW; BEGIN RETURN ThisDropCap(CtlC.GetAny(this, 13)) END DropCap; PROCEDURE (this: Paragraph) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END Style; PROCEDURE (this: Paragraph) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTStyle; PROCEDURE (this: Paragraph) Alignment* (): WdParagraphAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Alignment; PROCEDURE (this: Paragraph) PUTAlignment* (p1: WdParagraphAlignment), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAlignment; PROCEDURE (this: Paragraph) KeepTogether* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END KeepTogether; PROCEDURE (this: Paragraph) PUTKeepTogether* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTKeepTogether; PROCEDURE (this: Paragraph) KeepWithNext* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END KeepWithNext; PROCEDURE (this: Paragraph) PUTKeepWithNext* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTKeepWithNext; PROCEDURE (this: Paragraph) PageBreakBefore* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PageBreakBefore; PROCEDURE (this: Paragraph) PUTPageBreakBefore* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTPageBreakBefore; PROCEDURE (this: Paragraph) NoLineNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END NoLineNumber; PROCEDURE (this: Paragraph) PUTNoLineNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTNoLineNumber; PROCEDURE (this: Paragraph) RightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END RightIndent; PROCEDURE (this: Paragraph) PUTRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTRightIndent; PROCEDURE (this: Paragraph) LeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END LeftIndent; PROCEDURE (this: Paragraph) PUTLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTLeftIndent; PROCEDURE (this: Paragraph) FirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END FirstLineIndent; PROCEDURE (this: Paragraph) PUTFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 108, p1) END PUTFirstLineIndent; PROCEDURE (this: Paragraph) LineSpacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END LineSpacing; PROCEDURE (this: Paragraph) PUTLineSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTLineSpacing; PROCEDURE (this: Paragraph) LineSpacingRule* (): WdLineSpacing, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END LineSpacingRule; PROCEDURE (this: Paragraph) PUTLineSpacingRule* (p1: WdLineSpacing), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTLineSpacingRule; PROCEDURE (this: Paragraph) SpaceBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END SpaceBefore; PROCEDURE (this: Paragraph) PUTSpaceBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTSpaceBefore; PROCEDURE (this: Paragraph) SpaceAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 112) END SpaceAfter; PROCEDURE (this: Paragraph) PUTSpaceAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 112, p1) END PUTSpaceAfter; PROCEDURE (this: Paragraph) Hyphenation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Hyphenation; PROCEDURE (this: Paragraph) PUTHyphenation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTHyphenation; PROCEDURE (this: Paragraph) WidowControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 114) END WidowControl; PROCEDURE (this: Paragraph) PUTWidowControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 114, p1) END PUTWidowControl; PROCEDURE (this: Paragraph) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 116)) END Shading; PROCEDURE (this: Paragraph) FarEastLineBreakControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END FarEastLineBreakControl; PROCEDURE (this: Paragraph) PUTFarEastLineBreakControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTFarEastLineBreakControl; PROCEDURE (this: Paragraph) WordWrap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END WordWrap; PROCEDURE (this: Paragraph) PUTWordWrap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 118, p1) END PUTWordWrap; PROCEDURE (this: Paragraph) HangingPunctuation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 119) END HangingPunctuation; PROCEDURE (this: Paragraph) PUTHangingPunctuation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 119, p1) END PUTHangingPunctuation; PROCEDURE (this: Paragraph) HalfWidthPunctuationOnTopOfLine* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 120) END HalfWidthPunctuationOnTopOfLine; PROCEDURE (this: Paragraph) PUTHalfWidthPunctuationOnTopOfLine* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 120, p1) END PUTHalfWidthPunctuationOnTopOfLine; PROCEDURE (this: Paragraph) AddSpaceBetweenFarEastAndAlpha* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 121) END AddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: Paragraph) PUTAddSpaceBetweenFarEastAndAlpha* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 121, p1) END PUTAddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: Paragraph) AddSpaceBetweenFarEastAndDigit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END AddSpaceBetweenFarEastAndDigit; PROCEDURE (this: Paragraph) PUTAddSpaceBetweenFarEastAndDigit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTAddSpaceBetweenFarEastAndDigit; PROCEDURE (this: Paragraph) BaseLineAlignment* (): WdBaselineAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 123) END BaseLineAlignment; PROCEDURE (this: Paragraph) PUTBaseLineAlignment* (p1: WdBaselineAlignment), NEW; BEGIN CtlC.PutInt(this, 123, p1) END PUTBaseLineAlignment; PROCEDURE (this: Paragraph) AutoAdjustRightIndent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END AutoAdjustRightIndent; PROCEDURE (this: Paragraph) PUTAutoAdjustRightIndent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 124, p1) END PUTAutoAdjustRightIndent; PROCEDURE (this: Paragraph) DisableLineHeightGrid* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END DisableLineHeightGrid; PROCEDURE (this: Paragraph) PUTDisableLineHeightGrid* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 125, p1) END PUTDisableLineHeightGrid; PROCEDURE (this: Paragraph) OutlineLevel* (): WdOutlineLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END OutlineLevel; PROCEDURE (this: Paragraph) PUTOutlineLevel* (p1: WdOutlineLevel), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTOutlineLevel; PROCEDURE (this: Paragraph) CloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END CloseUp; PROCEDURE (this: Paragraph) OpenUp* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END OpenUp; PROCEDURE (this: Paragraph) OpenOrCloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 303, NIL); END OpenOrCloseUp; PROCEDURE (this: Paragraph) TabHangingIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 304, arg, NIL); END TabHangingIndent; PROCEDURE (this: Paragraph) TabIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 306, arg, NIL); END TabIndent; PROCEDURE (this: Paragraph) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 312, NIL); END Reset; PROCEDURE (this: Paragraph) Space1* (), NEW; BEGIN CtlC.CallMethod(this, 313, NIL); END Space1; PROCEDURE (this: Paragraph) Space15* (), NEW; BEGIN CtlC.CallMethod(this, 314, NIL); END Space15; PROCEDURE (this: Paragraph) Space2* (), NEW; BEGIN CtlC.CallMethod(this, 315, NIL); END Space2; PROCEDURE (this: Paragraph) IndentCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 320, arg, NIL); END IndentCharWidth; PROCEDURE (this: Paragraph) IndentFirstLineCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 322, arg, NIL); END IndentFirstLineCharWidth; PROCEDURE (this: Paragraph) Next* ((* optional *) Count: CtlT.Any): Paragraph, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 324, arg, ret); RETURN ThisParagraph(CtlC.VarAny(ret)) END Next; PROCEDURE (this: Paragraph) Previous* ((* optional *) Count: CtlT.Any): Paragraph, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 325, arg, ret); RETURN ThisParagraph(CtlC.VarAny(ret)) END Previous; PROCEDURE (this: Paragraph) OutlinePromote* (), NEW; BEGIN CtlC.CallMethod(this, 326, NIL); END OutlinePromote; PROCEDURE (this: Paragraph) OutlineDemote* (), NEW; BEGIN CtlC.CallMethod(this, 327, NIL); END OutlineDemote; PROCEDURE (this: Paragraph) OutlineDemoteToBody* (), NEW; BEGIN CtlC.CallMethod(this, 328, NIL); END OutlineDemoteToBody; PROCEDURE (this: Paragraph) Indent* (), NEW; BEGIN CtlC.CallMethod(this, 333, NIL); END Indent; PROCEDURE (this: Paragraph) Outdent* (), NEW; BEGIN CtlC.CallMethod(this, 334, NIL); END Outdent; PROCEDURE (this: Paragraph) CharacterUnitRightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 126) END CharacterUnitRightIndent; PROCEDURE (this: Paragraph) PUTCharacterUnitRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 126, p1) END PUTCharacterUnitRightIndent; PROCEDURE (this: Paragraph) CharacterUnitLeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 127) END CharacterUnitLeftIndent; PROCEDURE (this: Paragraph) PUTCharacterUnitLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 127, p1) END PUTCharacterUnitLeftIndent; PROCEDURE (this: Paragraph) CharacterUnitFirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END CharacterUnitFirstLineIndent; PROCEDURE (this: Paragraph) PUTCharacterUnitFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTCharacterUnitFirstLineIndent; PROCEDURE (this: Paragraph) LineUnitBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 129) END LineUnitBefore; PROCEDURE (this: Paragraph) PUTLineUnitBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 129, p1) END PUTLineUnitBefore; PROCEDURE (this: Paragraph) LineUnitAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 130) END LineUnitAfter; PROCEDURE (this: Paragraph) PUTLineUnitAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 130, p1) END PUTLineUnitAfter; PROCEDURE (this: Paragraph) ReadingOrder* (): WdReadingOrder, NEW; BEGIN RETURN CtlC.GetInt(this, 203) END ReadingOrder; PROCEDURE (this: Paragraph) PUTReadingOrder* (p1: WdReadingOrder), NEW; BEGIN CtlC.PutInt(this, 203, p1) END PUTReadingOrder; PROCEDURE (this: Paragraph) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 204) END ID; PROCEDURE (this: Paragraph) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 204, p1) END PUTID; PROCEDURE (this: Paragraph) SpaceBeforeAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 132) END SpaceBeforeAuto; PROCEDURE (this: Paragraph) PUTSpaceBeforeAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 132, p1) END PUTSpaceBeforeAuto; PROCEDURE (this: Paragraph) SpaceAfterAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END SpaceAfterAuto; PROCEDURE (this: Paragraph) PUTSpaceAfterAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTSpaceAfterAuto; (* ---------- DropCap, dual, nonextensible ---------- *) PROCEDURE (this: DropCap) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: DropCap) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: DropCap) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: DropCap) Position* (): WdDropPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Position; PROCEDURE (this: DropCap) PUTPosition* (p1: WdDropPosition), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTPosition; PROCEDURE (this: DropCap) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 11) END FontName; PROCEDURE (this: DropCap) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 11, p1) END PUTFontName; PROCEDURE (this: DropCap) LinesToDrop* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END LinesToDrop; PROCEDURE (this: DropCap) PUTLinesToDrop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTLinesToDrop; PROCEDURE (this: DropCap) DistanceFromText* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 13) END DistanceFromText; PROCEDURE (this: DropCap) PUTDistanceFromText* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 13, p1) END PUTDistanceFromText; PROCEDURE (this: DropCap) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Clear; PROCEDURE (this: DropCap) Enable* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Enable; (* ---------- TabStops, dual, nonextensible ---------- *) PROCEDURE (this: TabStops) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TabStops) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: TabStops) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TabStops) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TabStops) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TabStops) Item* (Index: CtlT.Any): TabStop, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TabStops) Add* (Position: SHORTREAL; (* optional *) Alignment: CtlT.Any; Leader: CtlT.Any): TabStop, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Position, arg[2]); CtlC.AnyVar(Alignment, arg[1]); CtlC.AnyVar(Leader, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END Add; PROCEDURE (this: TabStops) ClearAll* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END ClearAll; PROCEDURE (this: TabStops) Before* (Position: SHORTREAL): TabStop, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Position, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END Before; PROCEDURE (this: TabStops) After* (Position: SHORTREAL): TabStop, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(Position, arg[0]); CtlC.CallParMethod(this, 103, arg, ret); RETURN ThisTabStop(CtlC.VarAny(ret)) END After; (* ---------- TabStop, dual, nonextensible ---------- *) PROCEDURE (this: TabStop) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TabStop) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TabStop) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TabStop) Alignment* (): WdTabAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Alignment; PROCEDURE (this: TabStop) PUTAlignment* (p1: WdTabAlignment), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAlignment; PROCEDURE (this: TabStop) Leader* (): WdTabLeader, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Leader; PROCEDURE (this: TabStop) PUTLeader* (p1: WdTabLeader), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTLeader; PROCEDURE (this: TabStop) Position* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Position; PROCEDURE (this: TabStop) PUTPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTPosition; PROCEDURE (this: TabStop) CustomTab* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END CustomTab; PROCEDURE (this: TabStop) Next* (): TabStop, NEW; BEGIN RETURN ThisTabStop(CtlC.GetAny(this, 104)) END Next; PROCEDURE (this: TabStop) Previous* (): TabStop, NEW; BEGIN RETURN ThisTabStop(CtlC.GetAny(this, 105)) END Previous; PROCEDURE (this: TabStop) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Clear; (* ---------- _ParagraphFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _ParagraphFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: _ParagraphFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _ParagraphFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _ParagraphFormat) Duplicate* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 10)) END Duplicate; PROCEDURE (this: _ParagraphFormat) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END Style; PROCEDURE (this: _ParagraphFormat) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTStyle; PROCEDURE (this: _ParagraphFormat) Alignment* (): WdParagraphAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Alignment; PROCEDURE (this: _ParagraphFormat) PUTAlignment* (p1: WdParagraphAlignment), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAlignment; PROCEDURE (this: _ParagraphFormat) KeepTogether* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END KeepTogether; PROCEDURE (this: _ParagraphFormat) PUTKeepTogether* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTKeepTogether; PROCEDURE (this: _ParagraphFormat) KeepWithNext* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END KeepWithNext; PROCEDURE (this: _ParagraphFormat) PUTKeepWithNext* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTKeepWithNext; PROCEDURE (this: _ParagraphFormat) PageBreakBefore* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PageBreakBefore; PROCEDURE (this: _ParagraphFormat) PUTPageBreakBefore* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTPageBreakBefore; PROCEDURE (this: _ParagraphFormat) NoLineNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END NoLineNumber; PROCEDURE (this: _ParagraphFormat) PUTNoLineNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTNoLineNumber; PROCEDURE (this: _ParagraphFormat) RightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END RightIndent; PROCEDURE (this: _ParagraphFormat) PUTRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTRightIndent; PROCEDURE (this: _ParagraphFormat) LeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END LeftIndent; PROCEDURE (this: _ParagraphFormat) PUTLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTLeftIndent; PROCEDURE (this: _ParagraphFormat) FirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END FirstLineIndent; PROCEDURE (this: _ParagraphFormat) PUTFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 108, p1) END PUTFirstLineIndent; PROCEDURE (this: _ParagraphFormat) LineSpacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END LineSpacing; PROCEDURE (this: _ParagraphFormat) PUTLineSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTLineSpacing; PROCEDURE (this: _ParagraphFormat) LineSpacingRule* (): WdLineSpacing, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END LineSpacingRule; PROCEDURE (this: _ParagraphFormat) PUTLineSpacingRule* (p1: WdLineSpacing), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTLineSpacingRule; PROCEDURE (this: _ParagraphFormat) SpaceBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END SpaceBefore; PROCEDURE (this: _ParagraphFormat) PUTSpaceBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTSpaceBefore; PROCEDURE (this: _ParagraphFormat) SpaceAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 112) END SpaceAfter; PROCEDURE (this: _ParagraphFormat) PUTSpaceAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 112, p1) END PUTSpaceAfter; PROCEDURE (this: _ParagraphFormat) Hyphenation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Hyphenation; PROCEDURE (this: _ParagraphFormat) PUTHyphenation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTHyphenation; PROCEDURE (this: _ParagraphFormat) WidowControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 114) END WidowControl; PROCEDURE (this: _ParagraphFormat) PUTWidowControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 114, p1) END PUTWidowControl; PROCEDURE (this: _ParagraphFormat) FarEastLineBreakControl* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END FarEastLineBreakControl; PROCEDURE (this: _ParagraphFormat) PUTFarEastLineBreakControl* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTFarEastLineBreakControl; PROCEDURE (this: _ParagraphFormat) WordWrap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END WordWrap; PROCEDURE (this: _ParagraphFormat) PUTWordWrap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 118, p1) END PUTWordWrap; PROCEDURE (this: _ParagraphFormat) HangingPunctuation* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 119) END HangingPunctuation; PROCEDURE (this: _ParagraphFormat) PUTHangingPunctuation* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 119, p1) END PUTHangingPunctuation; PROCEDURE (this: _ParagraphFormat) HalfWidthPunctuationOnTopOfLine* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 120) END HalfWidthPunctuationOnTopOfLine; PROCEDURE (this: _ParagraphFormat) PUTHalfWidthPunctuationOnTopOfLine* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 120, p1) END PUTHalfWidthPunctuationOnTopOfLine; PROCEDURE (this: _ParagraphFormat) AddSpaceBetweenFarEastAndAlpha* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 121) END AddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: _ParagraphFormat) PUTAddSpaceBetweenFarEastAndAlpha* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 121, p1) END PUTAddSpaceBetweenFarEastAndAlpha; PROCEDURE (this: _ParagraphFormat) AddSpaceBetweenFarEastAndDigit* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 122) END AddSpaceBetweenFarEastAndDigit; PROCEDURE (this: _ParagraphFormat) PUTAddSpaceBetweenFarEastAndDigit* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 122, p1) END PUTAddSpaceBetweenFarEastAndDigit; PROCEDURE (this: _ParagraphFormat) BaseLineAlignment* (): WdBaselineAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 123) END BaseLineAlignment; PROCEDURE (this: _ParagraphFormat) PUTBaseLineAlignment* (p1: WdBaselineAlignment), NEW; BEGIN CtlC.PutInt(this, 123, p1) END PUTBaseLineAlignment; PROCEDURE (this: _ParagraphFormat) AutoAdjustRightIndent* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END AutoAdjustRightIndent; PROCEDURE (this: _ParagraphFormat) PUTAutoAdjustRightIndent* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 124, p1) END PUTAutoAdjustRightIndent; PROCEDURE (this: _ParagraphFormat) DisableLineHeightGrid* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END DisableLineHeightGrid; PROCEDURE (this: _ParagraphFormat) PUTDisableLineHeightGrid* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 125, p1) END PUTDisableLineHeightGrid; PROCEDURE (this: _ParagraphFormat) TabStops* (): TabStops, NEW; BEGIN RETURN ThisTabStops(CtlC.GetAny(this, 1103)) END TabStops; PROCEDURE (this: _ParagraphFormat) PUTTabStops* (p1: TabStops), NEW; BEGIN CtlC.PutObj(this, 1103, p1) END PUTTabStops; PROCEDURE (this: _ParagraphFormat) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: _ParagraphFormat) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: _ParagraphFormat) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 1101)) END Shading; PROCEDURE (this: _ParagraphFormat) OutlineLevel* (): WdOutlineLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 202) END OutlineLevel; PROCEDURE (this: _ParagraphFormat) PUTOutlineLevel* (p1: WdOutlineLevel), NEW; BEGIN CtlC.PutInt(this, 202, p1) END PUTOutlineLevel; PROCEDURE (this: _ParagraphFormat) CloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END CloseUp; PROCEDURE (this: _ParagraphFormat) OpenUp* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END OpenUp; PROCEDURE (this: _ParagraphFormat) OpenOrCloseUp* (), NEW; BEGIN CtlC.CallMethod(this, 303, NIL); END OpenOrCloseUp; PROCEDURE (this: _ParagraphFormat) TabHangingIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 304, arg, NIL); END TabHangingIndent; PROCEDURE (this: _ParagraphFormat) TabIndent* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 306, arg, NIL); END TabIndent; PROCEDURE (this: _ParagraphFormat) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 312, NIL); END Reset; PROCEDURE (this: _ParagraphFormat) Space1* (), NEW; BEGIN CtlC.CallMethod(this, 313, NIL); END Space1; PROCEDURE (this: _ParagraphFormat) Space15* (), NEW; BEGIN CtlC.CallMethod(this, 314, NIL); END Space15; PROCEDURE (this: _ParagraphFormat) Space2* (), NEW; BEGIN CtlC.CallMethod(this, 315, NIL); END Space2; PROCEDURE (this: _ParagraphFormat) IndentCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 320, arg, NIL); END IndentCharWidth; PROCEDURE (this: _ParagraphFormat) IndentFirstLineCharWidth* (Count: SHORTINT), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SIntVar(Count, arg[0]); CtlC.CallParMethod(this, 322, arg, NIL); END IndentFirstLineCharWidth; PROCEDURE (this: _ParagraphFormat) CharacterUnitRightIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 126) END CharacterUnitRightIndent; PROCEDURE (this: _ParagraphFormat) PUTCharacterUnitRightIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 126, p1) END PUTCharacterUnitRightIndent; PROCEDURE (this: _ParagraphFormat) CharacterUnitLeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 127) END CharacterUnitLeftIndent; PROCEDURE (this: _ParagraphFormat) PUTCharacterUnitLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 127, p1) END PUTCharacterUnitLeftIndent; PROCEDURE (this: _ParagraphFormat) CharacterUnitFirstLineIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END CharacterUnitFirstLineIndent; PROCEDURE (this: _ParagraphFormat) PUTCharacterUnitFirstLineIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTCharacterUnitFirstLineIndent; PROCEDURE (this: _ParagraphFormat) LineUnitBefore* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 129) END LineUnitBefore; PROCEDURE (this: _ParagraphFormat) PUTLineUnitBefore* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 129, p1) END PUTLineUnitBefore; PROCEDURE (this: _ParagraphFormat) LineUnitAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 130) END LineUnitAfter; PROCEDURE (this: _ParagraphFormat) PUTLineUnitAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 130, p1) END PUTLineUnitAfter; PROCEDURE (this: _ParagraphFormat) ReadingOrder* (): WdReadingOrder, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END ReadingOrder; PROCEDURE (this: _ParagraphFormat) PUTReadingOrder* (p1: WdReadingOrder), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTReadingOrder; PROCEDURE (this: _ParagraphFormat) SpaceBeforeAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 132) END SpaceBeforeAuto; PROCEDURE (this: _ParagraphFormat) PUTSpaceBeforeAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 132, p1) END PUTSpaceBeforeAuto; PROCEDURE (this: _ParagraphFormat) SpaceAfterAuto* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END SpaceAfterAuto; PROCEDURE (this: _ParagraphFormat) PUTSpaceAfterAuto* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTSpaceAfterAuto; (* ---------- _Font, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _Font) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: _Font) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _Font) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _Font) Duplicate* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 10)) END Duplicate; PROCEDURE (this: _Font) Bold* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 130) END Bold; PROCEDURE (this: _Font) PUTBold* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 130, p1) END PUTBold; PROCEDURE (this: _Font) Italic* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END Italic; PROCEDURE (this: _Font) PUTItalic* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTItalic; PROCEDURE (this: _Font) Hidden* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 132) END Hidden; PROCEDURE (this: _Font) PUTHidden* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 132, p1) END PUTHidden; PROCEDURE (this: _Font) SmallCaps* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 133) END SmallCaps; PROCEDURE (this: _Font) PUTSmallCaps* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 133, p1) END PUTSmallCaps; PROCEDURE (this: _Font) AllCaps* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 134) END AllCaps; PROCEDURE (this: _Font) PUTAllCaps* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 134, p1) END PUTAllCaps; PROCEDURE (this: _Font) StrikeThrough* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 135) END StrikeThrough; PROCEDURE (this: _Font) PUTStrikeThrough* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 135, p1) END PUTStrikeThrough; PROCEDURE (this: _Font) DoubleStrikeThrough* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 136) END DoubleStrikeThrough; PROCEDURE (this: _Font) PUTDoubleStrikeThrough* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 136, p1) END PUTDoubleStrikeThrough; PROCEDURE (this: _Font) ColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 137) END ColorIndex; PROCEDURE (this: _Font) PUTColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 137, p1) END PUTColorIndex; PROCEDURE (this: _Font) Subscript* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 138) END Subscript; PROCEDURE (this: _Font) PUTSubscript* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 138, p1) END PUTSubscript; PROCEDURE (this: _Font) Superscript* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 139) END Superscript; PROCEDURE (this: _Font) PUTSuperscript* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 139, p1) END PUTSuperscript; PROCEDURE (this: _Font) Underline* (): WdUnderline, NEW; BEGIN RETURN CtlC.GetInt(this, 140) END Underline; PROCEDURE (this: _Font) PUTUnderline* (p1: WdUnderline), NEW; BEGIN CtlC.PutInt(this, 140, p1) END PUTUnderline; PROCEDURE (this: _Font) Size* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 141) END Size; PROCEDURE (this: _Font) PUTSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 141, p1) END PUTSize; PROCEDURE (this: _Font) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 142) END Name; PROCEDURE (this: _Font) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 142, p1) END PUTName; PROCEDURE (this: _Font) Position* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 143) END Position; PROCEDURE (this: _Font) PUTPosition* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 143, p1) END PUTPosition; PROCEDURE (this: _Font) Spacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 144) END Spacing; PROCEDURE (this: _Font) PUTSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 144, p1) END PUTSpacing; PROCEDURE (this: _Font) Scaling* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 145) END Scaling; PROCEDURE (this: _Font) PUTScaling* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 145, p1) END PUTScaling; PROCEDURE (this: _Font) Shadow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 146) END Shadow; PROCEDURE (this: _Font) PUTShadow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 146, p1) END PUTShadow; PROCEDURE (this: _Font) Outline* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 147) END Outline; PROCEDURE (this: _Font) PUTOutline* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 147, p1) END PUTOutline; PROCEDURE (this: _Font) Emboss* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 148) END Emboss; PROCEDURE (this: _Font) PUTEmboss* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 148, p1) END PUTEmboss; PROCEDURE (this: _Font) Kerning* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 149) END Kerning; PROCEDURE (this: _Font) PUTKerning* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 149, p1) END PUTKerning; PROCEDURE (this: _Font) Engrave* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 150) END Engrave; PROCEDURE (this: _Font) PUTEngrave* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 150, p1) END PUTEngrave; PROCEDURE (this: _Font) Animation* (): WdAnimation, NEW; BEGIN RETURN CtlC.GetInt(this, 151) END Animation; PROCEDURE (this: _Font) PUTAnimation* (p1: WdAnimation), NEW; BEGIN CtlC.PutInt(this, 151, p1) END PUTAnimation; PROCEDURE (this: _Font) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: _Font) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: _Font) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 153)) END Shading; PROCEDURE (this: _Font) EmphasisMark* (): WdEmphasisMark, NEW; BEGIN RETURN CtlC.GetInt(this, 154) END EmphasisMark; PROCEDURE (this: _Font) PUTEmphasisMark* (p1: WdEmphasisMark), NEW; BEGIN CtlC.PutInt(this, 154, p1) END PUTEmphasisMark; PROCEDURE (this: _Font) DisableCharacterSpaceGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 155) END DisableCharacterSpaceGrid; PROCEDURE (this: _Font) PUTDisableCharacterSpaceGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 155, p1) END PUTDisableCharacterSpaceGrid; PROCEDURE (this: _Font) NameFarEast* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 156) END NameFarEast; PROCEDURE (this: _Font) PUTNameFarEast* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 156, p1) END PUTNameFarEast; PROCEDURE (this: _Font) NameAscii* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 157) END NameAscii; PROCEDURE (this: _Font) PUTNameAscii* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 157, p1) END PUTNameAscii; PROCEDURE (this: _Font) NameOther* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 158) END NameOther; PROCEDURE (this: _Font) PUTNameOther* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 158, p1) END PUTNameOther; PROCEDURE (this: _Font) Grow* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Grow; PROCEDURE (this: _Font) Shrink* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Shrink; PROCEDURE (this: _Font) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Reset; PROCEDURE (this: _Font) SetAsTemplateDefault* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END SetAsTemplateDefault; PROCEDURE (this: _Font) Color* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 159) END Color; PROCEDURE (this: _Font) PUTColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 159, p1) END PUTColor; PROCEDURE (this: _Font) BoldBi* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 160) END BoldBi; PROCEDURE (this: _Font) PUTBoldBi* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 160, p1) END PUTBoldBi; PROCEDURE (this: _Font) ItalicBi* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 161) END ItalicBi; PROCEDURE (this: _Font) PUTItalicBi* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 161, p1) END PUTItalicBi; PROCEDURE (this: _Font) SizeBi* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 162) END SizeBi; PROCEDURE (this: _Font) PUTSizeBi* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 162, p1) END PUTSizeBi; PROCEDURE (this: _Font) NameBi* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 163) END NameBi; PROCEDURE (this: _Font) PUTNameBi* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 163, p1) END PUTNameBi; PROCEDURE (this: _Font) ColorIndexBi* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 164) END ColorIndexBi; PROCEDURE (this: _Font) PUTColorIndexBi* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 164, p1) END PUTColorIndexBi; PROCEDURE (this: _Font) DiacriticColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 165) END DiacriticColor; PROCEDURE (this: _Font) PUTDiacriticColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 165, p1) END PUTDiacriticColor; PROCEDURE (this: _Font) UnderlineColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 166) END UnderlineColor; PROCEDURE (this: _Font) PUTUnderlineColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 166, p1) END PUTUnderlineColor; (* ---------- Table, dual, nonextensible ---------- *) PROCEDURE (this: Table) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: Table) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Table) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Table) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Table) Columns* (): Columns, NEW; BEGIN RETURN ThisColumns(CtlC.GetAny(this, 100)) END Columns; PROCEDURE (this: Table) Rows* (): Rows, NEW; BEGIN RETURN ThisRows(CtlC.GetAny(this, 101)) END Rows; PROCEDURE (this: Table) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Table) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Table) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 104)) END Shading; PROCEDURE (this: Table) Uniform* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 105) END Uniform; PROCEDURE (this: Table) AutoFormatType* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END AutoFormatType; PROCEDURE (this: Table) Select* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Select; PROCEDURE (this: Table) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 9, NIL); END Delete; PROCEDURE (this: Table) SortOld* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; CaseSensitive: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 12 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[11]); CtlC.AnyVar(FieldNumber, arg[10]); CtlC.AnyVar(SortFieldType, arg[9]); CtlC.AnyVar(SortOrder, arg[8]); CtlC.AnyVar(FieldNumber2, arg[7]); CtlC.AnyVar(SortFieldType2, arg[6]); CtlC.AnyVar(SortOrder2, arg[5]); CtlC.AnyVar(FieldNumber3, arg[4]); CtlC.AnyVar(SortFieldType3, arg[3]); CtlC.AnyVar(SortOrder3, arg[2]); CtlC.AnyVar(CaseSensitive, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END SortOld; PROCEDURE (this: Table) SortAscending* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END SortAscending; PROCEDURE (this: Table) SortDescending* (), NEW; BEGIN CtlC.CallMethod(this, 13, NIL); END SortDescending; PROCEDURE (this: Table) AutoFormat* ((* optional *) Format: CtlT.Any; ApplyBorders: CtlT.Any; ApplyShading: CtlT.Any; ApplyFont: CtlT.Any; ApplyColor: CtlT.Any; ApplyHeadingRows: CtlT.Any; ApplyLastRow: CtlT.Any; ApplyFirstColumn: CtlT.Any; ApplyLastColumn: CtlT.Any; AutoFit: CtlT.Any), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.AnyVar(Format, arg[9]); CtlC.AnyVar(ApplyBorders, arg[8]); CtlC.AnyVar(ApplyShading, arg[7]); CtlC.AnyVar(ApplyFont, arg[6]); CtlC.AnyVar(ApplyColor, arg[5]); CtlC.AnyVar(ApplyHeadingRows, arg[4]); CtlC.AnyVar(ApplyLastRow, arg[3]); CtlC.AnyVar(ApplyFirstColumn, arg[2]); CtlC.AnyVar(ApplyLastColumn, arg[1]); CtlC.AnyVar(AutoFit, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END AutoFormat; PROCEDURE (this: Table) UpdateAutoFormat* (), NEW; BEGIN CtlC.CallMethod(this, 15, NIL); END UpdateAutoFormat; PROCEDURE (this: Table) ConvertToTextOld* ((* optional *) Separator: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToTextOld; PROCEDURE (this: Table) Cell* (Row: INTEGER; Column: INTEGER): Cell, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Row, arg[1]); CtlC.IntVar(Column, arg[0]); CtlC.CallParMethod(this, 17, arg, ret); RETURN ThisCell(CtlC.VarAny(ret)) END Cell; PROCEDURE (this: Table) Split* (BeforeRow: CtlT.Any): Table, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(BeforeRow, arg[0]); CtlC.CallParMethod(this, 18, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END Split; PROCEDURE (this: Table) ConvertToText* ((* optional *) Separator: CtlT.Any; NestedTables: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[1]); CtlC.AnyVar(NestedTables, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToText; PROCEDURE (this: Table) AutoFitBehavior* (Behavior: WdAutoFitBehavior), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Behavior, arg[0]); CtlC.CallParMethod(this, 20, arg, NIL); END AutoFitBehavior; PROCEDURE (this: Table) Sort* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; CaseSensitive: CtlT.Any; BidiSort: CtlT.Any; IgnoreThe: CtlT.Any; IgnoreKashida: CtlT.Any; IgnoreDiacritics: CtlT.Any; IgnoreHe: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 17 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[16]); CtlC.AnyVar(FieldNumber, arg[15]); CtlC.AnyVar(SortFieldType, arg[14]); CtlC.AnyVar(SortOrder, arg[13]); CtlC.AnyVar(FieldNumber2, arg[12]); CtlC.AnyVar(SortFieldType2, arg[11]); CtlC.AnyVar(SortOrder2, arg[10]); CtlC.AnyVar(FieldNumber3, arg[9]); CtlC.AnyVar(SortFieldType3, arg[8]); CtlC.AnyVar(SortOrder3, arg[7]); CtlC.AnyVar(CaseSensitive, arg[6]); CtlC.AnyVar(BidiSort, arg[5]); CtlC.AnyVar(IgnoreThe, arg[4]); CtlC.AnyVar(IgnoreKashida, arg[3]); CtlC.AnyVar(IgnoreDiacritics, arg[2]); CtlC.AnyVar(IgnoreHe, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 23, arg, NIL); END Sort; PROCEDURE (this: Table) Tables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 107)) END Tables; PROCEDURE (this: Table) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END NestingLevel; PROCEDURE (this: Table) AllowPageBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 109) END AllowPageBreaks; PROCEDURE (this: Table) PUTAllowPageBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 109, p1) END PUTAllowPageBreaks; PROCEDURE (this: Table) AllowAutoFit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 110) END AllowAutoFit; PROCEDURE (this: Table) PUTAllowAutoFit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 110, p1) END PUTAllowAutoFit; PROCEDURE (this: Table) PreferredWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END PreferredWidth; PROCEDURE (this: Table) PUTPreferredWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTPreferredWidth; PROCEDURE (this: Table) PreferredWidthType* (): WdPreferredWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END PreferredWidthType; PROCEDURE (this: Table) PUTPreferredWidthType* (p1: WdPreferredWidthType), NEW; BEGIN CtlC.PutInt(this, 112, p1) END PUTPreferredWidthType; PROCEDURE (this: Table) TopPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END TopPadding; PROCEDURE (this: Table) PUTTopPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTTopPadding; PROCEDURE (this: Table) BottomPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 114) END BottomPadding; PROCEDURE (this: Table) PUTBottomPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 114, p1) END PUTBottomPadding; PROCEDURE (this: Table) LeftPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 115) END LeftPadding; PROCEDURE (this: Table) PUTLeftPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 115, p1) END PUTLeftPadding; PROCEDURE (this: Table) RightPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 116) END RightPadding; PROCEDURE (this: Table) PUTRightPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 116, p1) END PUTRightPadding; PROCEDURE (this: Table) Spacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Spacing; PROCEDURE (this: Table) PUTSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTSpacing; PROCEDURE (this: Table) TableDirection* (): WdTableDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 118) END TableDirection; PROCEDURE (this: Table) PUTTableDirection* (p1: WdTableDirection), NEW; BEGIN CtlC.PutInt(this, 118, p1) END PUTTableDirection; PROCEDURE (this: Table) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 119) END ID; PROCEDURE (this: Table) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 119, p1) END PUTID; (* ---------- Row, dual, nonextensible ---------- *) PROCEDURE (this: Row) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: Row) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Row) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Row) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Row) AllowBreakAcrossPages* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END AllowBreakAcrossPages; PROCEDURE (this: Row) PUTAllowBreakAcrossPages* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTAllowBreakAcrossPages; PROCEDURE (this: Row) Alignment* (): WdRowAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Alignment; PROCEDURE (this: Row) PUTAlignment* (p1: WdRowAlignment), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTAlignment; PROCEDURE (this: Row) HeadingFormat* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END HeadingFormat; PROCEDURE (this: Row) PUTHeadingFormat* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTHeadingFormat; PROCEDURE (this: Row) SpaceBetweenColumns* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END SpaceBetweenColumns; PROCEDURE (this: Row) PUTSpaceBetweenColumns* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTSpaceBetweenColumns; PROCEDURE (this: Row) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END Height; PROCEDURE (this: Row) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTHeight; PROCEDURE (this: Row) HeightRule* (): WdRowHeightRule, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END HeightRule; PROCEDURE (this: Row) PUTHeightRule* (p1: WdRowHeightRule), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTHeightRule; PROCEDURE (this: Row) LeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 9) END LeftIndent; PROCEDURE (this: Row) PUTLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 9, p1) END PUTLeftIndent; PROCEDURE (this: Row) IsLast* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END IsLast; PROCEDURE (this: Row) IsFirst* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END IsFirst; PROCEDURE (this: Row) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END Index; PROCEDURE (this: Row) Cells* (): Cells, NEW; BEGIN RETURN ThisCells(CtlC.GetAny(this, 100)) END Cells; PROCEDURE (this: Row) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Row) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Row) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 103)) END Shading; PROCEDURE (this: Row) Next* (): Row, NEW; BEGIN RETURN ThisRow(CtlC.GetAny(this, 104)) END Next; PROCEDURE (this: Row) Previous* (): Row, NEW; BEGIN RETURN ThisRow(CtlC.GetAny(this, 105)) END Previous; PROCEDURE (this: Row) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Row) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Delete; PROCEDURE (this: Row) SetLeftIndent* (LeftIndent: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(LeftIndent, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END SetLeftIndent; PROCEDURE (this: Row) SetHeight* (RowHeight: SHORTREAL; HeightRule: WdRowHeightRule), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(RowHeight, arg[1]); CtlC.IntVar(HeightRule, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END SetHeight; PROCEDURE (this: Row) ConvertToTextOld* ((* optional *) Separator: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToTextOld; PROCEDURE (this: Row) ConvertToText* ((* optional *) Separator: CtlT.Any; NestedTables: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[1]); CtlC.AnyVar(NestedTables, arg[0]); CtlC.CallParMethod(this, 18, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToText; PROCEDURE (this: Row) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END NestingLevel; PROCEDURE (this: Row) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END ID; PROCEDURE (this: Row) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTID; (* ---------- Column, dual, nonextensible ---------- *) PROCEDURE (this: Column) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Column) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Column) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Column) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 3) END Width; PROCEDURE (this: Column) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 3, p1) END PUTWidth; PROCEDURE (this: Column) IsFirst* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END IsFirst; PROCEDURE (this: Column) IsLast* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END IsLast; PROCEDURE (this: Column) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Index; PROCEDURE (this: Column) Cells* (): Cells, NEW; BEGIN RETURN ThisCells(CtlC.GetAny(this, 100)) END Cells; PROCEDURE (this: Column) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Column) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Column) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 102)) END Shading; PROCEDURE (this: Column) Next* (): Column, NEW; BEGIN RETURN ThisColumn(CtlC.GetAny(this, 103)) END Next; PROCEDURE (this: Column) Previous* (): Column, NEW; BEGIN RETURN ThisColumn(CtlC.GetAny(this, 104)) END Previous; PROCEDURE (this: Column) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Column) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Delete; PROCEDURE (this: Column) SetWidth* (ColumnWidth: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(ColumnWidth, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 201, arg, NIL); END SetWidth; PROCEDURE (this: Column) AutoFit* (), NEW; BEGIN CtlC.CallMethod(this, 202, NIL); END AutoFit; PROCEDURE (this: Column) SortOld* ((* optional *) ExcludeHeader: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; CaseSensitive: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[4]); CtlC.AnyVar(SortFieldType, arg[3]); CtlC.AnyVar(SortOrder, arg[2]); CtlC.AnyVar(CaseSensitive, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END SortOld; PROCEDURE (this: Column) Sort* ((* optional *) ExcludeHeader: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; CaseSensitive: CtlT.Any; BidiSort: CtlT.Any; IgnoreThe: CtlT.Any; IgnoreKashida: CtlT.Any; IgnoreDiacritics: CtlT.Any; IgnoreHe: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[9]); CtlC.AnyVar(SortFieldType, arg[8]); CtlC.AnyVar(SortOrder, arg[7]); CtlC.AnyVar(CaseSensitive, arg[6]); CtlC.AnyVar(BidiSort, arg[5]); CtlC.AnyVar(IgnoreThe, arg[4]); CtlC.AnyVar(IgnoreKashida, arg[3]); CtlC.AnyVar(IgnoreDiacritics, arg[2]); CtlC.AnyVar(IgnoreHe, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 204, arg, NIL); END Sort; PROCEDURE (this: Column) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END NestingLevel; PROCEDURE (this: Column) PreferredWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END PreferredWidth; PROCEDURE (this: Column) PUTPreferredWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTPreferredWidth; PROCEDURE (this: Column) PreferredWidthType* (): WdPreferredWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PreferredWidthType; PROCEDURE (this: Column) PUTPreferredWidthType* (p1: WdPreferredWidthType), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPreferredWidthType; (* ---------- Cell, dual, nonextensible ---------- *) PROCEDURE (this: Cell) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: Cell) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Cell) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Cell) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Cell) RowIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END RowIndex; PROCEDURE (this: Cell) ColumnIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END ColumnIndex; PROCEDURE (this: Cell) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END Width; PROCEDURE (this: Cell) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTWidth; PROCEDURE (this: Cell) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END Height; PROCEDURE (this: Cell) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTHeight; PROCEDURE (this: Cell) HeightRule* (): WdRowHeightRule, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END HeightRule; PROCEDURE (this: Cell) PUTHeightRule* (p1: WdRowHeightRule), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTHeightRule; PROCEDURE (this: Cell) VerticalAlignment* (): WdCellVerticalAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 1104) END VerticalAlignment; PROCEDURE (this: Cell) PUTVerticalAlignment* (p1: WdCellVerticalAlignment), NEW; BEGIN CtlC.PutInt(this, 1104, p1) END PUTVerticalAlignment; PROCEDURE (this: Cell) Column* (): Column, NEW; BEGIN RETURN ThisColumn(CtlC.GetAny(this, 101)) END Column; PROCEDURE (this: Cell) Row* (): Row, NEW; BEGIN RETURN ThisRow(CtlC.GetAny(this, 102)) END Row; PROCEDURE (this: Cell) Next* (): Cell, NEW; BEGIN RETURN ThisCell(CtlC.GetAny(this, 103)) END Next; PROCEDURE (this: Cell) Previous* (): Cell, NEW; BEGIN RETURN ThisCell(CtlC.GetAny(this, 104)) END Previous; PROCEDURE (this: Cell) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 105)) END Shading; PROCEDURE (this: Cell) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Cell) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Cell) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Cell) Delete* ((* optional *) ShiftCells: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ShiftCells, arg[0]); CtlC.CallParMethod(this, 200, arg, NIL); END Delete; PROCEDURE (this: Cell) Formula* ((* optional *) Formula: CtlT.Any; NumFormat: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Formula, arg[1]); CtlC.AnyVar(NumFormat, arg[0]); CtlC.CallParMethod(this, 201, arg, NIL); END Formula; PROCEDURE (this: Cell) SetWidth* (ColumnWidth: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(ColumnWidth, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END SetWidth; PROCEDURE (this: Cell) SetHeight* (RowHeight: CtlT.Any; HeightRule: WdRowHeightRule), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowHeight, arg[1]); CtlC.IntVar(HeightRule, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END SetHeight; PROCEDURE (this: Cell) Merge* (MergeTo: Cell), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(MergeTo, arg[0]); CtlC.CallParMethod(this, 204, arg, NIL); END Merge; PROCEDURE (this: Cell) Split* ((* optional *) NumRows: CtlT.Any; NumColumns: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[1]); CtlC.AnyVar(NumColumns, arg[0]); CtlC.CallParMethod(this, 205, arg, NIL); END Split; PROCEDURE (this: Cell) AutoSum* (), NEW; BEGIN CtlC.CallMethod(this, 206, NIL); END AutoSum; PROCEDURE (this: Cell) Tables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 106)) END Tables; PROCEDURE (this: Cell) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END NestingLevel; PROCEDURE (this: Cell) WordWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 108) END WordWrap; PROCEDURE (this: Cell) PUTWordWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 108, p1) END PUTWordWrap; PROCEDURE (this: Cell) PreferredWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END PreferredWidth; PROCEDURE (this: Cell) PUTPreferredWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTPreferredWidth; PROCEDURE (this: Cell) FitText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 110) END FitText; PROCEDURE (this: Cell) PUTFitText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 110, p1) END PUTFitText; PROCEDURE (this: Cell) TopPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END TopPadding; PROCEDURE (this: Cell) PUTTopPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTopPadding; PROCEDURE (this: Cell) BottomPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 112) END BottomPadding; PROCEDURE (this: Cell) PUTBottomPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 112, p1) END PUTBottomPadding; PROCEDURE (this: Cell) LeftPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END LeftPadding; PROCEDURE (this: Cell) PUTLeftPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTLeftPadding; PROCEDURE (this: Cell) RightPadding* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 114) END RightPadding; PROCEDURE (this: Cell) PUTRightPadding* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 114, p1) END PUTRightPadding; PROCEDURE (this: Cell) ID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END ID; PROCEDURE (this: Cell) PUTID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTID; PROCEDURE (this: Cell) PreferredWidthType* (): WdPreferredWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 116) END PreferredWidthType; PROCEDURE (this: Cell) PUTPreferredWidthType* (p1: WdPreferredWidthType), NEW; BEGIN CtlC.PutInt(this, 116, p1) END PUTPreferredWidthType; (* ---------- Tables, dual, nonextensible ---------- *) PROCEDURE (this: Tables) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Tables) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Tables) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Tables) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Tables) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Tables) Item* (Index: INTEGER): Table, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Tables) AddOld* (range: Range; NumRows: INTEGER; NumColumns: INTEGER): Table, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[2]); CtlC.IntVar(NumRows, arg[1]); CtlC.IntVar(NumColumns, arg[0]); CtlC.CallParMethod(this, 4, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END AddOld; PROCEDURE (this: Tables) Add* (range: Range; NumRows: INTEGER; NumColumns: INTEGER; (* optional *) DefaultTableBehavior: CtlT.Any; AutoFitBehavior: CtlT.Any): Table, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[4]); CtlC.IntVar(NumRows, arg[3]); CtlC.IntVar(NumColumns, arg[2]); CtlC.AnyVar(DefaultTableBehavior, arg[1]); CtlC.AnyVar(AutoFitBehavior, arg[0]); CtlC.CallParMethod(this, 200, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Tables) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END NestingLevel; (* ---------- Rows, dual, nonextensible ---------- *) PROCEDURE (this: Rows) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Rows) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Rows) AllowBreakAcrossPages* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END AllowBreakAcrossPages; PROCEDURE (this: Rows) PUTAllowBreakAcrossPages* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTAllowBreakAcrossPages; PROCEDURE (this: Rows) Alignment* (): WdRowAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Alignment; PROCEDURE (this: Rows) PUTAlignment* (p1: WdRowAlignment), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTAlignment; PROCEDURE (this: Rows) HeadingFormat* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END HeadingFormat; PROCEDURE (this: Rows) PUTHeadingFormat* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTHeadingFormat; PROCEDURE (this: Rows) SpaceBetweenColumns* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END SpaceBetweenColumns; PROCEDURE (this: Rows) PUTSpaceBetweenColumns* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTSpaceBetweenColumns; PROCEDURE (this: Rows) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END Height; PROCEDURE (this: Rows) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTHeight; PROCEDURE (this: Rows) HeightRule* (): WdRowHeightRule, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END HeightRule; PROCEDURE (this: Rows) PUTHeightRule* (p1: WdRowHeightRule), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTHeightRule; PROCEDURE (this: Rows) LeftIndent* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 9) END LeftIndent; PROCEDURE (this: Rows) PUTLeftIndent* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 9, p1) END PUTLeftIndent; PROCEDURE (this: Rows) First* (): Row, NEW; BEGIN RETURN ThisRow(CtlC.GetAny(this, 10)) END First; PROCEDURE (this: Rows) Last* (): Row, NEW; BEGIN RETURN ThisRow(CtlC.GetAny(this, 11)) END Last; PROCEDURE (this: Rows) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Rows) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Rows) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Rows) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Rows) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Rows) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 102)) END Shading; PROCEDURE (this: Rows) Item* (Index: INTEGER): Row, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRow(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Rows) Add* ((* optional *) BeforeRow: CtlT.Any): Row, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(BeforeRow, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisRow(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Rows) Select* (), NEW; BEGIN CtlC.CallMethod(this, 199, NIL); END Select; PROCEDURE (this: Rows) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Delete; PROCEDURE (this: Rows) SetLeftIndent* (LeftIndent: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(LeftIndent, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END SetLeftIndent; PROCEDURE (this: Rows) SetHeight* (RowHeight: SHORTREAL; HeightRule: WdRowHeightRule), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(RowHeight, arg[1]); CtlC.IntVar(HeightRule, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END SetHeight; PROCEDURE (this: Rows) ConvertToTextOld* ((* optional *) Separator: CtlT.Any): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToTextOld; PROCEDURE (this: Rows) DistributeHeight* (), NEW; BEGIN CtlC.CallMethod(this, 206, NIL); END DistributeHeight; PROCEDURE (this: Rows) ConvertToText* ((* optional *) Separator: CtlT.Any; NestedTables: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[1]); CtlC.AnyVar(NestedTables, arg[0]); CtlC.CallParMethod(this, 210, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END ConvertToText; PROCEDURE (this: Rows) WrapAroundText* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END WrapAroundText; PROCEDURE (this: Rows) PUTWrapAroundText* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTWrapAroundText; PROCEDURE (this: Rows) DistanceTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 13) END DistanceTop; PROCEDURE (this: Rows) PUTDistanceTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 13, p1) END PUTDistanceTop; PROCEDURE (this: Rows) DistanceBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 14) END DistanceBottom; PROCEDURE (this: Rows) PUTDistanceBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 14, p1) END PUTDistanceBottom; PROCEDURE (this: Rows) DistanceLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 20) END DistanceLeft; PROCEDURE (this: Rows) PUTDistanceLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 20, p1) END PUTDistanceLeft; PROCEDURE (this: Rows) DistanceRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 21) END DistanceRight; PROCEDURE (this: Rows) PUTDistanceRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 21, p1) END PUTDistanceRight; PROCEDURE (this: Rows) HorizontalPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 15) END HorizontalPosition; PROCEDURE (this: Rows) PUTHorizontalPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 15, p1) END PUTHorizontalPosition; PROCEDURE (this: Rows) VerticalPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 17) END VerticalPosition; PROCEDURE (this: Rows) PUTVerticalPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 17, p1) END PUTVerticalPosition; PROCEDURE (this: Rows) RelativeHorizontalPosition* (): WdRelativeHorizontalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END RelativeHorizontalPosition; PROCEDURE (this: Rows) PUTRelativeHorizontalPosition* (p1: WdRelativeHorizontalPosition), NEW; BEGIN CtlC.PutInt(this, 18, p1) END PUTRelativeHorizontalPosition; PROCEDURE (this: Rows) RelativeVerticalPosition* (): WdRelativeVerticalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 19) END RelativeVerticalPosition; PROCEDURE (this: Rows) PUTRelativeVerticalPosition* (p1: WdRelativeVerticalPosition), NEW; BEGIN CtlC.PutInt(this, 19, p1) END PUTRelativeVerticalPosition; PROCEDURE (this: Rows) AllowOverlap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 22) END AllowOverlap; PROCEDURE (this: Rows) PUTAllowOverlap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 22, p1) END PUTAllowOverlap; PROCEDURE (this: Rows) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END NestingLevel; PROCEDURE (this: Rows) TableDirection* (): WdTableDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END TableDirection; PROCEDURE (this: Rows) PUTTableDirection* (p1: WdTableDirection), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTTableDirection; (* ---------- Columns, dual, nonextensible ---------- *) PROCEDURE (this: Columns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Columns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Columns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Columns) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Columns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Columns) First* (): Column, NEW; BEGIN RETURN ThisColumn(CtlC.GetAny(this, 100)) END First; PROCEDURE (this: Columns) Last* (): Column, NEW; BEGIN RETURN ThisColumn(CtlC.GetAny(this, 101)) END Last; PROCEDURE (this: Columns) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 3) END Width; PROCEDURE (this: Columns) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 3, p1) END PUTWidth; PROCEDURE (this: Columns) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Columns) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Columns) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 103)) END Shading; PROCEDURE (this: Columns) Item* (Index: INTEGER): Column, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisColumn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Columns) Add* ((* optional *) BeforeColumn: CtlT.Any): Column, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(BeforeColumn, arg[0]); CtlC.CallParMethod(this, 5, arg, ret); RETURN ThisColumn(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Columns) Select* (), NEW; BEGIN CtlC.CallMethod(this, 199, NIL); END Select; PROCEDURE (this: Columns) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 200, NIL); END Delete; PROCEDURE (this: Columns) SetWidth* (ColumnWidth: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(ColumnWidth, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 201, arg, NIL); END SetWidth; PROCEDURE (this: Columns) AutoFit* (), NEW; BEGIN CtlC.CallMethod(this, 202, NIL); END AutoFit; PROCEDURE (this: Columns) DistributeWidth* (), NEW; BEGIN CtlC.CallMethod(this, 203, NIL); END DistributeWidth; PROCEDURE (this: Columns) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END NestingLevel; PROCEDURE (this: Columns) PreferredWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END PreferredWidth; PROCEDURE (this: Columns) PUTPreferredWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTPreferredWidth; PROCEDURE (this: Columns) PreferredWidthType* (): WdPreferredWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END PreferredWidthType; PROCEDURE (this: Columns) PUTPreferredWidthType* (p1: WdPreferredWidthType), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTPreferredWidthType; (* ---------- Cells, dual, nonextensible ---------- *) PROCEDURE (this: Cells) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Cells) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Cells) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Cells) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Cells) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Cells) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END Width; PROCEDURE (this: Cells) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTWidth; PROCEDURE (this: Cells) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END Height; PROCEDURE (this: Cells) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTHeight; PROCEDURE (this: Cells) HeightRule* (): WdRowHeightRule, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END HeightRule; PROCEDURE (this: Cells) PUTHeightRule* (p1: WdRowHeightRule), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTHeightRule; PROCEDURE (this: Cells) VerticalAlignment* (): WdCellVerticalAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 1104) END VerticalAlignment; PROCEDURE (this: Cells) PUTVerticalAlignment* (p1: WdCellVerticalAlignment), NEW; BEGIN CtlC.PutInt(this, 1104, p1) END PUTVerticalAlignment; PROCEDURE (this: Cells) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Cells) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Cells) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 101)) END Shading; PROCEDURE (this: Cells) Item* (Index: INTEGER): Cell, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisCell(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Cells) Add* ((* optional *) BeforeCell: CtlT.Any): Cell, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(BeforeCell, arg[0]); CtlC.CallParMethod(this, 4, arg, ret); RETURN ThisCell(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Cells) Delete* ((* optional *) ShiftCells: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ShiftCells, arg[0]); CtlC.CallParMethod(this, 200, arg, NIL); END Delete; PROCEDURE (this: Cells) SetWidth* (ColumnWidth: SHORTREAL; RulerStyle: WdRulerStyle), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.SRealVar(ColumnWidth, arg[1]); CtlC.IntVar(RulerStyle, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END SetWidth; PROCEDURE (this: Cells) SetHeight* (RowHeight: CtlT.Any; HeightRule: WdRowHeightRule), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(RowHeight, arg[1]); CtlC.IntVar(HeightRule, arg[0]); CtlC.CallParMethod(this, 203, arg, NIL); END SetHeight; PROCEDURE (this: Cells) Merge* (), NEW; BEGIN CtlC.CallMethod(this, 204, NIL); END Merge; PROCEDURE (this: Cells) Split* ((* optional *) NumRows: CtlT.Any; NumColumns: CtlT.Any; MergeBeforeSplit: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[2]); CtlC.AnyVar(NumColumns, arg[1]); CtlC.AnyVar(MergeBeforeSplit, arg[0]); CtlC.CallParMethod(this, 205, arg, NIL); END Split; PROCEDURE (this: Cells) DistributeHeight* (), NEW; BEGIN CtlC.CallMethod(this, 206, NIL); END DistributeHeight; PROCEDURE (this: Cells) DistributeWidth* (), NEW; BEGIN CtlC.CallMethod(this, 207, NIL); END DistributeWidth; PROCEDURE (this: Cells) AutoFit* (), NEW; BEGIN CtlC.CallMethod(this, 208, NIL); END AutoFit; PROCEDURE (this: Cells) NestingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END NestingLevel; PROCEDURE (this: Cells) PreferredWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END PreferredWidth; PROCEDURE (this: Cells) PUTPreferredWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTPreferredWidth; PROCEDURE (this: Cells) PreferredWidthType* (): WdPreferredWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PreferredWidthType; PROCEDURE (this: Cells) PUTPreferredWidthType* (p1: WdPreferredWidthType), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTPreferredWidthType; (* ---------- AutoCorrect, dual, nonextensible ---------- *) PROCEDURE (this: AutoCorrect) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoCorrect) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoCorrect) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoCorrect) CorrectDays* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END CorrectDays; PROCEDURE (this: AutoCorrect) PUTCorrectDays* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTCorrectDays; PROCEDURE (this: AutoCorrect) CorrectInitialCaps* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END CorrectInitialCaps; PROCEDURE (this: AutoCorrect) PUTCorrectInitialCaps* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTCorrectInitialCaps; PROCEDURE (this: AutoCorrect) CorrectSentenceCaps* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END CorrectSentenceCaps; PROCEDURE (this: AutoCorrect) PUTCorrectSentenceCaps* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTCorrectSentenceCaps; PROCEDURE (this: AutoCorrect) ReplaceText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END ReplaceText; PROCEDURE (this: AutoCorrect) PUTReplaceText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTReplaceText; PROCEDURE (this: AutoCorrect) Entries* (): AutoCorrectEntries, NEW; BEGIN RETURN ThisAutoCorrectEntries(CtlC.GetAny(this, 6)) END Entries; PROCEDURE (this: AutoCorrect) FirstLetterExceptions* (): FirstLetterExceptions, NEW; BEGIN RETURN ThisFirstLetterExceptions(CtlC.GetAny(this, 7)) END FirstLetterExceptions; PROCEDURE (this: AutoCorrect) FirstLetterAutoAdd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END FirstLetterAutoAdd; PROCEDURE (this: AutoCorrect) PUTFirstLetterAutoAdd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTFirstLetterAutoAdd; PROCEDURE (this: AutoCorrect) TwoInitialCapsExceptions* (): TwoInitialCapsExceptions, NEW; BEGIN RETURN ThisTwoInitialCapsExceptions(CtlC.GetAny(this, 9)) END TwoInitialCapsExceptions; PROCEDURE (this: AutoCorrect) TwoInitialCapsAutoAdd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END TwoInitialCapsAutoAdd; PROCEDURE (this: AutoCorrect) PUTTwoInitialCapsAutoAdd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTTwoInitialCapsAutoAdd; PROCEDURE (this: AutoCorrect) CorrectCapsLock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END CorrectCapsLock; PROCEDURE (this: AutoCorrect) PUTCorrectCapsLock* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 11, p1) END PUTCorrectCapsLock; PROCEDURE (this: AutoCorrect) CorrectHangulAndAlphabet* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END CorrectHangulAndAlphabet; PROCEDURE (this: AutoCorrect) PUTCorrectHangulAndAlphabet* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTCorrectHangulAndAlphabet; PROCEDURE (this: AutoCorrect) HangulAndAlphabetExceptions* (): HangulAndAlphabetExceptions, NEW; BEGIN RETURN ThisHangulAndAlphabetExceptions(CtlC.GetAny(this, 13)) END HangulAndAlphabetExceptions; PROCEDURE (this: AutoCorrect) HangulAndAlphabetAutoAdd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END HangulAndAlphabetAutoAdd; PROCEDURE (this: AutoCorrect) PUTHangulAndAlphabetAutoAdd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTHangulAndAlphabetAutoAdd; PROCEDURE (this: AutoCorrect) ReplaceTextFromSpellingChecker* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 15) END ReplaceTextFromSpellingChecker; PROCEDURE (this: AutoCorrect) PUTReplaceTextFromSpellingChecker* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 15, p1) END PUTReplaceTextFromSpellingChecker; PROCEDURE (this: AutoCorrect) OtherCorrectionsAutoAdd* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END OtherCorrectionsAutoAdd; PROCEDURE (this: AutoCorrect) PUTOtherCorrectionsAutoAdd* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTOtherCorrectionsAutoAdd; PROCEDURE (this: AutoCorrect) OtherCorrectionsExceptions* (): OtherCorrectionsExceptions, NEW; BEGIN RETURN ThisOtherCorrectionsExceptions(CtlC.GetAny(this, 17)) END OtherCorrectionsExceptions; PROCEDURE (this: AutoCorrect) CorrectKeyboardSetting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 18) END CorrectKeyboardSetting; PROCEDURE (this: AutoCorrect) PUTCorrectKeyboardSetting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 18, p1) END PUTCorrectKeyboardSetting; (* ---------- AutoCorrectEntries, dual, nonextensible ---------- *) PROCEDURE (this: AutoCorrectEntries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoCorrectEntries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoCorrectEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoCorrectEntries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AutoCorrectEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: AutoCorrectEntries) Item* (Index: CtlT.Any): AutoCorrectEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisAutoCorrectEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AutoCorrectEntries) Add* (Name: ARRAY OF CHAR; Value: ARRAY OF CHAR): AutoCorrectEntry, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(Value, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisAutoCorrectEntry(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AutoCorrectEntries) AddRichText* (Name: ARRAY OF CHAR; range: Range): AutoCorrectEntry, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisAutoCorrectEntry(CtlC.VarAny(ret)) END AddRichText; (* ---------- AutoCorrectEntry, dual, nonextensible ---------- *) PROCEDURE (this: AutoCorrectEntry) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoCorrectEntry) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoCorrectEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoCorrectEntry) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: AutoCorrectEntry) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: AutoCorrectEntry) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTName; PROCEDURE (this: AutoCorrectEntry) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Value; PROCEDURE (this: AutoCorrectEntry) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3, p1) END PUTValue; PROCEDURE (this: AutoCorrectEntry) RichText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END RichText; PROCEDURE (this: AutoCorrectEntry) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; PROCEDURE (this: AutoCorrectEntry) Apply* (range: Range), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END Apply; (* ---------- FirstLetterExceptions, dual, nonextensible ---------- *) PROCEDURE (this: FirstLetterExceptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FirstLetterExceptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FirstLetterExceptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FirstLetterExceptions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FirstLetterExceptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: FirstLetterExceptions) Item* (Index: CtlT.Any): FirstLetterException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFirstLetterException(CtlC.VarAny(ret)) END Item; PROCEDURE (this: FirstLetterExceptions) Add* (Name: ARRAY OF CHAR): FirstLetterException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisFirstLetterException(CtlC.VarAny(ret)) END Add; (* ---------- FirstLetterException, dual, nonextensible ---------- *) PROCEDURE (this: FirstLetterException) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FirstLetterException) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FirstLetterException) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FirstLetterException) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: FirstLetterException) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: FirstLetterException) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- TwoInitialCapsExceptions, dual, nonextensible ---------- *) PROCEDURE (this: TwoInitialCapsExceptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TwoInitialCapsExceptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TwoInitialCapsExceptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TwoInitialCapsExceptions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TwoInitialCapsExceptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: TwoInitialCapsExceptions) Item* (Index: CtlT.Any): TwoInitialCapsException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTwoInitialCapsException(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TwoInitialCapsExceptions) Add* (Name: ARRAY OF CHAR): TwoInitialCapsException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisTwoInitialCapsException(CtlC.VarAny(ret)) END Add; (* ---------- TwoInitialCapsException, dual, nonextensible ---------- *) PROCEDURE (this: TwoInitialCapsException) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TwoInitialCapsException) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TwoInitialCapsException) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TwoInitialCapsException) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: TwoInitialCapsException) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: TwoInitialCapsException) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- Footnotes, dual, nonextensible ---------- *) PROCEDURE (this: Footnotes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Footnotes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Footnotes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Footnotes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Footnotes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Footnotes) Location* (): WdFootnoteLocation, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Location; PROCEDURE (this: Footnotes) PUTLocation* (p1: WdFootnoteLocation), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTLocation; PROCEDURE (this: Footnotes) NumberStyle* (): WdNoteNumberStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END NumberStyle; PROCEDURE (this: Footnotes) PUTNumberStyle* (p1: WdNoteNumberStyle), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTNumberStyle; PROCEDURE (this: Footnotes) StartingNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END StartingNumber; PROCEDURE (this: Footnotes) PUTStartingNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTStartingNumber; PROCEDURE (this: Footnotes) NumberingRule* (): WdNumberingRule, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END NumberingRule; PROCEDURE (this: Footnotes) PUTNumberingRule* (p1: WdNumberingRule), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTNumberingRule; PROCEDURE (this: Footnotes) Separator* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 104)) END Separator; PROCEDURE (this: Footnotes) ContinuationSeparator* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 105)) END ContinuationSeparator; PROCEDURE (this: Footnotes) ContinuationNotice* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 106)) END ContinuationNotice; PROCEDURE (this: Footnotes) Item* (Index: INTEGER): Footnote, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFootnote(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Footnotes) Add* (range: Range; (* optional *) Reference: CtlT.Any; Text: CtlT.Any): Footnote, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[2]); CtlC.AnyVar(Reference, arg[1]); CtlC.AnyVar(Text, arg[0]); CtlC.CallParMethod(this, 4, arg, ret); RETURN ThisFootnote(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Footnotes) Convert* (), NEW; BEGIN CtlC.CallMethod(this, 5, NIL); END Convert; PROCEDURE (this: Footnotes) SwapWithEndnotes* (), NEW; BEGIN CtlC.CallMethod(this, 6, NIL); END SwapWithEndnotes; PROCEDURE (this: Footnotes) ResetSeparator* (), NEW; BEGIN CtlC.CallMethod(this, 7, NIL); END ResetSeparator; PROCEDURE (this: Footnotes) ResetContinuationSeparator* (), NEW; BEGIN CtlC.CallMethod(this, 8, NIL); END ResetContinuationSeparator; PROCEDURE (this: Footnotes) ResetContinuationNotice* (), NEW; BEGIN CtlC.CallMethod(this, 9, NIL); END ResetContinuationNotice; (* ---------- Endnotes, dual, nonextensible ---------- *) PROCEDURE (this: Endnotes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Endnotes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Endnotes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Endnotes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Endnotes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Endnotes) Location* (): WdEndnoteLocation, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Location; PROCEDURE (this: Endnotes) PUTLocation* (p1: WdEndnoteLocation), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTLocation; PROCEDURE (this: Endnotes) NumberStyle* (): WdNoteNumberStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END NumberStyle; PROCEDURE (this: Endnotes) PUTNumberStyle* (p1: WdNoteNumberStyle), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTNumberStyle; PROCEDURE (this: Endnotes) StartingNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END StartingNumber; PROCEDURE (this: Endnotes) PUTStartingNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTStartingNumber; PROCEDURE (this: Endnotes) NumberingRule* (): WdNumberingRule, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END NumberingRule; PROCEDURE (this: Endnotes) PUTNumberingRule* (p1: WdNumberingRule), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTNumberingRule; PROCEDURE (this: Endnotes) Separator* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 104)) END Separator; PROCEDURE (this: Endnotes) ContinuationSeparator* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 105)) END ContinuationSeparator; PROCEDURE (this: Endnotes) ContinuationNotice* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 106)) END ContinuationNotice; PROCEDURE (this: Endnotes) Item* (Index: INTEGER): Endnote, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisEndnote(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Endnotes) Add* (range: Range; (* optional *) Reference: CtlT.Any; Text: CtlT.Any): Endnote, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[2]); CtlC.AnyVar(Reference, arg[1]); CtlC.AnyVar(Text, arg[0]); CtlC.CallParMethod(this, 4, arg, ret); RETURN ThisEndnote(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Endnotes) Convert* (), NEW; BEGIN CtlC.CallMethod(this, 5, NIL); END Convert; PROCEDURE (this: Endnotes) SwapWithFootnotes* (), NEW; BEGIN CtlC.CallMethod(this, 6, NIL); END SwapWithFootnotes; PROCEDURE (this: Endnotes) ResetSeparator* (), NEW; BEGIN CtlC.CallMethod(this, 7, NIL); END ResetSeparator; PROCEDURE (this: Endnotes) ResetContinuationSeparator* (), NEW; BEGIN CtlC.CallMethod(this, 8, NIL); END ResetContinuationSeparator; PROCEDURE (this: Endnotes) ResetContinuationNotice* (), NEW; BEGIN CtlC.CallMethod(this, 9, NIL); END ResetContinuationNotice; (* ---------- Comments, dual, nonextensible ---------- *) PROCEDURE (this: Comments) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Comments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Comments) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Comments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Comments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Comments) ShowBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1003) END ShowBy; PROCEDURE (this: Comments) PUTShowBy* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1003, p1) END PUTShowBy; PROCEDURE (this: Comments) Item* (Index: INTEGER): Comment, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisComment(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Comments) Add* (range: Range; (* optional *) Text: CtlT.Any): Comment, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[1]); CtlC.AnyVar(Text, arg[0]); CtlC.CallParMethod(this, 4, arg, ret); RETURN ThisComment(CtlC.VarAny(ret)) END Add; (* ---------- Footnote, dual, nonextensible ---------- *) PROCEDURE (this: Footnote) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Footnote) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Footnote) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Footnote) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Range; PROCEDURE (this: Footnote) Reference* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 5)) END Reference; PROCEDURE (this: Footnote) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Index; PROCEDURE (this: Footnote) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Delete; (* ---------- Endnote, dual, nonextensible ---------- *) PROCEDURE (this: Endnote) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Endnote) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Endnote) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Endnote) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Range; PROCEDURE (this: Endnote) Reference* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 5)) END Reference; PROCEDURE (this: Endnote) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Index; PROCEDURE (this: Endnote) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Delete; (* ---------- Comment, dual, nonextensible ---------- *) PROCEDURE (this: Comment) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Comment) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Comment) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Comment) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1003)) END Range; PROCEDURE (this: Comment) Reference* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1004)) END Reference; PROCEDURE (this: Comment) Scope* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1005)) END Scope; PROCEDURE (this: Comment) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1006) END Index; PROCEDURE (this: Comment) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1007) END Author; PROCEDURE (this: Comment) PUTAuthor* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1007, p1) END PUTAuthor; PROCEDURE (this: Comment) Initial* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1008) END Initial; PROCEDURE (this: Comment) PUTInitial* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1008, p1) END PUTInitial; PROCEDURE (this: Comment) ShowTip* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1009) END ShowTip; PROCEDURE (this: Comment) PUTShowTip* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1009, p1) END PUTShowTip; PROCEDURE (this: Comment) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Delete; (* ---------- Borders, dual, nonextensible ---------- *) PROCEDURE (this: Borders) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Borders) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Borders) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Borders) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Borders) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Borders) Enable* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Enable; PROCEDURE (this: Borders) PUTEnable* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTEnable; PROCEDURE (this: Borders) DistanceFromTop* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END DistanceFromTop; PROCEDURE (this: Borders) PUTDistanceFromTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTDistanceFromTop; PROCEDURE (this: Borders) Shadow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Shadow; PROCEDURE (this: Borders) PUTShadow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTShadow; PROCEDURE (this: Borders) InsideLineStyle* (): WdLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END InsideLineStyle; PROCEDURE (this: Borders) PUTInsideLineStyle* (p1: WdLineStyle), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTInsideLineStyle; PROCEDURE (this: Borders) OutsideLineStyle* (): WdLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END OutsideLineStyle; PROCEDURE (this: Borders) PUTOutsideLineStyle* (p1: WdLineStyle), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTOutsideLineStyle; PROCEDURE (this: Borders) InsideLineWidth* (): WdLineWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END InsideLineWidth; PROCEDURE (this: Borders) PUTInsideLineWidth* (p1: WdLineWidth), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTInsideLineWidth; PROCEDURE (this: Borders) OutsideLineWidth* (): WdLineWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END OutsideLineWidth; PROCEDURE (this: Borders) PUTOutsideLineWidth* (p1: WdLineWidth), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTOutsideLineWidth; PROCEDURE (this: Borders) InsideColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END InsideColorIndex; PROCEDURE (this: Borders) PUTInsideColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTInsideColorIndex; PROCEDURE (this: Borders) OutsideColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END OutsideColorIndex; PROCEDURE (this: Borders) PUTOutsideColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTOutsideColorIndex; PROCEDURE (this: Borders) DistanceFromLeft* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 20) END DistanceFromLeft; PROCEDURE (this: Borders) PUTDistanceFromLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 20, p1) END PUTDistanceFromLeft; PROCEDURE (this: Borders) DistanceFromBottom* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 21) END DistanceFromBottom; PROCEDURE (this: Borders) PUTDistanceFromBottom* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 21, p1) END PUTDistanceFromBottom; PROCEDURE (this: Borders) DistanceFromRight* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 22) END DistanceFromRight; PROCEDURE (this: Borders) PUTDistanceFromRight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 22, p1) END PUTDistanceFromRight; PROCEDURE (this: Borders) AlwaysInFront* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 23) END AlwaysInFront; PROCEDURE (this: Borders) PUTAlwaysInFront* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 23, p1) END PUTAlwaysInFront; PROCEDURE (this: Borders) SurroundHeader* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END SurroundHeader; PROCEDURE (this: Borders) PUTSurroundHeader* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTSurroundHeader; PROCEDURE (this: Borders) SurroundFooter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END SurroundFooter; PROCEDURE (this: Borders) PUTSurroundFooter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTSurroundFooter; PROCEDURE (this: Borders) JoinBorders* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 26) END JoinBorders; PROCEDURE (this: Borders) PUTJoinBorders* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 26, p1) END PUTJoinBorders; PROCEDURE (this: Borders) HasHorizontal* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 27) END HasHorizontal; PROCEDURE (this: Borders) HasVertical* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END HasVertical; PROCEDURE (this: Borders) DistanceFrom* (): WdBorderDistanceFrom, NEW; BEGIN RETURN CtlC.GetInt(this, 29) END DistanceFrom; PROCEDURE (this: Borders) PUTDistanceFrom* (p1: WdBorderDistanceFrom), NEW; BEGIN CtlC.PutInt(this, 29, p1) END PUTDistanceFrom; PROCEDURE (this: Borders) EnableFirstPageInSection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 30) END EnableFirstPageInSection; PROCEDURE (this: Borders) PUTEnableFirstPageInSection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 30, p1) END PUTEnableFirstPageInSection; PROCEDURE (this: Borders) EnableOtherPagesInSection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 31) END EnableOtherPagesInSection; PROCEDURE (this: Borders) PUTEnableOtherPagesInSection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 31, p1) END PUTEnableOtherPagesInSection; PROCEDURE (this: Borders) Item* (Index: WdBorderType): Border, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisBorder(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Borders) ApplyPageBordersToAllSections* (), NEW; BEGIN CtlC.CallMethod(this, 2000, NIL); END ApplyPageBordersToAllSections; PROCEDURE (this: Borders) InsideColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 32) END InsideColor; PROCEDURE (this: Borders) PUTInsideColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 32, p1) END PUTInsideColor; PROCEDURE (this: Borders) OutsideColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 33) END OutsideColor; PROCEDURE (this: Borders) PUTOutsideColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 33, p1) END PUTOutsideColor; (* ---------- Border, dual, nonextensible ---------- *) PROCEDURE (this: Border) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Border) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Border) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Border) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Visible; PROCEDURE (this: Border) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 0, p1) END PUTVisible; PROCEDURE (this: Border) ColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END ColorIndex; PROCEDURE (this: Border) PUTColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTColorIndex; PROCEDURE (this: Border) Inside* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Inside; PROCEDURE (this: Border) LineStyle* (): WdLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END LineStyle; PROCEDURE (this: Border) PUTLineStyle* (p1: WdLineStyle), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTLineStyle; PROCEDURE (this: Border) LineWidth* (): WdLineWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END LineWidth; PROCEDURE (this: Border) PUTLineWidth* (p1: WdLineWidth), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTLineWidth; PROCEDURE (this: Border) ArtStyle* (): WdPageBorderArt, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END ArtStyle; PROCEDURE (this: Border) PUTArtStyle* (p1: WdPageBorderArt), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTArtStyle; PROCEDURE (this: Border) ArtWidth* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END ArtWidth; PROCEDURE (this: Border) PUTArtWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTArtWidth; PROCEDURE (this: Border) Color* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END Color; PROCEDURE (this: Border) PUTColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTColor; (* ---------- Shading, dual, nonextensible ---------- *) PROCEDURE (this: Shading) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Shading) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Shading) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Shading) ForegroundPatternColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END ForegroundPatternColorIndex; PROCEDURE (this: Shading) PUTForegroundPatternColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTForegroundPatternColorIndex; PROCEDURE (this: Shading) BackgroundPatternColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END BackgroundPatternColorIndex; PROCEDURE (this: Shading) PUTBackgroundPatternColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTBackgroundPatternColorIndex; PROCEDURE (this: Shading) Texture* (): WdTextureIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Texture; PROCEDURE (this: Shading) PUTTexture* (p1: WdTextureIndex), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTTexture; PROCEDURE (this: Shading) ForegroundPatternColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END ForegroundPatternColor; PROCEDURE (this: Shading) PUTForegroundPatternColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTForegroundPatternColor; PROCEDURE (this: Shading) BackgroundPatternColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END BackgroundPatternColor; PROCEDURE (this: Shading) PUTBackgroundPatternColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTBackgroundPatternColor; (* ---------- TextRetrievalMode, dual, nonextensible ---------- *) PROCEDURE (this: TextRetrievalMode) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TextRetrievalMode) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TextRetrievalMode) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TextRetrievalMode) ViewType* (): WdViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END ViewType; PROCEDURE (this: TextRetrievalMode) PUTViewType* (p1: WdViewType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTViewType; PROCEDURE (this: TextRetrievalMode) Duplicate* (): TextRetrievalMode, NEW; BEGIN RETURN ThisTextRetrievalMode(CtlC.GetAny(this, 1)) END Duplicate; PROCEDURE (this: TextRetrievalMode) IncludeHiddenText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END IncludeHiddenText; PROCEDURE (this: TextRetrievalMode) PUTIncludeHiddenText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTIncludeHiddenText; PROCEDURE (this: TextRetrievalMode) IncludeFieldCodes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END IncludeFieldCodes; PROCEDURE (this: TextRetrievalMode) PUTIncludeFieldCodes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTIncludeFieldCodes; (* ---------- AutoTextEntries, dual, nonextensible ---------- *) PROCEDURE (this: AutoTextEntries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoTextEntries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoTextEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoTextEntries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AutoTextEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: AutoTextEntries) Item* (Index: CtlT.Any): AutoTextEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisAutoTextEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AutoTextEntries) Add* (Name: ARRAY OF CHAR; range: Range): AutoTextEntry, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisAutoTextEntry(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AutoTextEntries) AppendToSpike* (range: Range): AutoTextEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisAutoTextEntry(CtlC.VarAny(ret)) END AppendToSpike; (* ---------- AutoTextEntry, dual, nonextensible ---------- *) PROCEDURE (this: AutoTextEntry) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoTextEntry) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoTextEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoTextEntry) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: AutoTextEntry) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: AutoTextEntry) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTName; PROCEDURE (this: AutoTextEntry) StyleName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END StyleName; PROCEDURE (this: AutoTextEntry) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: AutoTextEntry) PUTValue* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTValue; PROCEDURE (this: AutoTextEntry) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; PROCEDURE (this: AutoTextEntry) Insert* (Where: Range; (* optional *) RichText: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Where, arg[1]); CtlC.AnyVar(RichText, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Insert; (* ---------- System, dual, nonextensible ---------- *) PROCEDURE (this: System) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: System) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: System) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: System) OperatingSystem* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END OperatingSystem; PROCEDURE (this: System) ProcessorType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END ProcessorType; PROCEDURE (this: System) Version* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Version; PROCEDURE (this: System) FreeDiskSpace* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END FreeDiskSpace; PROCEDURE (this: System) Country* (): WdCountry, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Country; PROCEDURE (this: System) LanguageDesignation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END LanguageDesignation; PROCEDURE (this: System) HorizontalResolution* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END HorizontalResolution; PROCEDURE (this: System) VerticalResolution* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END VerticalResolution; PROCEDURE (this: System) ProfileString* (Section: ARRAY OF CHAR; Key: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Section, arg[1]); CtlC.StrVar(Key, arg[0]); CtlC.CallGetMethod(this, 9, arg, ret); RETURN CtlC.VarStr(ret) END ProfileString; PROCEDURE (this: System) PUTProfileString* (Section: ARRAY OF CHAR; Key: ARRAY OF CHAR; p3: ARRAY OF CHAR), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Section, arg[2]); CtlC.StrVar(Key, arg[1]); CtlC.StrVar(p3, arg[0]); CtlC.CallPutMethod(this, 9, arg, NIL); END PUTProfileString; PROCEDURE (this: System) PrivateProfileString* (FileName: ARRAY OF CHAR; Section: ARRAY OF CHAR; Key: ARRAY OF CHAR): CtlT.Strg, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.StrVar(Section, arg[1]); CtlC.StrVar(Key, arg[0]); CtlC.CallGetMethod(this, 10, arg, ret); RETURN CtlC.VarStr(ret) END PrivateProfileString; PROCEDURE (this: System) PUTPrivateProfileString* (FileName: ARRAY OF CHAR; Section: ARRAY OF CHAR; Key: ARRAY OF CHAR; p4: ARRAY OF CHAR), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.StrVar(Section, arg[2]); CtlC.StrVar(Key, arg[1]); CtlC.StrVar(p4, arg[0]); CtlC.CallPutMethod(this, 10, arg, NIL); END PUTPrivateProfileString; PROCEDURE (this: System) MathCoprocessorInstalled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END MathCoprocessorInstalled; PROCEDURE (this: System) ComputerType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END ComputerType; PROCEDURE (this: System) MacintoshName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 14) END MacintoshName; PROCEDURE (this: System) QuickDrawInstalled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 15) END QuickDrawInstalled; PROCEDURE (this: System) Cursor* (): WdCursorType, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END Cursor; PROCEDURE (this: System) PUTCursor* (p1: WdCursorType), NEW; BEGIN CtlC.PutInt(this, 16, p1) END PUTCursor; PROCEDURE (this: System) MSInfo* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END MSInfo; PROCEDURE (this: System) Connect* (Path: ARRAY OF CHAR; (* optional *) Drive: CtlT.Any; Password: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(Path, arg[2]); CtlC.AnyVar(Drive, arg[1]); CtlC.AnyVar(Password, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END Connect; (* ---------- OLEFormat, dual, nonextensible ---------- *) PROCEDURE (this: OLEFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: OLEFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: OLEFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: OLEFormat) ClassType* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END ClassType; PROCEDURE (this: OLEFormat) PUTClassType* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTClassType; PROCEDURE (this: OLEFormat) DisplayAsIcon* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END DisplayAsIcon; PROCEDURE (this: OLEFormat) PUTDisplayAsIcon* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTDisplayAsIcon; PROCEDURE (this: OLEFormat) IconName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END IconName; PROCEDURE (this: OLEFormat) PUTIconName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTIconName; PROCEDURE (this: OLEFormat) IconPath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END IconPath; PROCEDURE (this: OLEFormat) IconIndex* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END IconIndex; PROCEDURE (this: OLEFormat) PUTIconIndex* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTIconIndex; PROCEDURE (this: OLEFormat) IconLabel* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END IconLabel; PROCEDURE (this: OLEFormat) PUTIconLabel* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTIconLabel; PROCEDURE (this: OLEFormat) Label* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 12) END Label; PROCEDURE (this: OLEFormat) Object* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 14) END Object; PROCEDURE (this: OLEFormat) ProgID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 22) END ProgID; PROCEDURE (this: OLEFormat) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END Activate; PROCEDURE (this: OLEFormat) Edit* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END Edit; PROCEDURE (this: OLEFormat) Open* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END Open; PROCEDURE (this: OLEFormat) DoVerb* ((* optional *) VerbIndex: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(VerbIndex, arg[0]); CtlC.CallParMethod(this, 109, arg, NIL); END DoVerb; PROCEDURE (this: OLEFormat) ConvertTo* ((* optional *) ClassType: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[4]); CtlC.AnyVar(DisplayAsIcon, arg[3]); CtlC.AnyVar(IconFileName, arg[2]); CtlC.AnyVar(IconIndex, arg[1]); CtlC.AnyVar(IconLabel, arg[0]); CtlC.CallParMethod(this, 110, arg, NIL); END ConvertTo; PROCEDURE (this: OLEFormat) ActivateAs* (ClassType: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(ClassType, arg[0]); CtlC.CallParMethod(this, 111, arg, NIL); END ActivateAs; (* ---------- LinkFormat, dual, nonextensible ---------- *) PROCEDURE (this: LinkFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: LinkFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: LinkFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: LinkFormat) AutoUpdate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END AutoUpdate; PROCEDURE (this: LinkFormat) PUTAutoUpdate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTAutoUpdate; PROCEDURE (this: LinkFormat) SourceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END SourceName; PROCEDURE (this: LinkFormat) SourcePath* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END SourcePath; PROCEDURE (this: LinkFormat) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END Locked; PROCEDURE (this: LinkFormat) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTLocked; PROCEDURE (this: LinkFormat) Type* (): WdLinkType, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END Type; PROCEDURE (this: LinkFormat) SourceFullName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 21) END SourceFullName; PROCEDURE (this: LinkFormat) PUTSourceFullName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 21, p1) END PUTSourceFullName; PROCEDURE (this: LinkFormat) SavePictureWithDocument* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 22) END SavePictureWithDocument; PROCEDURE (this: LinkFormat) PUTSavePictureWithDocument* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 22, p1) END PUTSavePictureWithDocument; PROCEDURE (this: LinkFormat) BreakLink* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END BreakLink; PROCEDURE (this: LinkFormat) Update* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END Update; (* ---------- _OLEControl, hidden, dual ---------- *) PROCEDURE (this: _OLEControl) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147417853) END Left; PROCEDURE (this: _OLEControl) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147417853, p1) END PUTLeft; PROCEDURE (this: _OLEControl) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147417852) END Top; PROCEDURE (this: _OLEControl) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147417852, p1) END PUTTop; PROCEDURE (this: _OLEControl) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147417851) END Height; PROCEDURE (this: _OLEControl) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147417851, p1) END PUTHeight; PROCEDURE (this: _OLEControl) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, -2147417850) END Width; PROCEDURE (this: _OLEControl) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, -2147417850, p1) END PUTWidth; PROCEDURE (this: _OLEControl) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147418112) END Name; PROCEDURE (this: _OLEControl) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147418112, p1) END PUTName; PROCEDURE (this: _OLEControl) Automation* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, -2147417849) END Automation; PROCEDURE (this: _OLEControl) Select* (), NEW; BEGIN CtlC.CallMethod(this, -2147417568, NIL); END Select; PROCEDURE (this: _OLEControl) Copy* (), NEW; BEGIN CtlC.CallMethod(this, -2147417560, NIL); END Copy; PROCEDURE (this: _OLEControl) Cut* (), NEW; BEGIN CtlC.CallMethod(this, -2147417559, NIL); END Cut; PROCEDURE (this: _OLEControl) Delete* (), NEW; BEGIN CtlC.CallMethod(this, -2147417520, NIL); END Delete; PROCEDURE (this: _OLEControl) Activate* (), NEW; BEGIN CtlC.CallMethod(this, -2147417519, NIL); END Activate; PROCEDURE (this: _OLEControl) AltHTML* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, -2147415101) END AltHTML; PROCEDURE (this: _OLEControl) PUTAltHTML* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, -2147415101, p1) END PUTAltHTML; (* ---------- Fields, dual, nonextensible ---------- *) PROCEDURE (this: Fields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Fields) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Fields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Fields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Fields) Locked* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Locked; PROCEDURE (this: Fields) PUTLocked* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTLocked; PROCEDURE (this: Fields) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Fields) Item* (Index: INTEGER): Field, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Fields) ToggleShowCodes* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END ToggleShowCodes; PROCEDURE (this: Fields) Update* (): INTEGER, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 101, ret); RETURN CtlC.VarInt(ret) END Update; PROCEDURE (this: Fields) Unlink* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Unlink; PROCEDURE (this: Fields) UpdateSource* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END UpdateSource; PROCEDURE (this: Fields) Add* (range: Range; (* optional *) Type: CtlT.Any; Text: CtlT.Any; PreserveFormatting: CtlT.Any): Field, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(Text, arg[1]); CtlC.AnyVar(PreserveFormatting, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END Add; (* ---------- Field, dual, nonextensible ---------- *) PROCEDURE (this: Field) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Field) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Field) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Field) Code* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Code; PROCEDURE (this: Field) PUTCode* (p1: Range), NEW; BEGIN CtlC.PutObj(this, 0, p1) END PUTCode; PROCEDURE (this: Field) Type* (): WdFieldType, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Type; PROCEDURE (this: Field) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Locked; PROCEDURE (this: Field) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTLocked; PROCEDURE (this: Field) Kind* (): WdFieldKind, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Kind; PROCEDURE (this: Field) Result* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 4)) END Result; PROCEDURE (this: Field) PUTResult* (p1: Range), NEW; BEGIN CtlC.PutObj(this, 4, p1) END PUTResult; PROCEDURE (this: Field) Data* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END Data; PROCEDURE (this: Field) PUTData* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 5, p1) END PUTData; PROCEDURE (this: Field) Next* (): Field, NEW; BEGIN RETURN ThisField(CtlC.GetAny(this, 6)) END Next; PROCEDURE (this: Field) Previous* (): Field, NEW; BEGIN RETURN ThisField(CtlC.GetAny(this, 7)) END Previous; PROCEDURE (this: Field) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END Index; PROCEDURE (this: Field) ShowCodes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END ShowCodes; PROCEDURE (this: Field) PUTShowCodes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTShowCodes; PROCEDURE (this: Field) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 10)) END LinkFormat; PROCEDURE (this: Field) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 11)) END OLEFormat; PROCEDURE (this: Field) InlineShape* (): InlineShape, NEW; BEGIN RETURN ThisInlineShape(CtlC.GetAny(this, 12)) END InlineShape; PROCEDURE (this: Field) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Field) Update* (): BOOLEAN, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 101, ret); RETURN CtlC.VarBool(ret) END Update; PROCEDURE (this: Field) Unlink* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Unlink; PROCEDURE (this: Field) UpdateSource* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END UpdateSource; PROCEDURE (this: Field) DoClick* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END DoClick; PROCEDURE (this: Field) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END Copy; PROCEDURE (this: Field) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END Cut; PROCEDURE (this: Field) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END Delete; (* ---------- Browser, dual, nonextensible ---------- *) PROCEDURE (this: Browser) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Browser) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Browser) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Browser) Target* (): WdBrowseTarget, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Target; PROCEDURE (this: Browser) PUTTarget* (p1: WdBrowseTarget), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTTarget; PROCEDURE (this: Browser) Next* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Next; PROCEDURE (this: Browser) Previous* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Previous; (* ---------- Styles, dual, nonextensible ---------- *) PROCEDURE (this: Styles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Styles) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Styles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Styles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Styles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Styles) Item* (Index: CtlT.Any): Style, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisStyle(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Styles) Add* (Name: ARRAY OF CHAR; (* optional *) Type: CtlT.Any): Style, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisStyle(CtlC.VarAny(ret)) END Add; (* ---------- Style, dual, nonextensible ---------- *) PROCEDURE (this: Style) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Style) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Style) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Style) NameLocal* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END NameLocal; PROCEDURE (this: Style) PUTNameLocal* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTNameLocal; PROCEDURE (this: Style) BaseStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 1) END BaseStyle; PROCEDURE (this: Style) PUTBaseStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 1, p1) END PUTBaseStyle; PROCEDURE (this: Style) Description* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Description; PROCEDURE (this: Style) Type* (): WdStyleType, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Type; PROCEDURE (this: Style) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END BuiltIn; PROCEDURE (this: Style) NextParagraphStyle* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 5) END NextParagraphStyle; PROCEDURE (this: Style) PUTNextParagraphStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 5, p1) END PUTNextParagraphStyle; PROCEDURE (this: Style) InUse* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END InUse; PROCEDURE (this: Style) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 7)) END Shading; PROCEDURE (this: Style) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 8)) END Borders; PROCEDURE (this: Style) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 8, p1) END PUTBorders; PROCEDURE (this: Style) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 9)) END ParagraphFormat; PROCEDURE (this: Style) PUTParagraphFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 9, p1) END PUTParagraphFormat; PROCEDURE (this: Style) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 10)) END Font; PROCEDURE (this: Style) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 10, p1) END PUTFont; PROCEDURE (this: Style) Frame* (): Frame, NEW; BEGIN RETURN ThisFrame(CtlC.GetAny(this, 11)) END Frame; PROCEDURE (this: Style) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END LanguageID; PROCEDURE (this: Style) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTLanguageID; PROCEDURE (this: Style) AutomaticallyUpdate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END AutomaticallyUpdate; PROCEDURE (this: Style) PUTAutomaticallyUpdate* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTAutomaticallyUpdate; PROCEDURE (this: Style) ListTemplate* (): ListTemplate, NEW; BEGIN RETURN ThisListTemplate(CtlC.GetAny(this, 14)) END ListTemplate; PROCEDURE (this: Style) ListLevelNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 15) END ListLevelNumber; PROCEDURE (this: Style) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 16) END LanguageIDFarEast; PROCEDURE (this: Style) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 16, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Style) Hidden* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 17) END Hidden; PROCEDURE (this: Style) PUTHidden* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 17, p1) END PUTHidden; PROCEDURE (this: Style) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: Style) LinkToListTemplate* (listTemplate: ListTemplate; (* optional *) ListLevelNumber: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[1]); CtlC.AnyVar(ListLevelNumber, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END LinkToListTemplate; PROCEDURE (this: Style) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 18) END NoProofing; PROCEDURE (this: Style) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 18, p1) END PUTNoProofing; (* ---------- Frames, dual, nonextensible ---------- *) PROCEDURE (this: Frames) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Frames) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Frames) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Frames) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Frames) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Frames) Item* (Index: INTEGER): Frame, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFrame(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Frames) Add* (range: Range): Frame, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisFrame(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Frames) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- Frame, dual, nonextensible ---------- *) PROCEDURE (this: Frame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Frame) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Frame) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Frame) HeightRule* (): WdFrameSizeRule, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END HeightRule; PROCEDURE (this: Frame) PUTHeightRule* (p1: WdFrameSizeRule), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTHeightRule; PROCEDURE (this: Frame) WidthRule* (): WdFrameSizeRule, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END WidthRule; PROCEDURE (this: Frame) PUTWidthRule* (p1: WdFrameSizeRule), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTWidthRule; PROCEDURE (this: Frame) HorizontalDistanceFromText* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 3) END HorizontalDistanceFromText; PROCEDURE (this: Frame) PUTHorizontalDistanceFromText* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 3, p1) END PUTHorizontalDistanceFromText; PROCEDURE (this: Frame) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 4) END Height; PROCEDURE (this: Frame) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 4, p1) END PUTHeight; PROCEDURE (this: Frame) HorizontalPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 5) END HorizontalPosition; PROCEDURE (this: Frame) PUTHorizontalPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 5, p1) END PUTHorizontalPosition; PROCEDURE (this: Frame) LockAnchor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END LockAnchor; PROCEDURE (this: Frame) PUTLockAnchor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTLockAnchor; PROCEDURE (this: Frame) RelativeHorizontalPosition* (): WdRelativeHorizontalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END RelativeHorizontalPosition; PROCEDURE (this: Frame) PUTRelativeHorizontalPosition* (p1: WdRelativeHorizontalPosition), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTRelativeHorizontalPosition; PROCEDURE (this: Frame) RelativeVerticalPosition* (): WdRelativeVerticalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END RelativeVerticalPosition; PROCEDURE (this: Frame) PUTRelativeVerticalPosition* (p1: WdRelativeVerticalPosition), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTRelativeVerticalPosition; PROCEDURE (this: Frame) VerticalDistanceFromText* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 9) END VerticalDistanceFromText; PROCEDURE (this: Frame) PUTVerticalDistanceFromText* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 9, p1) END PUTVerticalDistanceFromText; PROCEDURE (this: Frame) VerticalPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 10) END VerticalPosition; PROCEDURE (this: Frame) PUTVerticalPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 10, p1) END PUTVerticalPosition; PROCEDURE (this: Frame) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 11) END Width; PROCEDURE (this: Frame) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 11, p1) END PUTWidth; PROCEDURE (this: Frame) TextWrap* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END TextWrap; PROCEDURE (this: Frame) PUTTextWrap* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTTextWrap; PROCEDURE (this: Frame) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 13)) END Shading; PROCEDURE (this: Frame) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Frame) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Frame) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 15)) END Range; PROCEDURE (this: Frame) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: Frame) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Frame) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Copy; PROCEDURE (this: Frame) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Cut; (* ---------- FormFields, dual, nonextensible ---------- *) PROCEDURE (this: FormFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FormFields) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FormFields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FormFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: FormFields) Shaded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Shaded; PROCEDURE (this: FormFields) PUTShaded* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTShaded; PROCEDURE (this: FormFields) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FormFields) Item* (Index: CtlT.Any): FormField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFormField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: FormFields) Add* (range: Range; Type: WdFieldType): FormField, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[1]); CtlC.IntVar(Type, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisFormField(CtlC.VarAny(ret)) END Add; (* ---------- FormField, dual, nonextensible ---------- *) PROCEDURE (this: FormField) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FormField) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FormField) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FormField) Type* (): WdFieldType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Type; PROCEDURE (this: FormField) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: FormField) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTName; PROCEDURE (this: FormField) EntryMacro* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END EntryMacro; PROCEDURE (this: FormField) PUTEntryMacro* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3, p1) END PUTEntryMacro; PROCEDURE (this: FormField) ExitMacro* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END ExitMacro; PROCEDURE (this: FormField) PUTExitMacro* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 4, p1) END PUTExitMacro; PROCEDURE (this: FormField) OwnHelp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END OwnHelp; PROCEDURE (this: FormField) PUTOwnHelp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTOwnHelp; PROCEDURE (this: FormField) OwnStatus* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END OwnStatus; PROCEDURE (this: FormField) PUTOwnStatus* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTOwnStatus; PROCEDURE (this: FormField) HelpText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END HelpText; PROCEDURE (this: FormField) PUTHelpText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTHelpText; PROCEDURE (this: FormField) StatusText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END StatusText; PROCEDURE (this: FormField) PUTStatusText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 8, p1) END PUTStatusText; PROCEDURE (this: FormField) Enabled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END Enabled; PROCEDURE (this: FormField) PUTEnabled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTEnabled; PROCEDURE (this: FormField) Result* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END Result; PROCEDURE (this: FormField) PUTResult* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTResult; PROCEDURE (this: FormField) TextInput* (): TextInput, NEW; BEGIN RETURN ThisTextInput(CtlC.GetAny(this, 11)) END TextInput; PROCEDURE (this: FormField) CheckBox* (): CheckBox, NEW; BEGIN RETURN ThisCheckBox(CtlC.GetAny(this, 12)) END CheckBox; PROCEDURE (this: FormField) DropDown* (): DropDown, NEW; BEGIN RETURN ThisDropDown(CtlC.GetAny(this, 13)) END DropDown; PROCEDURE (this: FormField) Next* (): FormField, NEW; BEGIN RETURN ThisFormField(CtlC.GetAny(this, 14)) END Next; PROCEDURE (this: FormField) Previous* (): FormField, NEW; BEGIN RETURN ThisFormField(CtlC.GetAny(this, 15)) END Previous; PROCEDURE (this: FormField) CalculateOnExit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END CalculateOnExit; PROCEDURE (this: FormField) PUTCalculateOnExit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTCalculateOnExit; PROCEDURE (this: FormField) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 17)) END Range; PROCEDURE (this: FormField) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: FormField) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Copy; PROCEDURE (this: FormField) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Cut; PROCEDURE (this: FormField) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Delete; (* ---------- TextInput, dual, nonextensible ---------- *) PROCEDURE (this: TextInput) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TextInput) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TextInput) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TextInput) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Valid; PROCEDURE (this: TextInput) Default* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Default; PROCEDURE (this: TextInput) PUTDefault* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTDefault; PROCEDURE (this: TextInput) Type* (): WdTextFormFieldType, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Type; PROCEDURE (this: TextInput) Format* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Format; PROCEDURE (this: TextInput) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Width; PROCEDURE (this: TextInput) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTWidth; PROCEDURE (this: TextInput) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Clear; PROCEDURE (this: TextInput) EditType* (Type: WdTextFormFieldType; (* optional *) Default: CtlT.Any; Format: CtlT.Any; Enabled: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[3]); CtlC.AnyVar(Default, arg[2]); CtlC.AnyVar(Format, arg[1]); CtlC.AnyVar(Enabled, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END EditType; (* ---------- CheckBox, dual, nonextensible ---------- *) PROCEDURE (this: CheckBox) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CheckBox) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CheckBox) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: CheckBox) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Valid; PROCEDURE (this: CheckBox) AutoSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END AutoSize; PROCEDURE (this: CheckBox) PUTAutoSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTAutoSize; PROCEDURE (this: CheckBox) Size* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2) END Size; PROCEDURE (this: CheckBox) PUTSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2, p1) END PUTSize; PROCEDURE (this: CheckBox) Default* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END Default; PROCEDURE (this: CheckBox) PUTDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTDefault; PROCEDURE (this: CheckBox) Value* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END Value; PROCEDURE (this: CheckBox) PUTValue* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTValue; (* ---------- DropDown, dual, nonextensible ---------- *) PROCEDURE (this: DropDown) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: DropDown) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: DropDown) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: DropDown) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 0) END Valid; PROCEDURE (this: DropDown) Default* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Default; PROCEDURE (this: DropDown) PUTDefault* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTDefault; PROCEDURE (this: DropDown) Value* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Value; PROCEDURE (this: DropDown) PUTValue* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTValue; PROCEDURE (this: DropDown) ListEntries* (): ListEntries, NEW; BEGIN RETURN ThisListEntries(CtlC.GetAny(this, 3)) END ListEntries; (* ---------- ListEntries, dual, nonextensible ---------- *) PROCEDURE (this: ListEntries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListEntries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListEntries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListEntries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ListEntries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: ListEntries) Item* (Index: CtlT.Any): ListEntry, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisListEntry(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ListEntries) Add* (Name: ARRAY OF CHAR; (* optional *) Index: CtlT.Any): ListEntry, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisListEntry(CtlC.VarAny(ret)) END Add; PROCEDURE (this: ListEntries) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Clear; (* ---------- ListEntry, dual, nonextensible ---------- *) PROCEDURE (this: ListEntry) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListEntry) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListEntry) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListEntry) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: ListEntry) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: ListEntry) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTName; PROCEDURE (this: ListEntry) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; (* ---------- TablesOfFigures, dual, nonextensible ---------- *) PROCEDURE (this: TablesOfFigures) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TablesOfFigures) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TablesOfFigures) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TablesOfFigures) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TablesOfFigures) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: TablesOfFigures) Format* (): WdTofFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Format; PROCEDURE (this: TablesOfFigures) PUTFormat* (p1: WdTofFormat), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTFormat; PROCEDURE (this: TablesOfFigures) Item* (Index: INTEGER): TableOfFigures, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTableOfFigures(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TablesOfFigures) AddOld* (range: Range; (* optional *) Caption: CtlT.Any; IncludeLabel: CtlT.Any; UseHeadingStyles: CtlT.Any; UpperHeadingLevel: CtlT.Any; LowerHeadingLevel: CtlT.Any; UseFields: CtlT.Any; TableID: CtlT.Any; RightAlignPageNumbers: CtlT.Any; IncludePageNumbers: CtlT.Any; AddedStyles: CtlT.Any): TableOfFigures, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[10]); CtlC.AnyVar(Caption, arg[9]); CtlC.AnyVar(IncludeLabel, arg[8]); CtlC.AnyVar(UseHeadingStyles, arg[7]); CtlC.AnyVar(UpperHeadingLevel, arg[6]); CtlC.AnyVar(LowerHeadingLevel, arg[5]); CtlC.AnyVar(UseFields, arg[4]); CtlC.AnyVar(TableID, arg[3]); CtlC.AnyVar(RightAlignPageNumbers, arg[2]); CtlC.AnyVar(IncludePageNumbers, arg[1]); CtlC.AnyVar(AddedStyles, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisTableOfFigures(CtlC.VarAny(ret)) END AddOld; PROCEDURE (this: TablesOfFigures) MarkEntry* (range: Range; (* optional *) Entry: CtlT.Any; EntryAutoText: CtlT.Any; TableID: CtlT.Any; Level: CtlT.Any): Field, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[4]); CtlC.AnyVar(Entry, arg[3]); CtlC.AnyVar(EntryAutoText, arg[2]); CtlC.AnyVar(TableID, arg[1]); CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END MarkEntry; PROCEDURE (this: TablesOfFigures) Add* (range: Range; (* optional *) Caption: CtlT.Any; IncludeLabel: CtlT.Any; UseHeadingStyles: CtlT.Any; UpperHeadingLevel: CtlT.Any; LowerHeadingLevel: CtlT.Any; UseFields: CtlT.Any; TableID: CtlT.Any; RightAlignPageNumbers: CtlT.Any; IncludePageNumbers: CtlT.Any; AddedStyles: CtlT.Any; UseHyperlinks: CtlT.Any; HidePageNumbersInWeb: CtlT.Any): TableOfFigures, NEW; VAR arg: ARRAY 13 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[12]); CtlC.AnyVar(Caption, arg[11]); CtlC.AnyVar(IncludeLabel, arg[10]); CtlC.AnyVar(UseHeadingStyles, arg[9]); CtlC.AnyVar(UpperHeadingLevel, arg[8]); CtlC.AnyVar(LowerHeadingLevel, arg[7]); CtlC.AnyVar(UseFields, arg[6]); CtlC.AnyVar(TableID, arg[5]); CtlC.AnyVar(RightAlignPageNumbers, arg[4]); CtlC.AnyVar(IncludePageNumbers, arg[3]); CtlC.AnyVar(AddedStyles, arg[2]); CtlC.AnyVar(UseHyperlinks, arg[1]); CtlC.AnyVar(HidePageNumbersInWeb, arg[0]); CtlC.CallParMethod(this, 444, arg, ret); RETURN ThisTableOfFigures(CtlC.VarAny(ret)) END Add; (* ---------- TableOfFigures, dual, nonextensible ---------- *) PROCEDURE (this: TableOfFigures) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TableOfFigures) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TableOfFigures) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TableOfFigures) Caption* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Caption; PROCEDURE (this: TableOfFigures) PUTCaption* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1, p1) END PUTCaption; PROCEDURE (this: TableOfFigures) IncludeLabel* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END IncludeLabel; PROCEDURE (this: TableOfFigures) PUTIncludeLabel* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTIncludeLabel; PROCEDURE (this: TableOfFigures) RightAlignPageNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END RightAlignPageNumbers; PROCEDURE (this: TableOfFigures) PUTRightAlignPageNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTRightAlignPageNumbers; PROCEDURE (this: TableOfFigures) UseHeadingStyles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END UseHeadingStyles; PROCEDURE (this: TableOfFigures) PUTUseHeadingStyles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTUseHeadingStyles; PROCEDURE (this: TableOfFigures) LowerHeadingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END LowerHeadingLevel; PROCEDURE (this: TableOfFigures) PUTLowerHeadingLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTLowerHeadingLevel; PROCEDURE (this: TableOfFigures) UpperHeadingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END UpperHeadingLevel; PROCEDURE (this: TableOfFigures) PUTUpperHeadingLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTUpperHeadingLevel; PROCEDURE (this: TableOfFigures) IncludePageNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END IncludePageNumbers; PROCEDURE (this: TableOfFigures) PUTIncludePageNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTIncludePageNumbers; PROCEDURE (this: TableOfFigures) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 8)) END Range; PROCEDURE (this: TableOfFigures) UseFields* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END UseFields; PROCEDURE (this: TableOfFigures) PUTUseFields* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTUseFields; PROCEDURE (this: TableOfFigures) TableID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END TableID; PROCEDURE (this: TableOfFigures) PUTTableID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTTableID; PROCEDURE (this: TableOfFigures) HeadingStyles* (): HeadingStyles, NEW; BEGIN RETURN ThisHeadingStyles(CtlC.GetAny(this, 11)) END HeadingStyles; PROCEDURE (this: TableOfFigures) TabLeader* (): WdTabLeader, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END TabLeader; PROCEDURE (this: TableOfFigures) PUTTabLeader* (p1: WdTabLeader), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTTabLeader; PROCEDURE (this: TableOfFigures) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: TableOfFigures) UpdatePageNumbers* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END UpdatePageNumbers; PROCEDURE (this: TableOfFigures) Update* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Update; PROCEDURE (this: TableOfFigures) UseHyperlinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END UseHyperlinks; PROCEDURE (this: TableOfFigures) PUTUseHyperlinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTUseHyperlinks; PROCEDURE (this: TableOfFigures) HidePageNumbersInWeb* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END HidePageNumbersInWeb; PROCEDURE (this: TableOfFigures) PUTHidePageNumbersInWeb* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTHidePageNumbersInWeb; (* ---------- MailMerge, dual, nonextensible ---------- *) PROCEDURE (this: MailMerge) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMerge) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMerge) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMerge) MainDocumentType* (): WdMailMergeMainDocType, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END MainDocumentType; PROCEDURE (this: MailMerge) PUTMainDocumentType* (p1: WdMailMergeMainDocType), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTMainDocumentType; PROCEDURE (this: MailMerge) State* (): WdMailMergeState, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END State; PROCEDURE (this: MailMerge) Destination* (): WdMailMergeDestination, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Destination; PROCEDURE (this: MailMerge) PUTDestination* (p1: WdMailMergeDestination), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTDestination; PROCEDURE (this: MailMerge) DataSource* (): MailMergeDataSource, NEW; BEGIN RETURN ThisMailMergeDataSource(CtlC.GetAny(this, 4)) END DataSource; PROCEDURE (this: MailMerge) Fields* (): MailMergeFields, NEW; BEGIN RETURN ThisMailMergeFields(CtlC.GetAny(this, 5)) END Fields; PROCEDURE (this: MailMerge) ViewMailMergeFieldCodes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END ViewMailMergeFieldCodes; PROCEDURE (this: MailMerge) PUTViewMailMergeFieldCodes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTViewMailMergeFieldCodes; PROCEDURE (this: MailMerge) SuppressBlankLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END SuppressBlankLines; PROCEDURE (this: MailMerge) PUTSuppressBlankLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTSuppressBlankLines; PROCEDURE (this: MailMerge) MailAsAttachment* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END MailAsAttachment; PROCEDURE (this: MailMerge) PUTMailAsAttachment* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTMailAsAttachment; PROCEDURE (this: MailMerge) MailAddressFieldName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 9) END MailAddressFieldName; PROCEDURE (this: MailMerge) PUTMailAddressFieldName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 9, p1) END PUTMailAddressFieldName; PROCEDURE (this: MailMerge) MailSubject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END MailSubject; PROCEDURE (this: MailMerge) PUTMailSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTMailSubject; PROCEDURE (this: MailMerge) CreateDataSource* ((* optional *) Name: CtlT.Any; PasswordDocument: CtlT.Any; WritePasswordDocument: CtlT.Any; HeaderRecord: CtlT.Any; MSQuery: CtlT.Any; SQLStatement: CtlT.Any; SQLStatement1: CtlT.Any; Connection: CtlT.Any; LinkToSource: CtlT.Any), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[8]); CtlC.AnyVar(PasswordDocument, arg[7]); CtlC.AnyVar(WritePasswordDocument, arg[6]); CtlC.AnyVar(HeaderRecord, arg[5]); CtlC.AnyVar(MSQuery, arg[4]); CtlC.AnyVar(SQLStatement, arg[3]); CtlC.AnyVar(SQLStatement1, arg[2]); CtlC.AnyVar(Connection, arg[1]); CtlC.AnyVar(LinkToSource, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END CreateDataSource; PROCEDURE (this: MailMerge) CreateHeaderSource* (Name: ARRAY OF CHAR; (* optional *) PasswordDocument: CtlT.Any; WritePasswordDocument: CtlT.Any; HeaderRecord: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(PasswordDocument, arg[2]); CtlC.AnyVar(WritePasswordDocument, arg[1]); CtlC.AnyVar(HeaderRecord, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END CreateHeaderSource; PROCEDURE (this: MailMerge) OpenDataSource* (Name: ARRAY OF CHAR; (* optional *) Format: CtlT.Any; ConfirmConversions: CtlT.Any; ReadOnly: CtlT.Any; LinkToSource: CtlT.Any; AddToRecentFiles: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; Revert: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any; Connection: CtlT.Any; SQLStatement: CtlT.Any; SQLStatement1: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[13]); CtlC.AnyVar(Format, arg[12]); CtlC.AnyVar(ConfirmConversions, arg[11]); CtlC.AnyVar(ReadOnly, arg[10]); CtlC.AnyVar(LinkToSource, arg[9]); CtlC.AnyVar(AddToRecentFiles, arg[8]); CtlC.AnyVar(PasswordDocument, arg[7]); CtlC.AnyVar(PasswordTemplate, arg[6]); CtlC.AnyVar(Revert, arg[5]); CtlC.AnyVar(WritePasswordDocument, arg[4]); CtlC.AnyVar(WritePasswordTemplate, arg[3]); CtlC.AnyVar(Connection, arg[2]); CtlC.AnyVar(SQLStatement, arg[1]); CtlC.AnyVar(SQLStatement1, arg[0]); CtlC.CallParMethod(this, 103, arg, NIL); END OpenDataSource; PROCEDURE (this: MailMerge) OpenHeaderSource* (Name: ARRAY OF CHAR; (* optional *) Format: CtlT.Any; ConfirmConversions: CtlT.Any; ReadOnly: CtlT.Any; AddToRecentFiles: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; Revert: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any), NEW; VAR arg: ARRAY 10 OF CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[9]); CtlC.AnyVar(Format, arg[8]); CtlC.AnyVar(ConfirmConversions, arg[7]); CtlC.AnyVar(ReadOnly, arg[6]); CtlC.AnyVar(AddToRecentFiles, arg[5]); CtlC.AnyVar(PasswordDocument, arg[4]); CtlC.AnyVar(PasswordTemplate, arg[3]); CtlC.AnyVar(Revert, arg[2]); CtlC.AnyVar(WritePasswordDocument, arg[1]); CtlC.AnyVar(WritePasswordTemplate, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END OpenHeaderSource; PROCEDURE (this: MailMerge) Execute* ((* optional *) Pause: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Pause, arg[0]); CtlC.CallParMethod(this, 105, arg, NIL); END Execute; PROCEDURE (this: MailMerge) Check* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END Check; PROCEDURE (this: MailMerge) EditDataSource* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END EditDataSource; PROCEDURE (this: MailMerge) EditHeaderSource* (), NEW; BEGIN CtlC.CallMethod(this, 108, NIL); END EditHeaderSource; PROCEDURE (this: MailMerge) EditMainDocument* (), NEW; BEGIN CtlC.CallMethod(this, 109, NIL); END EditMainDocument; PROCEDURE (this: MailMerge) UseAddressBook* (Type: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Type, arg[0]); CtlC.CallParMethod(this, 111, arg, NIL); END UseAddressBook; (* ---------- MailMergeFields, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeFields) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeFields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeFields) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: MailMergeFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: MailMergeFields) Item* (Index: INTEGER): MailMergeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END Item; PROCEDURE (this: MailMergeFields) Add* (range: Range; Name: ARRAY OF CHAR): MailMergeField, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[1]); CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END Add; PROCEDURE (this: MailMergeFields) AddAsk* (range: Range; Name: ARRAY OF CHAR; (* optional *) Prompt: CtlT.Any; DefaultAskText: CtlT.Any; AskOnce: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[4]); CtlC.StrVar(Name, arg[3]); CtlC.AnyVar(Prompt, arg[2]); CtlC.AnyVar(DefaultAskText, arg[1]); CtlC.AnyVar(AskOnce, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddAsk; PROCEDURE (this: MailMergeFields) AddFillIn* (range: Range; (* optional *) Prompt: CtlT.Any; DefaultFillInText: CtlT.Any; AskOnce: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[3]); CtlC.AnyVar(Prompt, arg[2]); CtlC.AnyVar(DefaultFillInText, arg[1]); CtlC.AnyVar(AskOnce, arg[0]); CtlC.CallParMethod(this, 103, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddFillIn; PROCEDURE (this: MailMergeFields) AddIf* (range: Range; MergeField: ARRAY OF CHAR; Comparison: WdMailMergeComparison; (* optional *) CompareTo: CtlT.Any; TrueAutoText: CtlT.Any; TrueText: CtlT.Any; FalseAutoText: CtlT.Any; FalseText: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[7]); CtlC.StrVar(MergeField, arg[6]); CtlC.IntVar(Comparison, arg[5]); CtlC.AnyVar(CompareTo, arg[4]); CtlC.AnyVar(TrueAutoText, arg[3]); CtlC.AnyVar(TrueText, arg[2]); CtlC.AnyVar(FalseAutoText, arg[1]); CtlC.AnyVar(FalseText, arg[0]); CtlC.CallParMethod(this, 104, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddIf; PROCEDURE (this: MailMergeFields) AddMergeRec* (range: Range): MailMergeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddMergeRec; PROCEDURE (this: MailMergeFields) AddMergeSeq* (range: Range): MailMergeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 106, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddMergeSeq; PROCEDURE (this: MailMergeFields) AddNext* (range: Range): MailMergeField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 107, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddNext; PROCEDURE (this: MailMergeFields) AddNextIf* (range: Range; MergeField: ARRAY OF CHAR; Comparison: WdMailMergeComparison; (* optional *) CompareTo: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[3]); CtlC.StrVar(MergeField, arg[2]); CtlC.IntVar(Comparison, arg[1]); CtlC.AnyVar(CompareTo, arg[0]); CtlC.CallParMethod(this, 108, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddNextIf; PROCEDURE (this: MailMergeFields) AddSet* (range: Range; Name: ARRAY OF CHAR; (* optional *) ValueText: CtlT.Any; ValueAutoText: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[3]); CtlC.StrVar(Name, arg[2]); CtlC.AnyVar(ValueText, arg[1]); CtlC.AnyVar(ValueAutoText, arg[0]); CtlC.CallParMethod(this, 109, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddSet; PROCEDURE (this: MailMergeFields) AddSkipIf* (range: Range; MergeField: ARRAY OF CHAR; Comparison: WdMailMergeComparison; (* optional *) CompareTo: CtlT.Any): MailMergeField, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[3]); CtlC.StrVar(MergeField, arg[2]); CtlC.IntVar(Comparison, arg[1]); CtlC.AnyVar(CompareTo, arg[0]); CtlC.CallParMethod(this, 110, arg, ret); RETURN ThisMailMergeField(CtlC.VarAny(ret)) END AddSkipIf; (* ---------- MailMergeField, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeField) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeField) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeField) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeField) Type* (): WdFieldType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Type; PROCEDURE (this: MailMergeField) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END Locked; PROCEDURE (this: MailMergeField) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTLocked; PROCEDURE (this: MailMergeField) Code* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 5)) END Code; PROCEDURE (this: MailMergeField) PUTCode* (p1: Range), NEW; BEGIN CtlC.PutObj(this, 5, p1) END PUTCode; PROCEDURE (this: MailMergeField) Next* (): MailMergeField, NEW; BEGIN RETURN ThisMailMergeField(CtlC.GetAny(this, 8)) END Next; PROCEDURE (this: MailMergeField) Previous* (): MailMergeField, NEW; BEGIN RETURN ThisMailMergeField(CtlC.GetAny(this, 9)) END Previous; PROCEDURE (this: MailMergeField) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: MailMergeField) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END Copy; PROCEDURE (this: MailMergeField) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END Cut; PROCEDURE (this: MailMergeField) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 107, NIL); END Delete; (* ---------- MailMergeDataSource, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeDataSource) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeDataSource) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeDataSource) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeDataSource) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Name; PROCEDURE (this: MailMergeDataSource) HeaderSourceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END HeaderSourceName; PROCEDURE (this: MailMergeDataSource) Type* (): WdMailMergeDataSource, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Type; PROCEDURE (this: MailMergeDataSource) HeaderSourceType* (): WdMailMergeDataSource, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END HeaderSourceType; PROCEDURE (this: MailMergeDataSource) ConnectString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END ConnectString; PROCEDURE (this: MailMergeDataSource) QueryString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END QueryString; PROCEDURE (this: MailMergeDataSource) PUTQueryString* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTQueryString; PROCEDURE (this: MailMergeDataSource) ActiveRecord* (): WdMailMergeActiveRecord, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END ActiveRecord; PROCEDURE (this: MailMergeDataSource) PUTActiveRecord* (p1: WdMailMergeActiveRecord), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTActiveRecord; PROCEDURE (this: MailMergeDataSource) FirstRecord* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END FirstRecord; PROCEDURE (this: MailMergeDataSource) PUTFirstRecord* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTFirstRecord; PROCEDURE (this: MailMergeDataSource) LastRecord* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END LastRecord; PROCEDURE (this: MailMergeDataSource) PUTLastRecord* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTLastRecord; PROCEDURE (this: MailMergeDataSource) FieldNames* (): MailMergeFieldNames, NEW; BEGIN RETURN ThisMailMergeFieldNames(CtlC.GetAny(this, 10)) END FieldNames; PROCEDURE (this: MailMergeDataSource) DataFields* (): MailMergeDataFields, NEW; BEGIN RETURN ThisMailMergeDataFields(CtlC.GetAny(this, 11)) END DataFields; PROCEDURE (this: MailMergeDataSource) FindRecord* (FindText: ARRAY OF CHAR; Field: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FindText, arg[1]); CtlC.StrVar(Field, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN CtlC.VarBool(ret) END FindRecord; (* ---------- MailMergeFieldNames, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeFieldNames) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeFieldNames) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeFieldNames) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeFieldNames) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: MailMergeFieldNames) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: MailMergeFieldNames) Item* (Index: CtlT.Any): MailMergeFieldName, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisMailMergeFieldName(CtlC.VarAny(ret)) END Item; (* ---------- MailMergeFieldName, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeFieldName) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeFieldName) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeFieldName) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeFieldName) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: MailMergeFieldName) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; (* ---------- MailMergeDataFields, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeDataFields) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeDataFields) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeDataFields) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeDataFields) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: MailMergeDataFields) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: MailMergeDataFields) Item* (Index: CtlT.Any): MailMergeDataField, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisMailMergeDataField(CtlC.VarAny(ret)) END Item; (* ---------- MailMergeDataField, dual, nonextensible ---------- *) PROCEDURE (this: MailMergeDataField) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMergeDataField) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMergeDataField) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMergeDataField) Value* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Value; PROCEDURE (this: MailMergeDataField) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Name; PROCEDURE (this: MailMergeDataField) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Index; (* ---------- Envelope, dual, nonextensible ---------- *) PROCEDURE (this: Envelope) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Envelope) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Envelope) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Envelope) Address* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1)) END Address; PROCEDURE (this: Envelope) ReturnAddress* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 2)) END ReturnAddress; PROCEDURE (this: Envelope) DefaultPrintBarCode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END DefaultPrintBarCode; PROCEDURE (this: Envelope) PUTDefaultPrintBarCode* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTDefaultPrintBarCode; PROCEDURE (this: Envelope) DefaultPrintFIMA* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END DefaultPrintFIMA; PROCEDURE (this: Envelope) PUTDefaultPrintFIMA* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTDefaultPrintFIMA; PROCEDURE (this: Envelope) DefaultHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END DefaultHeight; PROCEDURE (this: Envelope) PUTDefaultHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTDefaultHeight; PROCEDURE (this: Envelope) DefaultWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END DefaultWidth; PROCEDURE (this: Envelope) PUTDefaultWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTDefaultWidth; PROCEDURE (this: Envelope) DefaultSize* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END DefaultSize; PROCEDURE (this: Envelope) PUTDefaultSize* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTDefaultSize; PROCEDURE (this: Envelope) DefaultOmitReturnAddress* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END DefaultOmitReturnAddress; PROCEDURE (this: Envelope) PUTDefaultOmitReturnAddress* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTDefaultOmitReturnAddress; PROCEDURE (this: Envelope) FeedSource* (): WdPaperTray, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END FeedSource; PROCEDURE (this: Envelope) PUTFeedSource* (p1: WdPaperTray), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTFeedSource; PROCEDURE (this: Envelope) AddressFromLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 13) END AddressFromLeft; PROCEDURE (this: Envelope) PUTAddressFromLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 13, p1) END PUTAddressFromLeft; PROCEDURE (this: Envelope) AddressFromTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 14) END AddressFromTop; PROCEDURE (this: Envelope) PUTAddressFromTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 14, p1) END PUTAddressFromTop; PROCEDURE (this: Envelope) ReturnAddressFromLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 15) END ReturnAddressFromLeft; PROCEDURE (this: Envelope) PUTReturnAddressFromLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 15, p1) END PUTReturnAddressFromLeft; PROCEDURE (this: Envelope) ReturnAddressFromTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 16) END ReturnAddressFromTop; PROCEDURE (this: Envelope) PUTReturnAddressFromTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 16, p1) END PUTReturnAddressFromTop; PROCEDURE (this: Envelope) AddressStyle* (): Style, NEW; BEGIN RETURN ThisStyle(CtlC.GetAny(this, 17)) END AddressStyle; PROCEDURE (this: Envelope) ReturnAddressStyle* (): Style, NEW; BEGIN RETURN ThisStyle(CtlC.GetAny(this, 18)) END ReturnAddressStyle; PROCEDURE (this: Envelope) DefaultOrientation* (): WdEnvelopeOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 19) END DefaultOrientation; PROCEDURE (this: Envelope) PUTDefaultOrientation* (p1: WdEnvelopeOrientation), NEW; BEGIN CtlC.PutInt(this, 19, p1) END PUTDefaultOrientation; PROCEDURE (this: Envelope) DefaultFaceUp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END DefaultFaceUp; PROCEDURE (this: Envelope) PUTDefaultFaceUp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTDefaultFaceUp; PROCEDURE (this: Envelope) Insert* ((* optional *) ExtractAddress: CtlT.Any; Address: CtlT.Any; AutoText: CtlT.Any; OmitReturnAddress: CtlT.Any; ReturnAddress: CtlT.Any; ReturnAutoText: CtlT.Any; PrintBarCode: CtlT.Any; PrintFIMA: CtlT.Any; Size: CtlT.Any; Height: CtlT.Any; Width: CtlT.Any; FeedSource: CtlT.Any; AddressFromLeft: CtlT.Any; AddressFromTop: CtlT.Any; ReturnAddressFromLeft: CtlT.Any; ReturnAddressFromTop: CtlT.Any; DefaultFaceUp: CtlT.Any; DefaultOrientation: CtlT.Any), NEW; VAR arg: ARRAY 18 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExtractAddress, arg[17]); CtlC.AnyVar(Address, arg[16]); CtlC.AnyVar(AutoText, arg[15]); CtlC.AnyVar(OmitReturnAddress, arg[14]); CtlC.AnyVar(ReturnAddress, arg[13]); CtlC.AnyVar(ReturnAutoText, arg[12]); CtlC.AnyVar(PrintBarCode, arg[11]); CtlC.AnyVar(PrintFIMA, arg[10]); CtlC.AnyVar(Size, arg[9]); CtlC.AnyVar(Height, arg[8]); CtlC.AnyVar(Width, arg[7]); CtlC.AnyVar(FeedSource, arg[6]); CtlC.AnyVar(AddressFromLeft, arg[5]); CtlC.AnyVar(AddressFromTop, arg[4]); CtlC.AnyVar(ReturnAddressFromLeft, arg[3]); CtlC.AnyVar(ReturnAddressFromTop, arg[2]); CtlC.AnyVar(DefaultFaceUp, arg[1]); CtlC.AnyVar(DefaultOrientation, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END Insert; PROCEDURE (this: Envelope) PrintOut* ((* optional *) ExtractAddress: CtlT.Any; Address: CtlT.Any; AutoText: CtlT.Any; OmitReturnAddress: CtlT.Any; ReturnAddress: CtlT.Any; ReturnAutoText: CtlT.Any; PrintBarCode: CtlT.Any; PrintFIMA: CtlT.Any; Size: CtlT.Any; Height: CtlT.Any; Width: CtlT.Any; FeedSource: CtlT.Any; AddressFromLeft: CtlT.Any; AddressFromTop: CtlT.Any; ReturnAddressFromLeft: CtlT.Any; ReturnAddressFromTop: CtlT.Any; DefaultFaceUp: CtlT.Any; DefaultOrientation: CtlT.Any), NEW; VAR arg: ARRAY 18 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExtractAddress, arg[17]); CtlC.AnyVar(Address, arg[16]); CtlC.AnyVar(AutoText, arg[15]); CtlC.AnyVar(OmitReturnAddress, arg[14]); CtlC.AnyVar(ReturnAddress, arg[13]); CtlC.AnyVar(ReturnAutoText, arg[12]); CtlC.AnyVar(PrintBarCode, arg[11]); CtlC.AnyVar(PrintFIMA, arg[10]); CtlC.AnyVar(Size, arg[9]); CtlC.AnyVar(Height, arg[8]); CtlC.AnyVar(Width, arg[7]); CtlC.AnyVar(FeedSource, arg[6]); CtlC.AnyVar(AddressFromLeft, arg[5]); CtlC.AnyVar(AddressFromTop, arg[4]); CtlC.AnyVar(ReturnAddressFromLeft, arg[3]); CtlC.AnyVar(ReturnAddressFromTop, arg[2]); CtlC.AnyVar(DefaultFaceUp, arg[1]); CtlC.AnyVar(DefaultOrientation, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END PrintOut; PROCEDURE (this: Envelope) UpdateDocument* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END UpdateDocument; (* ---------- MailingLabel, dual, nonextensible ---------- *) PROCEDURE (this: MailingLabel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailingLabel) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailingLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailingLabel) DefaultPrintBarCode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END DefaultPrintBarCode; PROCEDURE (this: MailingLabel) PUTDefaultPrintBarCode* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTDefaultPrintBarCode; PROCEDURE (this: MailingLabel) DefaultLaserTray* (): WdPaperTray, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END DefaultLaserTray; PROCEDURE (this: MailingLabel) PUTDefaultLaserTray* (p1: WdPaperTray), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTDefaultLaserTray; PROCEDURE (this: MailingLabel) CustomLabels* (): CustomLabels, NEW; BEGIN RETURN ThisCustomLabels(CtlC.GetAny(this, 8)) END CustomLabels; PROCEDURE (this: MailingLabel) DefaultLabelName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 9) END DefaultLabelName; PROCEDURE (this: MailingLabel) PUTDefaultLabelName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 9, p1) END PUTDefaultLabelName; PROCEDURE (this: MailingLabel) CreateNewDocument* ((* optional *) Name: CtlT.Any; Address: CtlT.Any; AutoText: CtlT.Any; ExtractAddress: CtlT.Any; LaserTray: CtlT.Any): Document, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[4]); CtlC.AnyVar(Address, arg[3]); CtlC.AnyVar(AutoText, arg[2]); CtlC.AnyVar(ExtractAddress, arg[1]); CtlC.AnyVar(LaserTray, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN This_Document(CtlC.VarAny(ret)) END CreateNewDocument; PROCEDURE (this: MailingLabel) PrintOut* ((* optional *) Name: CtlT.Any; Address: CtlT.Any; ExtractAddress: CtlT.Any; LaserTray: CtlT.Any; SingleLabel: CtlT.Any; Row: CtlT.Any; Column: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[6]); CtlC.AnyVar(Address, arg[5]); CtlC.AnyVar(ExtractAddress, arg[4]); CtlC.AnyVar(LaserTray, arg[3]); CtlC.AnyVar(SingleLabel, arg[2]); CtlC.AnyVar(Row, arg[1]); CtlC.AnyVar(Column, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END PrintOut; (* ---------- CustomLabels, dual, nonextensible ---------- *) PROCEDURE (this: CustomLabels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CustomLabels) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CustomLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: CustomLabels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: CustomLabels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: CustomLabels) Item* (Index: CtlT.Any): CustomLabel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisCustomLabel(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CustomLabels) Add* (Name: ARRAY OF CHAR; (* optional *) DotMatrix: CtlT.Any): CustomLabel, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.AnyVar(DotMatrix, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisCustomLabel(CtlC.VarAny(ret)) END Add; (* ---------- CustomLabel, dual, nonextensible ---------- *) PROCEDURE (this: CustomLabel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CustomLabel) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CustomLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: CustomLabel) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: CustomLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: CustomLabel) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTName; PROCEDURE (this: CustomLabel) TopMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 3) END TopMargin; PROCEDURE (this: CustomLabel) PUTTopMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 3, p1) END PUTTopMargin; PROCEDURE (this: CustomLabel) SideMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 4) END SideMargin; PROCEDURE (this: CustomLabel) PUTSideMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 4, p1) END PUTSideMargin; PROCEDURE (this: CustomLabel) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 5) END Height; PROCEDURE (this: CustomLabel) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 5, p1) END PUTHeight; PROCEDURE (this: CustomLabel) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 6) END Width; PROCEDURE (this: CustomLabel) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 6, p1) END PUTWidth; PROCEDURE (this: CustomLabel) VerticalPitch* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END VerticalPitch; PROCEDURE (this: CustomLabel) PUTVerticalPitch* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTVerticalPitch; PROCEDURE (this: CustomLabel) HorizontalPitch* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 8) END HorizontalPitch; PROCEDURE (this: CustomLabel) PUTHorizontalPitch* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 8, p1) END PUTHorizontalPitch; PROCEDURE (this: CustomLabel) NumberAcross* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END NumberAcross; PROCEDURE (this: CustomLabel) PUTNumberAcross* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTNumberAcross; PROCEDURE (this: CustomLabel) NumberDown* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END NumberDown; PROCEDURE (this: CustomLabel) PUTNumberDown* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTNumberDown; PROCEDURE (this: CustomLabel) DotMatrix* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END DotMatrix; PROCEDURE (this: CustomLabel) PageSize* (): WdCustomLabelPageSize, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END PageSize; PROCEDURE (this: CustomLabel) PUTPageSize* (p1: WdCustomLabelPageSize), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTPageSize; PROCEDURE (this: CustomLabel) Valid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END Valid; PROCEDURE (this: CustomLabel) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- TablesOfContents, dual, nonextensible ---------- *) PROCEDURE (this: TablesOfContents) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TablesOfContents) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TablesOfContents) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TablesOfContents) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TablesOfContents) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: TablesOfContents) Format* (): WdTocFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Format; PROCEDURE (this: TablesOfContents) PUTFormat* (p1: WdTocFormat), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTFormat; PROCEDURE (this: TablesOfContents) Item* (Index: INTEGER): TableOfContents, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTableOfContents(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TablesOfContents) AddOld* (range: Range; (* optional *) UseHeadingStyles: CtlT.Any; UpperHeadingLevel: CtlT.Any; LowerHeadingLevel: CtlT.Any; UseFields: CtlT.Any; TableID: CtlT.Any; RightAlignPageNumbers: CtlT.Any; IncludePageNumbers: CtlT.Any; AddedStyles: CtlT.Any): TableOfContents, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[8]); CtlC.AnyVar(UseHeadingStyles, arg[7]); CtlC.AnyVar(UpperHeadingLevel, arg[6]); CtlC.AnyVar(LowerHeadingLevel, arg[5]); CtlC.AnyVar(UseFields, arg[4]); CtlC.AnyVar(TableID, arg[3]); CtlC.AnyVar(RightAlignPageNumbers, arg[2]); CtlC.AnyVar(IncludePageNumbers, arg[1]); CtlC.AnyVar(AddedStyles, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisTableOfContents(CtlC.VarAny(ret)) END AddOld; PROCEDURE (this: TablesOfContents) MarkEntry* (range: Range; (* optional *) Entry: CtlT.Any; EntryAutoText: CtlT.Any; TableID: CtlT.Any; Level: CtlT.Any): Field, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[4]); CtlC.AnyVar(Entry, arg[3]); CtlC.AnyVar(EntryAutoText, arg[2]); CtlC.AnyVar(TableID, arg[1]); CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END MarkEntry; PROCEDURE (this: TablesOfContents) Add* (range: Range; (* optional *) UseHeadingStyles: CtlT.Any; UpperHeadingLevel: CtlT.Any; LowerHeadingLevel: CtlT.Any; UseFields: CtlT.Any; TableID: CtlT.Any; RightAlignPageNumbers: CtlT.Any; IncludePageNumbers: CtlT.Any; AddedStyles: CtlT.Any; UseHyperlinks: CtlT.Any; HidePageNumbersInWeb: CtlT.Any): TableOfContents, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[10]); CtlC.AnyVar(UseHeadingStyles, arg[9]); CtlC.AnyVar(UpperHeadingLevel, arg[8]); CtlC.AnyVar(LowerHeadingLevel, arg[7]); CtlC.AnyVar(UseFields, arg[6]); CtlC.AnyVar(TableID, arg[5]); CtlC.AnyVar(RightAlignPageNumbers, arg[4]); CtlC.AnyVar(IncludePageNumbers, arg[3]); CtlC.AnyVar(AddedStyles, arg[2]); CtlC.AnyVar(UseHyperlinks, arg[1]); CtlC.AnyVar(HidePageNumbersInWeb, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisTableOfContents(CtlC.VarAny(ret)) END Add; (* ---------- TableOfContents, dual, nonextensible ---------- *) PROCEDURE (this: TableOfContents) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TableOfContents) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TableOfContents) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TableOfContents) UseHeadingStyles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END UseHeadingStyles; PROCEDURE (this: TableOfContents) PUTUseHeadingStyles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTUseHeadingStyles; PROCEDURE (this: TableOfContents) UseFields* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END UseFields; PROCEDURE (this: TableOfContents) PUTUseFields* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTUseFields; PROCEDURE (this: TableOfContents) UpperHeadingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END UpperHeadingLevel; PROCEDURE (this: TableOfContents) PUTUpperHeadingLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTUpperHeadingLevel; PROCEDURE (this: TableOfContents) LowerHeadingLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END LowerHeadingLevel; PROCEDURE (this: TableOfContents) PUTLowerHeadingLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTLowerHeadingLevel; PROCEDURE (this: TableOfContents) TableID* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END TableID; PROCEDURE (this: TableOfContents) PUTTableID* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 5, p1) END PUTTableID; PROCEDURE (this: TableOfContents) HeadingStyles* (): HeadingStyles, NEW; BEGIN RETURN ThisHeadingStyles(CtlC.GetAny(this, 6)) END HeadingStyles; PROCEDURE (this: TableOfContents) RightAlignPageNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END RightAlignPageNumbers; PROCEDURE (this: TableOfContents) PUTRightAlignPageNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTRightAlignPageNumbers; PROCEDURE (this: TableOfContents) IncludePageNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END IncludePageNumbers; PROCEDURE (this: TableOfContents) PUTIncludePageNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTIncludePageNumbers; PROCEDURE (this: TableOfContents) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 9)) END Range; PROCEDURE (this: TableOfContents) TabLeader* (): WdTabLeader, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END TabLeader; PROCEDURE (this: TableOfContents) PUTTabLeader* (p1: WdTabLeader), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTTabLeader; PROCEDURE (this: TableOfContents) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: TableOfContents) UpdatePageNumbers* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END UpdatePageNumbers; PROCEDURE (this: TableOfContents) Update* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Update; PROCEDURE (this: TableOfContents) UseHyperlinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END UseHyperlinks; PROCEDURE (this: TableOfContents) PUTUseHyperlinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 11, p1) END PUTUseHyperlinks; PROCEDURE (this: TableOfContents) HidePageNumbersInWeb* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END HidePageNumbersInWeb; PROCEDURE (this: TableOfContents) PUTHidePageNumbersInWeb* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTHidePageNumbersInWeb; (* ---------- TablesOfAuthorities, dual, nonextensible ---------- *) PROCEDURE (this: TablesOfAuthorities) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TablesOfAuthorities) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TablesOfAuthorities) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TablesOfAuthorities) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TablesOfAuthorities) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: TablesOfAuthorities) Format* (): WdToaFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Format; PROCEDURE (this: TablesOfAuthorities) PUTFormat* (p1: WdToaFormat), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTFormat; PROCEDURE (this: TablesOfAuthorities) Item* (Index: INTEGER): TableOfAuthorities, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTableOfAuthorities(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TablesOfAuthorities) Add* (range: Range; (* optional *) Category: CtlT.Any; Bookmark: CtlT.Any; Passim: CtlT.Any; KeepEntryFormatting: CtlT.Any; Separator: CtlT.Any; IncludeSequenceName: CtlT.Any; EntrySeparator: CtlT.Any; PageRangeSeparator: CtlT.Any; IncludeCategoryHeader: CtlT.Any; PageNumberSeparator: CtlT.Any): TableOfAuthorities, NEW; VAR arg: ARRAY 11 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[10]); CtlC.AnyVar(Category, arg[9]); CtlC.AnyVar(Bookmark, arg[8]); CtlC.AnyVar(Passim, arg[7]); CtlC.AnyVar(KeepEntryFormatting, arg[6]); CtlC.AnyVar(Separator, arg[5]); CtlC.AnyVar(IncludeSequenceName, arg[4]); CtlC.AnyVar(EntrySeparator, arg[3]); CtlC.AnyVar(PageRangeSeparator, arg[2]); CtlC.AnyVar(IncludeCategoryHeader, arg[1]); CtlC.AnyVar(PageNumberSeparator, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisTableOfAuthorities(CtlC.VarAny(ret)) END Add; PROCEDURE (this: TablesOfAuthorities) NextCitation* (ShortCitation: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(ShortCitation, arg[0]); CtlC.CallParMethod(this, 103, arg, NIL); END NextCitation; PROCEDURE (this: TablesOfAuthorities) MarkCitation* (range: Range; ShortCitation: ARRAY OF CHAR; (* optional *) LongCitation: CtlT.Any; LongCitationAutoText: CtlT.Any; Category: CtlT.Any): Field, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[4]); CtlC.StrVar(ShortCitation, arg[3]); CtlC.AnyVar(LongCitation, arg[2]); CtlC.AnyVar(LongCitationAutoText, arg[1]); CtlC.AnyVar(Category, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END MarkCitation; PROCEDURE (this: TablesOfAuthorities) MarkAllCitations* (ShortCitation: ARRAY OF CHAR; (* optional *) LongCitation: CtlT.Any; LongCitationAutoText: CtlT.Any; Category: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.StrVar(ShortCitation, arg[3]); CtlC.AnyVar(LongCitation, arg[2]); CtlC.AnyVar(LongCitationAutoText, arg[1]); CtlC.AnyVar(Category, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END MarkAllCitations; (* ---------- TableOfAuthorities, dual, nonextensible ---------- *) PROCEDURE (this: TableOfAuthorities) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TableOfAuthorities) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TableOfAuthorities) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TableOfAuthorities) Passim* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END Passim; PROCEDURE (this: TableOfAuthorities) PUTPassim* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTPassim; PROCEDURE (this: TableOfAuthorities) KeepEntryFormatting* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END KeepEntryFormatting; PROCEDURE (this: TableOfAuthorities) PUTKeepEntryFormatting* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTKeepEntryFormatting; PROCEDURE (this: TableOfAuthorities) Category* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Category; PROCEDURE (this: TableOfAuthorities) PUTCategory* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTCategory; PROCEDURE (this: TableOfAuthorities) Bookmark* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Bookmark; PROCEDURE (this: TableOfAuthorities) PUTBookmark* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 4, p1) END PUTBookmark; PROCEDURE (this: TableOfAuthorities) Separator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END Separator; PROCEDURE (this: TableOfAuthorities) PUTSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 5, p1) END PUTSeparator; PROCEDURE (this: TableOfAuthorities) IncludeSequenceName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END IncludeSequenceName; PROCEDURE (this: TableOfAuthorities) PUTIncludeSequenceName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 6, p1) END PUTIncludeSequenceName; PROCEDURE (this: TableOfAuthorities) EntrySeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END EntrySeparator; PROCEDURE (this: TableOfAuthorities) PUTEntrySeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 7, p1) END PUTEntrySeparator; PROCEDURE (this: TableOfAuthorities) PageRangeSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END PageRangeSeparator; PROCEDURE (this: TableOfAuthorities) PUTPageRangeSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 8, p1) END PUTPageRangeSeparator; PROCEDURE (this: TableOfAuthorities) IncludeCategoryHeader* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END IncludeCategoryHeader; PROCEDURE (this: TableOfAuthorities) PUTIncludeCategoryHeader* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTIncludeCategoryHeader; PROCEDURE (this: TableOfAuthorities) PageNumberSeparator* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 10) END PageNumberSeparator; PROCEDURE (this: TableOfAuthorities) PUTPageNumberSeparator* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 10, p1) END PUTPageNumberSeparator; PROCEDURE (this: TableOfAuthorities) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 11)) END Range; PROCEDURE (this: TableOfAuthorities) TabLeader* (): WdTabLeader, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END TabLeader; PROCEDURE (this: TableOfAuthorities) PUTTabLeader* (p1: WdTabLeader), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTTabLeader; PROCEDURE (this: TableOfAuthorities) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: TableOfAuthorities) Update* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Update; (* ---------- Dialogs, dual, nonextensible ---------- *) PROCEDURE (this: Dialogs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Dialogs) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Dialogs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Dialogs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Dialogs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Dialogs) Item* (Index: WdWordDialog): Dialog, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisDialog(CtlC.VarAny(ret)) END Item; (* ---------- Dialog, dual ---------- *) PROCEDURE (this: Dialog) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 32003)) END Application; PROCEDURE (this: Dialog) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 32004) END Creator; PROCEDURE (this: Dialog) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 32005) END Parent; PROCEDURE (this: Dialog) DefaultTab* (): WdWordDialogTab, NEW; BEGIN RETURN CtlC.GetInt(this, 32002) END DefaultTab; PROCEDURE (this: Dialog) PUTDefaultTab* (p1: WdWordDialogTab), NEW; BEGIN CtlC.PutInt(this, 32002, p1) END PUTDefaultTab; PROCEDURE (this: Dialog) Type* (): WdWordDialog, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Type; PROCEDURE (this: Dialog) Show* ((* optional *) TimeOut: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(TimeOut, arg[0]); CtlC.CallParMethod(this, 336, arg, ret); RETURN CtlC.VarInt(ret) END Show; PROCEDURE (this: Dialog) Display* ((* optional *) TimeOut: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(TimeOut, arg[0]); CtlC.CallParMethod(this, 338, arg, ret); RETURN CtlC.VarInt(ret) END Display; PROCEDURE (this: Dialog) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 32001, NIL); END Execute; PROCEDURE (this: Dialog) Update* (), NEW; BEGIN CtlC.CallMethod(this, 302, NIL); END Update; PROCEDURE (this: Dialog) CommandName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 32006) END CommandName; (* ---------- PageSetup, dual, nonextensible ---------- *) PROCEDURE (this: PageSetup) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: PageSetup) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: PageSetup) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PageSetup) TopMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END TopMargin; PROCEDURE (this: PageSetup) PUTTopMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTTopMargin; PROCEDURE (this: PageSetup) BottomMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 101) END BottomMargin; PROCEDURE (this: PageSetup) PUTBottomMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 101, p1) END PUTBottomMargin; PROCEDURE (this: PageSetup) LeftMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END LeftMargin; PROCEDURE (this: PageSetup) PUTLeftMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTLeftMargin; PROCEDURE (this: PageSetup) RightMargin* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END RightMargin; PROCEDURE (this: PageSetup) PUTRightMargin* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTRightMargin; PROCEDURE (this: PageSetup) Gutter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END Gutter; PROCEDURE (this: PageSetup) PUTGutter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTGutter; PROCEDURE (this: PageSetup) PageWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END PageWidth; PROCEDURE (this: PageSetup) PUTPageWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTPageWidth; PROCEDURE (this: PageSetup) PageHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END PageHeight; PROCEDURE (this: PageSetup) PUTPageHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTPageHeight; PROCEDURE (this: PageSetup) Orientation* (): WdOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END Orientation; PROCEDURE (this: PageSetup) PUTOrientation* (p1: WdOrientation), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTOrientation; PROCEDURE (this: PageSetup) FirstPageTray* (): WdPaperTray, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END FirstPageTray; PROCEDURE (this: PageSetup) PUTFirstPageTray* (p1: WdPaperTray), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTFirstPageTray; PROCEDURE (this: PageSetup) OtherPagesTray* (): WdPaperTray, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END OtherPagesTray; PROCEDURE (this: PageSetup) PUTOtherPagesTray* (p1: WdPaperTray), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTOtherPagesTray; PROCEDURE (this: PageSetup) VerticalAlignment* (): WdVerticalAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END VerticalAlignment; PROCEDURE (this: PageSetup) PUTVerticalAlignment* (p1: WdVerticalAlignment), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTVerticalAlignment; PROCEDURE (this: PageSetup) MirrorMargins* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END MirrorMargins; PROCEDURE (this: PageSetup) PUTMirrorMargins* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTMirrorMargins; PROCEDURE (this: PageSetup) HeaderDistance* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 112) END HeaderDistance; PROCEDURE (this: PageSetup) PUTHeaderDistance* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 112, p1) END PUTHeaderDistance; PROCEDURE (this: PageSetup) FooterDistance* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END FooterDistance; PROCEDURE (this: PageSetup) PUTFooterDistance* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTFooterDistance; PROCEDURE (this: PageSetup) SectionStart* (): WdSectionStart, NEW; BEGIN RETURN CtlC.GetInt(this, 114) END SectionStart; PROCEDURE (this: PageSetup) PUTSectionStart* (p1: WdSectionStart), NEW; BEGIN CtlC.PutInt(this, 114, p1) END PUTSectionStart; PROCEDURE (this: PageSetup) OddAndEvenPagesHeaderFooter* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 115) END OddAndEvenPagesHeaderFooter; PROCEDURE (this: PageSetup) PUTOddAndEvenPagesHeaderFooter* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 115, p1) END PUTOddAndEvenPagesHeaderFooter; PROCEDURE (this: PageSetup) DifferentFirstPageHeaderFooter* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 116) END DifferentFirstPageHeaderFooter; PROCEDURE (this: PageSetup) PUTDifferentFirstPageHeaderFooter* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 116, p1) END PUTDifferentFirstPageHeaderFooter; PROCEDURE (this: PageSetup) SuppressEndnotes* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END SuppressEndnotes; PROCEDURE (this: PageSetup) PUTSuppressEndnotes* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTSuppressEndnotes; PROCEDURE (this: PageSetup) LineNumbering* (): LineNumbering, NEW; BEGIN RETURN ThisLineNumbering(CtlC.GetAny(this, 118)) END LineNumbering; PROCEDURE (this: PageSetup) PUTLineNumbering* (p1: LineNumbering), NEW; BEGIN CtlC.PutObj(this, 118, p1) END PUTLineNumbering; PROCEDURE (this: PageSetup) TextColumns* (): TextColumns, NEW; BEGIN RETURN ThisTextColumns(CtlC.GetAny(this, 119)) END TextColumns; PROCEDURE (this: PageSetup) PUTTextColumns* (p1: TextColumns), NEW; BEGIN CtlC.PutObj(this, 119, p1) END PUTTextColumns; PROCEDURE (this: PageSetup) PaperSize* (): WdPaperSize, NEW; BEGIN RETURN CtlC.GetInt(this, 120) END PaperSize; PROCEDURE (this: PageSetup) PUTPaperSize* (p1: WdPaperSize), NEW; BEGIN CtlC.PutInt(this, 120, p1) END PUTPaperSize; PROCEDURE (this: PageSetup) TwoPagesOnOne* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 121) END TwoPagesOnOne; PROCEDURE (this: PageSetup) PUTTwoPagesOnOne* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 121, p1) END PUTTwoPagesOnOne; PROCEDURE (this: PageSetup) GutterOnTop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 122) END GutterOnTop; PROCEDURE (this: PageSetup) PUTGutterOnTop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 122, p1) END PUTGutterOnTop; PROCEDURE (this: PageSetup) CharsLine* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END CharsLine; PROCEDURE (this: PageSetup) PUTCharsLine* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTCharsLine; PROCEDURE (this: PageSetup) LinesPage* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 124) END LinesPage; PROCEDURE (this: PageSetup) PUTLinesPage* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 124, p1) END PUTLinesPage; PROCEDURE (this: PageSetup) ShowGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 128) END ShowGrid; PROCEDURE (this: PageSetup) PUTShowGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 128, p1) END PUTShowGrid; PROCEDURE (this: PageSetup) TogglePortrait* (), NEW; BEGIN CtlC.CallMethod(this, 201, NIL); END TogglePortrait; PROCEDURE (this: PageSetup) SetAsTemplateDefault* (), NEW; BEGIN CtlC.CallMethod(this, 202, NIL); END SetAsTemplateDefault; PROCEDURE (this: PageSetup) GutterStyle* (): WdGutterStyleOld, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END GutterStyle; PROCEDURE (this: PageSetup) PUTGutterStyle* (p1: WdGutterStyleOld), NEW; BEGIN CtlC.PutInt(this, 129, p1) END PUTGutterStyle; PROCEDURE (this: PageSetup) SectionDirection* (): WdSectionDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 130) END SectionDirection; PROCEDURE (this: PageSetup) PUTSectionDirection* (p1: WdSectionDirection), NEW; BEGIN CtlC.PutInt(this, 130, p1) END PUTSectionDirection; PROCEDURE (this: PageSetup) LayoutMode* (): WdLayoutMode, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END LayoutMode; PROCEDURE (this: PageSetup) PUTLayoutMode* (p1: WdLayoutMode), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTLayoutMode; PROCEDURE (this: PageSetup) GutterPos* (): WdGutterStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 1222) END GutterPos; PROCEDURE (this: PageSetup) PUTGutterPos* (p1: WdGutterStyle), NEW; BEGIN CtlC.PutInt(this, 1222, p1) END PUTGutterPos; (* ---------- LineNumbering, dual, nonextensible ---------- *) PROCEDURE (this: LineNumbering) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: LineNumbering) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: LineNumbering) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: LineNumbering) RestartMode* (): WdNumberingRule, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END RestartMode; PROCEDURE (this: LineNumbering) PUTRestartMode* (p1: WdNumberingRule), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTRestartMode; PROCEDURE (this: LineNumbering) StartingNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END StartingNumber; PROCEDURE (this: LineNumbering) PUTStartingNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTStartingNumber; PROCEDURE (this: LineNumbering) DistanceFromText* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END DistanceFromText; PROCEDURE (this: LineNumbering) PUTDistanceFromText* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTDistanceFromText; PROCEDURE (this: LineNumbering) CountBy* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END CountBy; PROCEDURE (this: LineNumbering) PUTCountBy* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTCountBy; PROCEDURE (this: LineNumbering) Active* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Active; PROCEDURE (this: LineNumbering) PUTActive* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTActive; (* ---------- TextColumns, dual, nonextensible ---------- *) PROCEDURE (this: TextColumns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TextColumns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: TextColumns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TextColumns) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TextColumns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TextColumns) EvenlySpaced* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EvenlySpaced; PROCEDURE (this: TextColumns) PUTEvenlySpaced* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTEvenlySpaced; PROCEDURE (this: TextColumns) LineBetween* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END LineBetween; PROCEDURE (this: TextColumns) PUTLineBetween* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTLineBetween; PROCEDURE (this: TextColumns) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Width; PROCEDURE (this: TextColumns) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTWidth; PROCEDURE (this: TextColumns) Spacing* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END Spacing; PROCEDURE (this: TextColumns) PUTSpacing* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTSpacing; PROCEDURE (this: TextColumns) Item* (Index: INTEGER): TextColumn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTextColumn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: TextColumns) Add* ((* optional *) Width: CtlT.Any; Spacing: CtlT.Any; EvenlySpaced: CtlT.Any): TextColumn, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Width, arg[2]); CtlC.AnyVar(Spacing, arg[1]); CtlC.AnyVar(EvenlySpaced, arg[0]); CtlC.CallParMethod(this, 201, arg, ret); RETURN ThisTextColumn(CtlC.VarAny(ret)) END Add; PROCEDURE (this: TextColumns) SetCount* (NumColumns: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(NumColumns, arg[0]); CtlC.CallParMethod(this, 202, arg, NIL); END SetCount; PROCEDURE (this: TextColumns) FlowDirection* (): WdFlowDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END FlowDirection; PROCEDURE (this: TextColumns) PUTFlowDirection* (p1: WdFlowDirection), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTFlowDirection; (* ---------- TextColumn, dual, nonextensible ---------- *) PROCEDURE (this: TextColumn) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TextColumn) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TextColumn) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TextColumn) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Width; PROCEDURE (this: TextColumn) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTWidth; PROCEDURE (this: TextColumn) SpaceAfter* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 101) END SpaceAfter; PROCEDURE (this: TextColumn) PUTSpaceAfter* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 101, p1) END PUTSpaceAfter; (* ---------- Selection, dual, nonextensible ---------- *) PROCEDURE (this: Selection) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Text; PROCEDURE (this: Selection) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTText; PROCEDURE (this: Selection) FormattedText* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 2)) END FormattedText; PROCEDURE (this: Selection) PUTFormattedText* (p1: Range), NEW; BEGIN CtlC.PutObj(this, 2, p1) END PUTFormattedText; PROCEDURE (this: Selection) Start* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Start; PROCEDURE (this: Selection) PUTStart* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTStart; PROCEDURE (this: Selection) End* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END End; PROCEDURE (this: Selection) PUTEnd* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTEnd; PROCEDURE (this: Selection) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 5)) END Font; PROCEDURE (this: Selection) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 5, p1) END PUTFont; PROCEDURE (this: Selection) Type* (): WdSelectionType, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Type; PROCEDURE (this: Selection) StoryType* (): WdStoryType, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END StoryType; PROCEDURE (this: Selection) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 8) END Style; PROCEDURE (this: Selection) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 8, p1) END PUTStyle; PROCEDURE (this: Selection) Tables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 50)) END Tables; PROCEDURE (this: Selection) Words* (): Words, NEW; BEGIN RETURN ThisWords(CtlC.GetAny(this, 51)) END Words; PROCEDURE (this: Selection) Sentences* (): Sentences, NEW; BEGIN RETURN ThisSentences(CtlC.GetAny(this, 52)) END Sentences; PROCEDURE (this: Selection) Characters* (): Characters, NEW; BEGIN RETURN ThisCharacters(CtlC.GetAny(this, 53)) END Characters; PROCEDURE (this: Selection) Footnotes* (): Footnotes, NEW; BEGIN RETURN ThisFootnotes(CtlC.GetAny(this, 54)) END Footnotes; PROCEDURE (this: Selection) Endnotes* (): Endnotes, NEW; BEGIN RETURN ThisEndnotes(CtlC.GetAny(this, 55)) END Endnotes; PROCEDURE (this: Selection) Comments* (): Comments, NEW; BEGIN RETURN ThisComments(CtlC.GetAny(this, 56)) END Comments; PROCEDURE (this: Selection) Cells* (): Cells, NEW; BEGIN RETURN ThisCells(CtlC.GetAny(this, 57)) END Cells; PROCEDURE (this: Selection) Sections* (): Sections, NEW; BEGIN RETURN ThisSections(CtlC.GetAny(this, 58)) END Sections; PROCEDURE (this: Selection) Paragraphs* (): Paragraphs, NEW; BEGIN RETURN ThisParagraphs(CtlC.GetAny(this, 59)) END Paragraphs; PROCEDURE (this: Selection) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: Selection) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: Selection) Shading* (): Shading, NEW; BEGIN RETURN ThisShading(CtlC.GetAny(this, 61)) END Shading; PROCEDURE (this: Selection) Fields* (): Fields, NEW; BEGIN RETURN ThisFields(CtlC.GetAny(this, 64)) END Fields; PROCEDURE (this: Selection) FormFields* (): FormFields, NEW; BEGIN RETURN ThisFormFields(CtlC.GetAny(this, 65)) END FormFields; PROCEDURE (this: Selection) Frames* (): Frames, NEW; BEGIN RETURN ThisFrames(CtlC.GetAny(this, 66)) END Frames; PROCEDURE (this: Selection) ParagraphFormat* (): ParagraphFormat, NEW; BEGIN RETURN This_ParagraphFormat(CtlC.GetAny(this, 1102)) END ParagraphFormat; PROCEDURE (this: Selection) PUTParagraphFormat* (p1: ParagraphFormat), NEW; BEGIN CtlC.PutObj(this, 1102, p1) END PUTParagraphFormat; PROCEDURE (this: Selection) PageSetup* (): PageSetup, NEW; BEGIN RETURN ThisPageSetup(CtlC.GetAny(this, 1101)) END PageSetup; PROCEDURE (this: Selection) PUTPageSetup* (p1: PageSetup), NEW; BEGIN CtlC.PutObj(this, 1101, p1) END PUTPageSetup; PROCEDURE (this: Selection) Bookmarks* (): Bookmarks, NEW; BEGIN RETURN ThisBookmarks(CtlC.GetAny(this, 75)) END Bookmarks; PROCEDURE (this: Selection) StoryLength* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 152) END StoryLength; PROCEDURE (this: Selection) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 153) END LanguageID; PROCEDURE (this: Selection) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 153, p1) END PUTLanguageID; PROCEDURE (this: Selection) LanguageIDFarEast* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 154) END LanguageIDFarEast; PROCEDURE (this: Selection) PUTLanguageIDFarEast* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 154, p1) END PUTLanguageIDFarEast; PROCEDURE (this: Selection) LanguageIDOther* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 155) END LanguageIDOther; PROCEDURE (this: Selection) PUTLanguageIDOther* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 155, p1) END PUTLanguageIDOther; PROCEDURE (this: Selection) Hyperlinks* (): Hyperlinks, NEW; BEGIN RETURN ThisHyperlinks(CtlC.GetAny(this, 156)) END Hyperlinks; PROCEDURE (this: Selection) Columns* (): Columns, NEW; BEGIN RETURN ThisColumns(CtlC.GetAny(this, 302)) END Columns; PROCEDURE (this: Selection) Rows* (): Rows, NEW; BEGIN RETURN ThisRows(CtlC.GetAny(this, 303)) END Rows; PROCEDURE (this: Selection) HeaderFooter* (): HeaderFooter, NEW; BEGIN RETURN ThisHeaderFooter(CtlC.GetAny(this, 306)) END HeaderFooter; PROCEDURE (this: Selection) IsEndOfRowMark* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 307) END IsEndOfRowMark; PROCEDURE (this: Selection) BookmarkID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 308) END BookmarkID; PROCEDURE (this: Selection) PreviousBookmarkID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 309) END PreviousBookmarkID; PROCEDURE (this: Selection) Find* (): Find, NEW; BEGIN RETURN ThisFind(CtlC.GetAny(this, 262)) END Find; PROCEDURE (this: Selection) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 400)) END Range; PROCEDURE (this: Selection) Information* (Type: WdInformation): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[0]); CtlC.CallGetMethod(this, 401, arg, ret); RETURN CtlC.VarAny(ret) END Information; PROCEDURE (this: Selection) Flags* (): WdSelectionFlags, NEW; BEGIN RETURN CtlC.GetInt(this, 402) END Flags; PROCEDURE (this: Selection) PUTFlags* (p1: WdSelectionFlags), NEW; BEGIN CtlC.PutInt(this, 402, p1) END PUTFlags; PROCEDURE (this: Selection) Active* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 403) END Active; PROCEDURE (this: Selection) StartIsActive* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 404) END StartIsActive; PROCEDURE (this: Selection) PUTStartIsActive* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 404, p1) END PUTStartIsActive; PROCEDURE (this: Selection) IPAtEndOfLine* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 405) END IPAtEndOfLine; PROCEDURE (this: Selection) ExtendMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 406) END ExtendMode; PROCEDURE (this: Selection) PUTExtendMode* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 406, p1) END PUTExtendMode; PROCEDURE (this: Selection) ColumnSelectMode* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 407) END ColumnSelectMode; PROCEDURE (this: Selection) PUTColumnSelectMode* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 407, p1) END PUTColumnSelectMode; PROCEDURE (this: Selection) Orientation* (): WdTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 410) END Orientation; PROCEDURE (this: Selection) PUTOrientation* (p1: WdTextOrientation), NEW; BEGIN CtlC.PutInt(this, 410, p1) END PUTOrientation; PROCEDURE (this: Selection) InlineShapes* (): InlineShapes, NEW; BEGIN RETURN ThisInlineShapes(CtlC.GetAny(this, 411)) END InlineShapes; PROCEDURE (this: Selection) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Selection) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Selection) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Selection) Document* (): Document, NEW; BEGIN RETURN This_Document(CtlC.GetAny(this, 1003)) END Document; PROCEDURE (this: Selection) ShapeRange* (): ShapeRange, NEW; BEGIN RETURN ThisShapeRange(CtlC.GetAny(this, 1004)) END ShapeRange; PROCEDURE (this: Selection) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: Selection) SetRange* (Start: INTEGER; End: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Start, arg[1]); CtlC.IntVar(End, arg[0]); CtlC.CallParMethod(this, 100, arg, NIL); END SetRange; PROCEDURE (this: Selection) Collapse* ((* optional *) Direction: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Direction, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END Collapse; PROCEDURE (this: Selection) InsertBefore* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END InsertBefore; PROCEDURE (this: Selection) InsertAfter* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END InsertAfter; PROCEDURE (this: Selection) Next* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Next; PROCEDURE (this: Selection) Previous* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): Range, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 106, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Previous; PROCEDURE (this: Selection) StartOf* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 107, arg, ret); RETURN CtlC.VarInt(ret) END StartOf; PROCEDURE (this: Selection) EndOf* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 108, arg, ret); RETURN CtlC.VarInt(ret) END EndOf; PROCEDURE (this: Selection) Move* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 109, arg, ret); RETURN CtlC.VarInt(ret) END Move; PROCEDURE (this: Selection) MoveStart* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 110, arg, ret); RETURN CtlC.VarInt(ret) END MoveStart; PROCEDURE (this: Selection) MoveEnd* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 111, arg, ret); RETURN CtlC.VarInt(ret) END MoveEnd; PROCEDURE (this: Selection) MoveWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 112, arg, ret); RETURN CtlC.VarInt(ret) END MoveWhile; PROCEDURE (this: Selection) MoveStartWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 113, arg, ret); RETURN CtlC.VarInt(ret) END MoveStartWhile; PROCEDURE (this: Selection) MoveEndWhile* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 114, arg, ret); RETURN CtlC.VarInt(ret) END MoveEndWhile; PROCEDURE (this: Selection) MoveUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 115, arg, ret); RETURN CtlC.VarInt(ret) END MoveUntil; PROCEDURE (this: Selection) MoveStartUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 116, arg, ret); RETURN CtlC.VarInt(ret) END MoveStartUntil; PROCEDURE (this: Selection) MoveEndUntil* (Cset: CtlT.Any; (* optional *) Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Cset, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 117, arg, ret); RETURN CtlC.VarInt(ret) END MoveEndUntil; PROCEDURE (this: Selection) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 119, NIL); END Cut; PROCEDURE (this: Selection) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 120, NIL); END Copy; PROCEDURE (this: Selection) Paste* (), NEW; BEGIN CtlC.CallMethod(this, 121, NIL); END Paste; PROCEDURE (this: Selection) InsertBreak* ((* optional *) Type: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Type, arg[0]); CtlC.CallParMethod(this, 122, arg, NIL); END InsertBreak; PROCEDURE (this: Selection) InsertFile* (FileName: ARRAY OF CHAR; (* optional *) Range: CtlT.Any; ConfirmConversions: CtlT.Any; Link: CtlT.Any; Attachment: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[4]); CtlC.AnyVar(Range, arg[3]); CtlC.AnyVar(ConfirmConversions, arg[2]); CtlC.AnyVar(Link, arg[1]); CtlC.AnyVar(Attachment, arg[0]); CtlC.CallParMethod(this, 123, arg, NIL); END InsertFile; PROCEDURE (this: Selection) InStory* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 125, arg, ret); RETURN CtlC.VarBool(ret) END InStory; PROCEDURE (this: Selection) InRange* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 126, arg, ret); RETURN CtlC.VarBool(ret) END InRange; PROCEDURE (this: Selection) Delete* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Count, arg[0]); CtlC.CallParMethod(this, 127, arg, ret); RETURN CtlC.VarInt(ret) END Delete; PROCEDURE (this: Selection) Expand* ((* optional *) Unit: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[0]); CtlC.CallParMethod(this, 129, arg, ret); RETURN CtlC.VarInt(ret) END Expand; PROCEDURE (this: Selection) InsertParagraph* (), NEW; BEGIN CtlC.CallMethod(this, 160, NIL); END InsertParagraph; PROCEDURE (this: Selection) InsertParagraphAfter* (), NEW; BEGIN CtlC.CallMethod(this, 161, NIL); END InsertParagraphAfter; PROCEDURE (this: Selection) ConvertToTableOld* ((* optional *) Separator: CtlT.Any; NumRows: CtlT.Any; NumColumns: CtlT.Any; InitialColumnWidth: CtlT.Any; Format: CtlT.Any; ApplyBorders: CtlT.Any; ApplyShading: CtlT.Any; ApplyFont: CtlT.Any; ApplyColor: CtlT.Any; ApplyHeadingRows: CtlT.Any; ApplyLastRow: CtlT.Any; ApplyFirstColumn: CtlT.Any; ApplyLastColumn: CtlT.Any; AutoFit: CtlT.Any): Table, NEW; VAR arg: ARRAY 14 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[13]); CtlC.AnyVar(NumRows, arg[12]); CtlC.AnyVar(NumColumns, arg[11]); CtlC.AnyVar(InitialColumnWidth, arg[10]); CtlC.AnyVar(Format, arg[9]); CtlC.AnyVar(ApplyBorders, arg[8]); CtlC.AnyVar(ApplyShading, arg[7]); CtlC.AnyVar(ApplyFont, arg[6]); CtlC.AnyVar(ApplyColor, arg[5]); CtlC.AnyVar(ApplyHeadingRows, arg[4]); CtlC.AnyVar(ApplyLastRow, arg[3]); CtlC.AnyVar(ApplyFirstColumn, arg[2]); CtlC.AnyVar(ApplyLastColumn, arg[1]); CtlC.AnyVar(AutoFit, arg[0]); CtlC.CallParMethod(this, 162, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END ConvertToTableOld; PROCEDURE (this: Selection) InsertDateTimeOld* ((* optional *) DateTimeFormat: CtlT.Any; InsertAsField: CtlT.Any; InsertAsFullWidth: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.AnyVar(DateTimeFormat, arg[2]); CtlC.AnyVar(InsertAsField, arg[1]); CtlC.AnyVar(InsertAsFullWidth, arg[0]); CtlC.CallParMethod(this, 163, arg, NIL); END InsertDateTimeOld; PROCEDURE (this: Selection) InsertSymbol* (CharacterNumber: INTEGER; (* optional *) Font: CtlT.Any; Unicode: CtlT.Any; Bias: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.IntVar(CharacterNumber, arg[3]); CtlC.AnyVar(Font, arg[2]); CtlC.AnyVar(Unicode, arg[1]); CtlC.AnyVar(Bias, arg[0]); CtlC.CallParMethod(this, 164, arg, NIL); END InsertSymbol; PROCEDURE (this: Selection) InsertCrossReference* (ReferenceType: CtlT.Any; ReferenceKind: WdReferenceKind; ReferenceItem: CtlT.Any; (* optional *) InsertAsHyperlink: CtlT.Any; IncludePosition: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(ReferenceType, arg[4]); CtlC.IntVar(ReferenceKind, arg[3]); CtlC.AnyVar(ReferenceItem, arg[2]); CtlC.AnyVar(InsertAsHyperlink, arg[1]); CtlC.AnyVar(IncludePosition, arg[0]); CtlC.CallParMethod(this, 165, arg, NIL); END InsertCrossReference; PROCEDURE (this: Selection) InsertCaption* (Label: CtlT.Any; (* optional *) Title: CtlT.Any; TitleAutoText: CtlT.Any; Position: CtlT.Any), NEW; VAR arg: ARRAY 4 OF CtlT.Variant; BEGIN CtlC.AnyVar(Label, arg[3]); CtlC.AnyVar(Title, arg[2]); CtlC.AnyVar(TitleAutoText, arg[1]); CtlC.AnyVar(Position, arg[0]); CtlC.CallParMethod(this, 166, arg, NIL); END InsertCaption; PROCEDURE (this: Selection) CopyAsPicture* (), NEW; BEGIN CtlC.CallMethod(this, 167, NIL); END CopyAsPicture; PROCEDURE (this: Selection) SortOld* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; SortColumn: CtlT.Any; Separator: CtlT.Any; CaseSensitive: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 14 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[13]); CtlC.AnyVar(FieldNumber, arg[12]); CtlC.AnyVar(SortFieldType, arg[11]); CtlC.AnyVar(SortOrder, arg[10]); CtlC.AnyVar(FieldNumber2, arg[9]); CtlC.AnyVar(SortFieldType2, arg[8]); CtlC.AnyVar(SortOrder2, arg[7]); CtlC.AnyVar(FieldNumber3, arg[6]); CtlC.AnyVar(SortFieldType3, arg[5]); CtlC.AnyVar(SortOrder3, arg[4]); CtlC.AnyVar(SortColumn, arg[3]); CtlC.AnyVar(Separator, arg[2]); CtlC.AnyVar(CaseSensitive, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 168, arg, NIL); END SortOld; PROCEDURE (this: Selection) SortAscending* (), NEW; BEGIN CtlC.CallMethod(this, 169, NIL); END SortAscending; PROCEDURE (this: Selection) SortDescending* (), NEW; BEGIN CtlC.CallMethod(this, 170, NIL); END SortDescending; PROCEDURE (this: Selection) IsEqual* (range: Range): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 171, arg, ret); RETURN CtlC.VarBool(ret) END IsEqual; PROCEDURE (this: Selection) Calculate* (): SHORTREAL, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 172, ret); RETURN CtlC.VarSReal(ret) END Calculate; PROCEDURE (this: Selection) GoTo* ((* optional *) What: CtlT.Any; Which: CtlT.Any; Count: CtlT.Any; Name: CtlT.Any): Range, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(What, arg[3]); CtlC.AnyVar(Which, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 173, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoTo; PROCEDURE (this: Selection) GoToNext* (What: WdGoToItem): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(What, arg[0]); CtlC.CallParMethod(this, 174, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoToNext; PROCEDURE (this: Selection) GoToPrevious* (What: WdGoToItem): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(What, arg[0]); CtlC.CallParMethod(this, 175, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END GoToPrevious; PROCEDURE (this: Selection) PasteSpecial* ((* optional *) IconIndex: CtlT.Any; Link: CtlT.Any; Placement: CtlT.Any; DisplayAsIcon: CtlT.Any; DataType: CtlT.Any; IconFileName: CtlT.Any; IconLabel: CtlT.Any), NEW; VAR arg: ARRAY 7 OF CtlT.Variant; BEGIN CtlC.AnyVar(IconIndex, arg[6]); CtlC.AnyVar(Link, arg[5]); CtlC.AnyVar(Placement, arg[4]); CtlC.AnyVar(DisplayAsIcon, arg[3]); CtlC.AnyVar(DataType, arg[2]); CtlC.AnyVar(IconFileName, arg[1]); CtlC.AnyVar(IconLabel, arg[0]); CtlC.CallParMethod(this, 176, arg, NIL); END PasteSpecial; PROCEDURE (this: Selection) PreviousField* (): Field, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 177, ret); RETURN ThisField(CtlC.VarAny(ret)) END PreviousField; PROCEDURE (this: Selection) NextField* (): Field, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 178, ret); RETURN ThisField(CtlC.VarAny(ret)) END NextField; PROCEDURE (this: Selection) InsertParagraphBefore* (), NEW; BEGIN CtlC.CallMethod(this, 212, NIL); END InsertParagraphBefore; PROCEDURE (this: Selection) InsertCells* ((* optional *) ShiftCells: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(ShiftCells, arg[0]); CtlC.CallParMethod(this, 214, arg, NIL); END InsertCells; PROCEDURE (this: Selection) Extend* ((* optional *) Character: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Character, arg[0]); CtlC.CallParMethod(this, 300, arg, NIL); END Extend; PROCEDURE (this: Selection) Shrink* (), NEW; BEGIN CtlC.CallMethod(this, 301, NIL); END Shrink; PROCEDURE (this: Selection) MoveLeft* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 500, arg, ret); RETURN CtlC.VarInt(ret) END MoveLeft; PROCEDURE (this: Selection) MoveRight* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 501, arg, ret); RETURN CtlC.VarInt(ret) END MoveRight; PROCEDURE (this: Selection) MoveUp* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 502, arg, ret); RETURN CtlC.VarInt(ret) END MoveUp; PROCEDURE (this: Selection) MoveDown* ((* optional *) Unit: CtlT.Any; Count: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[2]); CtlC.AnyVar(Count, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 503, arg, ret); RETURN CtlC.VarInt(ret) END MoveDown; PROCEDURE (this: Selection) HomeKey* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 504, arg, ret); RETURN CtlC.VarInt(ret) END HomeKey; PROCEDURE (this: Selection) EndKey* ((* optional *) Unit: CtlT.Any; Extend: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Unit, arg[1]); CtlC.AnyVar(Extend, arg[0]); CtlC.CallParMethod(this, 505, arg, ret); RETURN CtlC.VarInt(ret) END EndKey; PROCEDURE (this: Selection) EscapeKey* (), NEW; BEGIN CtlC.CallMethod(this, 506, NIL); END EscapeKey; PROCEDURE (this: Selection) TypeText* (Text: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(Text, arg[0]); CtlC.CallParMethod(this, 507, arg, NIL); END TypeText; PROCEDURE (this: Selection) CopyFormat* (), NEW; BEGIN CtlC.CallMethod(this, 509, NIL); END CopyFormat; PROCEDURE (this: Selection) PasteFormat* (), NEW; BEGIN CtlC.CallMethod(this, 510, NIL); END PasteFormat; PROCEDURE (this: Selection) TypeParagraph* (), NEW; BEGIN CtlC.CallMethod(this, 512, NIL); END TypeParagraph; PROCEDURE (this: Selection) TypeBackspace* (), NEW; BEGIN CtlC.CallMethod(this, 513, NIL); END TypeBackspace; PROCEDURE (this: Selection) NextSubdocument* (), NEW; BEGIN CtlC.CallMethod(this, 514, NIL); END NextSubdocument; PROCEDURE (this: Selection) PreviousSubdocument* (), NEW; BEGIN CtlC.CallMethod(this, 515, NIL); END PreviousSubdocument; PROCEDURE (this: Selection) SelectColumn* (), NEW; BEGIN CtlC.CallMethod(this, 516, NIL); END SelectColumn; PROCEDURE (this: Selection) SelectCurrentFont* (), NEW; BEGIN CtlC.CallMethod(this, 517, NIL); END SelectCurrentFont; PROCEDURE (this: Selection) SelectCurrentAlignment* (), NEW; BEGIN CtlC.CallMethod(this, 518, NIL); END SelectCurrentAlignment; PROCEDURE (this: Selection) SelectCurrentSpacing* (), NEW; BEGIN CtlC.CallMethod(this, 519, NIL); END SelectCurrentSpacing; PROCEDURE (this: Selection) SelectCurrentIndent* (), NEW; BEGIN CtlC.CallMethod(this, 520, NIL); END SelectCurrentIndent; PROCEDURE (this: Selection) SelectCurrentTabs* (), NEW; BEGIN CtlC.CallMethod(this, 521, NIL); END SelectCurrentTabs; PROCEDURE (this: Selection) SelectCurrentColor* (), NEW; BEGIN CtlC.CallMethod(this, 522, NIL); END SelectCurrentColor; PROCEDURE (this: Selection) CreateTextbox* (), NEW; BEGIN CtlC.CallMethod(this, 523, NIL); END CreateTextbox; PROCEDURE (this: Selection) WholeStory* (), NEW; BEGIN CtlC.CallMethod(this, 524, NIL); END WholeStory; PROCEDURE (this: Selection) SelectRow* (), NEW; BEGIN CtlC.CallMethod(this, 525, NIL); END SelectRow; PROCEDURE (this: Selection) SplitTable* (), NEW; BEGIN CtlC.CallMethod(this, 526, NIL); END SplitTable; PROCEDURE (this: Selection) InsertRows* ((* optional *) NumRows: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[0]); CtlC.CallParMethod(this, 528, arg, NIL); END InsertRows; PROCEDURE (this: Selection) InsertColumns* (), NEW; BEGIN CtlC.CallMethod(this, 529, NIL); END InsertColumns; PROCEDURE (this: Selection) InsertFormula* ((* optional *) Formula: CtlT.Any; NumberFormat: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(Formula, arg[1]); CtlC.AnyVar(NumberFormat, arg[0]); CtlC.CallParMethod(this, 530, arg, NIL); END InsertFormula; PROCEDURE (this: Selection) NextRevision* ((* optional *) Wrap: CtlT.Any): Revision, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Wrap, arg[0]); CtlC.CallParMethod(this, 531, arg, ret); RETURN ThisRevision(CtlC.VarAny(ret)) END NextRevision; PROCEDURE (this: Selection) PreviousRevision* ((* optional *) Wrap: CtlT.Any): Revision, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Wrap, arg[0]); CtlC.CallParMethod(this, 532, arg, ret); RETURN ThisRevision(CtlC.VarAny(ret)) END PreviousRevision; PROCEDURE (this: Selection) PasteAsNestedTable* (), NEW; BEGIN CtlC.CallMethod(this, 533, NIL); END PasteAsNestedTable; PROCEDURE (this: Selection) CreateAutoTextEntry* (Name: ARRAY OF CHAR; StyleName: ARRAY OF CHAR): AutoTextEntry, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[1]); CtlC.StrVar(StyleName, arg[0]); CtlC.CallParMethod(this, 534, arg, ret); RETURN ThisAutoTextEntry(CtlC.VarAny(ret)) END CreateAutoTextEntry; PROCEDURE (this: Selection) DetectLanguage* (), NEW; BEGIN CtlC.CallMethod(this, 535, NIL); END DetectLanguage; PROCEDURE (this: Selection) SelectCell* (), NEW; BEGIN CtlC.CallMethod(this, 536, NIL); END SelectCell; PROCEDURE (this: Selection) InsertRowsBelow* ((* optional *) NumRows: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[0]); CtlC.CallParMethod(this, 537, arg, NIL); END InsertRowsBelow; PROCEDURE (this: Selection) InsertColumnsRight* (), NEW; BEGIN CtlC.CallMethod(this, 538, NIL); END InsertColumnsRight; PROCEDURE (this: Selection) InsertRowsAbove* ((* optional *) NumRows: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumRows, arg[0]); CtlC.CallParMethod(this, 539, arg, NIL); END InsertRowsAbove; PROCEDURE (this: Selection) RtlRun* (), NEW; BEGIN CtlC.CallMethod(this, 600, NIL); END RtlRun; PROCEDURE (this: Selection) LtrRun* (), NEW; BEGIN CtlC.CallMethod(this, 601, NIL); END LtrRun; PROCEDURE (this: Selection) BoldRun* (), NEW; BEGIN CtlC.CallMethod(this, 602, NIL); END BoldRun; PROCEDURE (this: Selection) ItalicRun* (), NEW; BEGIN CtlC.CallMethod(this, 603, NIL); END ItalicRun; PROCEDURE (this: Selection) RtlPara* (), NEW; BEGIN CtlC.CallMethod(this, 605, NIL); END RtlPara; PROCEDURE (this: Selection) LtrPara* (), NEW; BEGIN CtlC.CallMethod(this, 606, NIL); END LtrPara; PROCEDURE (this: Selection) InsertDateTime* ((* optional *) DateTimeFormat: CtlT.Any; InsertAsField: CtlT.Any; InsertAsFullWidth: CtlT.Any; DateLanguage: CtlT.Any; CalendarType: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(DateTimeFormat, arg[4]); CtlC.AnyVar(InsertAsField, arg[3]); CtlC.AnyVar(InsertAsFullWidth, arg[2]); CtlC.AnyVar(DateLanguage, arg[1]); CtlC.AnyVar(CalendarType, arg[0]); CtlC.CallParMethod(this, 444, arg, NIL); END InsertDateTime; PROCEDURE (this: Selection) Sort* ((* optional *) ExcludeHeader: CtlT.Any; FieldNumber: CtlT.Any; SortFieldType: CtlT.Any; SortOrder: CtlT.Any; FieldNumber2: CtlT.Any; SortFieldType2: CtlT.Any; SortOrder2: CtlT.Any; FieldNumber3: CtlT.Any; SortFieldType3: CtlT.Any; SortOrder3: CtlT.Any; SortColumn: CtlT.Any; Separator: CtlT.Any; CaseSensitive: CtlT.Any; BidiSort: CtlT.Any; IgnoreThe: CtlT.Any; IgnoreKashida: CtlT.Any; IgnoreDiacritics: CtlT.Any; IgnoreHe: CtlT.Any; LanguageID: CtlT.Any), NEW; VAR arg: ARRAY 19 OF CtlT.Variant; BEGIN CtlC.AnyVar(ExcludeHeader, arg[18]); CtlC.AnyVar(FieldNumber, arg[17]); CtlC.AnyVar(SortFieldType, arg[16]); CtlC.AnyVar(SortOrder, arg[15]); CtlC.AnyVar(FieldNumber2, arg[14]); CtlC.AnyVar(SortFieldType2, arg[13]); CtlC.AnyVar(SortOrder2, arg[12]); CtlC.AnyVar(FieldNumber3, arg[11]); CtlC.AnyVar(SortFieldType3, arg[10]); CtlC.AnyVar(SortOrder3, arg[9]); CtlC.AnyVar(SortColumn, arg[8]); CtlC.AnyVar(Separator, arg[7]); CtlC.AnyVar(CaseSensitive, arg[6]); CtlC.AnyVar(BidiSort, arg[5]); CtlC.AnyVar(IgnoreThe, arg[4]); CtlC.AnyVar(IgnoreKashida, arg[3]); CtlC.AnyVar(IgnoreDiacritics, arg[2]); CtlC.AnyVar(IgnoreHe, arg[1]); CtlC.AnyVar(LanguageID, arg[0]); CtlC.CallParMethod(this, 445, arg, NIL); END Sort; PROCEDURE (this: Selection) ConvertToTable* ((* optional *) Separator: CtlT.Any; NumRows: CtlT.Any; NumColumns: CtlT.Any; InitialColumnWidth: CtlT.Any; Format: CtlT.Any; ApplyBorders: CtlT.Any; ApplyShading: CtlT.Any; ApplyFont: CtlT.Any; ApplyColor: CtlT.Any; ApplyHeadingRows: CtlT.Any; ApplyLastRow: CtlT.Any; ApplyFirstColumn: CtlT.Any; ApplyLastColumn: CtlT.Any; AutoFit: CtlT.Any; AutoFitBehavior: CtlT.Any; DefaultTableBehavior: CtlT.Any): Table, NEW; VAR arg: ARRAY 16 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Separator, arg[15]); CtlC.AnyVar(NumRows, arg[14]); CtlC.AnyVar(NumColumns, arg[13]); CtlC.AnyVar(InitialColumnWidth, arg[12]); CtlC.AnyVar(Format, arg[11]); CtlC.AnyVar(ApplyBorders, arg[10]); CtlC.AnyVar(ApplyShading, arg[9]); CtlC.AnyVar(ApplyFont, arg[8]); CtlC.AnyVar(ApplyColor, arg[7]); CtlC.AnyVar(ApplyHeadingRows, arg[6]); CtlC.AnyVar(ApplyLastRow, arg[5]); CtlC.AnyVar(ApplyFirstColumn, arg[4]); CtlC.AnyVar(ApplyLastColumn, arg[3]); CtlC.AnyVar(AutoFit, arg[2]); CtlC.AnyVar(AutoFitBehavior, arg[1]); CtlC.AnyVar(DefaultTableBehavior, arg[0]); CtlC.CallParMethod(this, 457, arg, ret); RETURN ThisTable(CtlC.VarAny(ret)) END ConvertToTable; PROCEDURE (this: Selection) NoProofing* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END NoProofing; PROCEDURE (this: Selection) PUTNoProofing* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1005, p1) END PUTNoProofing; PROCEDURE (this: Selection) TopLevelTables* (): Tables, NEW; BEGIN RETURN ThisTables(CtlC.GetAny(this, 1006)) END TopLevelTables; PROCEDURE (this: Selection) LanguageDetected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1007) END LanguageDetected; PROCEDURE (this: Selection) PUTLanguageDetected* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1007, p1) END PUTLanguageDetected; PROCEDURE (this: Selection) FitTextWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1008) END FitTextWidth; PROCEDURE (this: Selection) PUTFitTextWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 1008, p1) END PUTFitTextWidth; (* ---------- TablesOfAuthoritiesCategories, dual, nonextensible ---------- *) PROCEDURE (this: TablesOfAuthoritiesCategories) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TablesOfAuthoritiesCategories) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TablesOfAuthoritiesCategories) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TablesOfAuthoritiesCategories) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: TablesOfAuthoritiesCategories) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: TablesOfAuthoritiesCategories) Item* (Index: CtlT.Any): TableOfAuthoritiesCategory, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTableOfAuthoritiesCategory(CtlC.VarAny(ret)) END Item; (* ---------- TableOfAuthoritiesCategory, dual, nonextensible ---------- *) PROCEDURE (this: TableOfAuthoritiesCategory) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TableOfAuthoritiesCategory) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TableOfAuthoritiesCategory) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: TableOfAuthoritiesCategory) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: TableOfAuthoritiesCategory) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 0, p1) END PUTName; PROCEDURE (this: TableOfAuthoritiesCategory) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; (* ---------- CaptionLabels, dual, nonextensible ---------- *) PROCEDURE (this: CaptionLabels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CaptionLabels) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CaptionLabels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: CaptionLabels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: CaptionLabels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: CaptionLabels) Item* (Index: CtlT.Any): CaptionLabel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisCaptionLabel(CtlC.VarAny(ret)) END Item; PROCEDURE (this: CaptionLabels) Add* (Name: ARRAY OF CHAR): CaptionLabel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisCaptionLabel(CtlC.VarAny(ret)) END Add; (* ---------- CaptionLabel, dual, nonextensible ---------- *) PROCEDURE (this: CaptionLabel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CaptionLabel) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CaptionLabel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: CaptionLabel) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: CaptionLabel) BuiltIn* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END BuiltIn; PROCEDURE (this: CaptionLabel) ID* (): WdCaptionLabelID, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END ID; PROCEDURE (this: CaptionLabel) IncludeChapterNumber* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END IncludeChapterNumber; PROCEDURE (this: CaptionLabel) PUTIncludeChapterNumber* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTIncludeChapterNumber; PROCEDURE (this: CaptionLabel) NumberStyle* (): WdCaptionNumberStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END NumberStyle; PROCEDURE (this: CaptionLabel) PUTNumberStyle* (p1: WdCaptionNumberStyle), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTNumberStyle; PROCEDURE (this: CaptionLabel) ChapterStyleLevel* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END ChapterStyleLevel; PROCEDURE (this: CaptionLabel) PUTChapterStyleLevel* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTChapterStyleLevel; PROCEDURE (this: CaptionLabel) Separator* (): WdSeparatorType, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Separator; PROCEDURE (this: CaptionLabel) PUTSeparator* (p1: WdSeparatorType), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTSeparator; PROCEDURE (this: CaptionLabel) Position* (): WdCaptionPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END Position; PROCEDURE (this: CaptionLabel) PUTPosition* (p1: WdCaptionPosition), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTPosition; PROCEDURE (this: CaptionLabel) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; (* ---------- AutoCaptions, dual, nonextensible ---------- *) PROCEDURE (this: AutoCaptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoCaptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoCaptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoCaptions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AutoCaptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: AutoCaptions) Item* (Index: CtlT.Any): AutoCaption, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisAutoCaption(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AutoCaptions) CancelAutoInsert* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END CancelAutoInsert; (* ---------- AutoCaption, dual, nonextensible ---------- *) PROCEDURE (this: AutoCaption) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AutoCaption) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AutoCaption) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AutoCaption) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: AutoCaption) AutoInsert* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END AutoInsert; PROCEDURE (this: AutoCaption) PUTAutoInsert* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTAutoInsert; PROCEDURE (this: AutoCaption) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Index; PROCEDURE (this: AutoCaption) CaptionLabel* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 3) END CaptionLabel; PROCEDURE (this: AutoCaption) PUTCaptionLabel* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 3, p1) END PUTCaptionLabel; (* ---------- Indexes, dual, nonextensible ---------- *) PROCEDURE (this: Indexes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Indexes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Indexes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Indexes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Indexes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Indexes) Format* (): WdIndexFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Format; PROCEDURE (this: Indexes) PUTFormat* (p1: WdIndexFormat), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTFormat; PROCEDURE (this: Indexes) Item* (index: INTEGER): Index, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisIndex(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Indexes) AddOld* (range: Range; (* optional *) HeadingSeparator: CtlT.Any; RightAlignPageNumbers: CtlT.Any; Type: CtlT.Any; NumberOfColumns: CtlT.Any; AccentedLetters: CtlT.Any): Index, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[5]); CtlC.AnyVar(HeadingSeparator, arg[4]); CtlC.AnyVar(RightAlignPageNumbers, arg[3]); CtlC.AnyVar(Type, arg[2]); CtlC.AnyVar(NumberOfColumns, arg[1]); CtlC.AnyVar(AccentedLetters, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisIndex(CtlC.VarAny(ret)) END AddOld; PROCEDURE (this: Indexes) MarkEntry* (range: Range; (* optional *) Entry: CtlT.Any; EntryAutoText: CtlT.Any; CrossReference: CtlT.Any; CrossReferenceAutoText: CtlT.Any; BookmarkName: CtlT.Any; Bold: CtlT.Any; Italic: CtlT.Any; Reading: CtlT.Any): Field, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[8]); CtlC.AnyVar(Entry, arg[7]); CtlC.AnyVar(EntryAutoText, arg[6]); CtlC.AnyVar(CrossReference, arg[5]); CtlC.AnyVar(CrossReferenceAutoText, arg[4]); CtlC.AnyVar(BookmarkName, arg[3]); CtlC.AnyVar(Bold, arg[2]); CtlC.AnyVar(Italic, arg[1]); CtlC.AnyVar(Reading, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisField(CtlC.VarAny(ret)) END MarkEntry; PROCEDURE (this: Indexes) MarkAllEntries* (range: Range; (* optional *) Entry: CtlT.Any; EntryAutoText: CtlT.Any; CrossReference: CtlT.Any; CrossReferenceAutoText: CtlT.Any; BookmarkName: CtlT.Any; Bold: CtlT.Any; Italic: CtlT.Any), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[7]); CtlC.AnyVar(Entry, arg[6]); CtlC.AnyVar(EntryAutoText, arg[5]); CtlC.AnyVar(CrossReference, arg[4]); CtlC.AnyVar(CrossReferenceAutoText, arg[3]); CtlC.AnyVar(BookmarkName, arg[2]); CtlC.AnyVar(Bold, arg[1]); CtlC.AnyVar(Italic, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END MarkAllEntries; PROCEDURE (this: Indexes) AutoMarkEntries* (ConcordanceFileName: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(ConcordanceFileName, arg[0]); CtlC.CallParMethod(this, 103, arg, NIL); END AutoMarkEntries; PROCEDURE (this: Indexes) Add* (range: Range; (* optional *) HeadingSeparator: CtlT.Any; RightAlignPageNumbers: CtlT.Any; Type: CtlT.Any; NumberOfColumns: CtlT.Any; AccentedLetters: CtlT.Any; SortBy: CtlT.Any; IndexLanguage: CtlT.Any): Index, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[7]); CtlC.AnyVar(HeadingSeparator, arg[6]); CtlC.AnyVar(RightAlignPageNumbers, arg[5]); CtlC.AnyVar(Type, arg[4]); CtlC.AnyVar(NumberOfColumns, arg[3]); CtlC.AnyVar(AccentedLetters, arg[2]); CtlC.AnyVar(SortBy, arg[1]); CtlC.AnyVar(IndexLanguage, arg[0]); CtlC.CallParMethod(this, 104, arg, ret); RETURN ThisIndex(CtlC.VarAny(ret)) END Add; (* ---------- Index, dual, nonextensible ---------- *) PROCEDURE (this: Index) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Index) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Index) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Index) HeadingSeparator* (): WdHeadingSeparator, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END HeadingSeparator; PROCEDURE (this: Index) PUTHeadingSeparator* (p1: WdHeadingSeparator), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTHeadingSeparator; PROCEDURE (this: Index) RightAlignPageNumbers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END RightAlignPageNumbers; PROCEDURE (this: Index) PUTRightAlignPageNumbers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTRightAlignPageNumbers; PROCEDURE (this: Index) Type* (): WdIndexType, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Type; PROCEDURE (this: Index) PUTType* (p1: WdIndexType), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTType; PROCEDURE (this: Index) NumberOfColumns* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END NumberOfColumns; PROCEDURE (this: Index) PUTNumberOfColumns* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTNumberOfColumns; PROCEDURE (this: Index) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 5)) END Range; PROCEDURE (this: Index) TabLeader* (): WdTabLeader, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END TabLeader; PROCEDURE (this: Index) PUTTabLeader* (p1: WdTabLeader), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTTabLeader; PROCEDURE (this: Index) AccentedLetters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END AccentedLetters; PROCEDURE (this: Index) PUTAccentedLetters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTAccentedLetters; PROCEDURE (this: Index) SortBy* (): WdIndexSortBy, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END SortBy; PROCEDURE (this: Index) PUTSortBy* (p1: WdIndexSortBy), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTSortBy; PROCEDURE (this: Index) Filter* (): WdIndexFilter, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END Filter; PROCEDURE (this: Index) PUTFilter* (p1: WdIndexFilter), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTFilter; PROCEDURE (this: Index) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: Index) Update* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Update; PROCEDURE (this: Index) IndexLanguage* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END IndexLanguage; PROCEDURE (this: Index) PUTIndexLanguage* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTIndexLanguage; (* ---------- AddIn, dual, nonextensible ---------- *) PROCEDURE (this: AddIn) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AddIn) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AddIn) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AddIn) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: AddIn) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: AddIn) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Path; PROCEDURE (this: AddIn) Installed* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END Installed; PROCEDURE (this: AddIn) PUTInstalled* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTInstalled; PROCEDURE (this: AddIn) Compiled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END Compiled; PROCEDURE (this: AddIn) Autoload* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Autoload; PROCEDURE (this: AddIn) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- AddIns, dual, nonextensible ---------- *) PROCEDURE (this: AddIns) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: AddIns) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: AddIns) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: AddIns) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: AddIns) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: AddIns) Item* (Index: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Item; PROCEDURE (this: AddIns) Add* (FileName: ARRAY OF CHAR; (* optional *) Install: CtlT.Any): AddIn, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[1]); CtlC.AnyVar(Install, arg[0]); CtlC.CallParMethod(this, 2, arg, ret); RETURN ThisAddIn(CtlC.VarAny(ret)) END Add; PROCEDURE (this: AddIns) Unload* (RemoveFromList: BOOLEAN), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.BoolVar(RemoveFromList, arg[0]); CtlC.CallParMethod(this, 3, arg, NIL); END Unload; (* ---------- Revisions, dual, nonextensible ---------- *) PROCEDURE (this: Revisions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Revisions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Revisions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Revisions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Revisions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Count; PROCEDURE (this: Revisions) Item* (Index: INTEGER): Revision, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRevision(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Revisions) AcceptAll* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END AcceptAll; PROCEDURE (this: Revisions) RejectAll* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END RejectAll; (* ---------- Revision, dual, nonextensible ---------- *) PROCEDURE (this: Revision) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Revision) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Revision) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Revision) Author* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Author; PROCEDURE (this: Revision) Date* (): CtlT.OleDate; BEGIN RETURN CtlC.GetDate(this, 2) END Date; PROCEDURE (this: Revision) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 3)) END Range; PROCEDURE (this: Revision) Type* (): WdRevisionType, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Type; PROCEDURE (this: Revision) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END Index; PROCEDURE (this: Revision) Accept* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Accept; PROCEDURE (this: Revision) Reject* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Reject; (* ---------- Task, dual, nonextensible ---------- *) PROCEDURE (this: Task) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Task) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Task) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Task) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Task) Left* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Left; PROCEDURE (this: Task) PUTLeft* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTLeft; PROCEDURE (this: Task) Top* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Top; PROCEDURE (this: Task) PUTTop* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTTop; PROCEDURE (this: Task) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Width; PROCEDURE (this: Task) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTWidth; PROCEDURE (this: Task) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Height; PROCEDURE (this: Task) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTHeight; PROCEDURE (this: Task) WindowState* (): WdWindowState, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END WindowState; PROCEDURE (this: Task) PUTWindowState* (p1: WdWindowState), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTWindowState; PROCEDURE (this: Task) Visible* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END Visible; PROCEDURE (this: Task) PUTVisible* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTVisible; PROCEDURE (this: Task) Activate* ((* optional *) Wait: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Wait, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END Activate; PROCEDURE (this: Task) Close* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Close; PROCEDURE (this: Task) Move* (Left: INTEGER; Top: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Left, arg[1]); CtlC.IntVar(Top, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Move; PROCEDURE (this: Task) Resize* (Width: INTEGER; Height: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Width, arg[1]); CtlC.IntVar(Height, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Resize; PROCEDURE (this: Task) SendWindowMessage* (Message: INTEGER; wParam: INTEGER; lParam: INTEGER), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Message, arg[2]); CtlC.IntVar(wParam, arg[1]); CtlC.IntVar(lParam, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SendWindowMessage; (* ---------- Tasks, dual, nonextensible ---------- *) PROCEDURE (this: Tasks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Tasks) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Tasks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Tasks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Tasks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Tasks) Item* (Index: CtlT.Any): Task, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisTask(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Tasks) Exists* (Name: ARRAY OF CHAR): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 2, arg, ret); RETURN CtlC.VarBool(ret) END Exists; PROCEDURE (this: Tasks) ExitWindows* (), NEW; BEGIN CtlC.CallMethod(this, 3, NIL); END ExitWindows; (* ---------- HeadersFooters, dual, nonextensible ---------- *) PROCEDURE (this: HeadersFooters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HeadersFooters) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HeadersFooters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HeadersFooters) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HeadersFooters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: HeadersFooters) Item* (Index: WdHeaderFooterIndex): HeaderFooter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHeaderFooter(CtlC.VarAny(ret)) END Item; (* ---------- HeaderFooter, dual, nonextensible ---------- *) PROCEDURE (this: HeaderFooter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HeaderFooter) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HeaderFooter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HeaderFooter) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 0)) END Range; PROCEDURE (this: HeaderFooter) Index* (): WdHeaderFooterIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Index; PROCEDURE (this: HeaderFooter) IsHeader* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END IsHeader; PROCEDURE (this: HeaderFooter) Exists* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END Exists; PROCEDURE (this: HeaderFooter) PUTExists* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTExists; PROCEDURE (this: HeaderFooter) PageNumbers* (): PageNumbers, NEW; BEGIN RETURN ThisPageNumbers(CtlC.GetAny(this, 5)) END PageNumbers; PROCEDURE (this: HeaderFooter) LinkToPrevious* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END LinkToPrevious; PROCEDURE (this: HeaderFooter) PUTLinkToPrevious* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTLinkToPrevious; PROCEDURE (this: HeaderFooter) Shapes* (): Shapes, NEW; BEGIN RETURN ThisShapes(CtlC.GetAny(this, 7)) END Shapes; (* ---------- PageNumbers, dual, nonextensible ---------- *) PROCEDURE (this: PageNumbers) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: PageNumbers) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: PageNumbers) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PageNumbers) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: PageNumbers) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: PageNumbers) NumberStyle* (): WdPageNumberStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END NumberStyle; PROCEDURE (this: PageNumbers) PUTNumberStyle* (p1: WdPageNumberStyle), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTNumberStyle; PROCEDURE (this: PageNumbers) IncludeChapterNumber* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END IncludeChapterNumber; PROCEDURE (this: PageNumbers) PUTIncludeChapterNumber* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTIncludeChapterNumber; PROCEDURE (this: PageNumbers) HeadingLevelForChapter* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END HeadingLevelForChapter; PROCEDURE (this: PageNumbers) PUTHeadingLevelForChapter* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTHeadingLevelForChapter; PROCEDURE (this: PageNumbers) ChapterPageSeparator* (): WdSeparatorType, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END ChapterPageSeparator; PROCEDURE (this: PageNumbers) PUTChapterPageSeparator* (p1: WdSeparatorType), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTChapterPageSeparator; PROCEDURE (this: PageNumbers) RestartNumberingAtSection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END RestartNumberingAtSection; PROCEDURE (this: PageNumbers) PUTRestartNumberingAtSection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTRestartNumberingAtSection; PROCEDURE (this: PageNumbers) StartingNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END StartingNumber; PROCEDURE (this: PageNumbers) PUTStartingNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 7, p1) END PUTStartingNumber; PROCEDURE (this: PageNumbers) ShowFirstPageNumber* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END ShowFirstPageNumber; PROCEDURE (this: PageNumbers) PUTShowFirstPageNumber* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTShowFirstPageNumber; PROCEDURE (this: PageNumbers) Item* (Index: INTEGER): PageNumber, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisPageNumber(CtlC.VarAny(ret)) END Item; PROCEDURE (this: PageNumbers) Add* ((* optional *) PageNumberAlignment: CtlT.Any; FirstPage: CtlT.Any): PageNumber, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(PageNumberAlignment, arg[1]); CtlC.AnyVar(FirstPage, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisPageNumber(CtlC.VarAny(ret)) END Add; PROCEDURE (this: PageNumbers) DoubleQuote* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END DoubleQuote; PROCEDURE (this: PageNumbers) PUTDoubleQuote* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTDoubleQuote; (* ---------- PageNumber, dual, nonextensible ---------- *) PROCEDURE (this: PageNumber) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: PageNumber) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: PageNumber) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: PageNumber) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: PageNumber) Alignment* (): WdPageNumberAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Alignment; PROCEDURE (this: PageNumber) PUTAlignment* (p1: WdPageNumberAlignment), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTAlignment; PROCEDURE (this: PageNumber) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: PageNumber) Copy* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Copy; PROCEDURE (this: PageNumber) Cut* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Cut; PROCEDURE (this: PageNumber) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Delete; (* ---------- Subdocuments, dual, nonextensible ---------- *) PROCEDURE (this: Subdocuments) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Subdocuments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Subdocuments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Subdocuments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Subdocuments) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Subdocuments) Expanded* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Expanded; PROCEDURE (this: Subdocuments) PUTExpanded* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTExpanded; PROCEDURE (this: Subdocuments) Item* (Index: INTEGER): Subdocument, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisSubdocument(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Subdocuments) AddFromFile* (Name: CtlT.Any; (* optional *) ConfirmConversions: CtlT.Any; ReadOnly: CtlT.Any; PasswordDocument: CtlT.Any; PasswordTemplate: CtlT.Any; Revert: CtlT.Any; WritePasswordDocument: CtlT.Any; WritePasswordTemplate: CtlT.Any): Subdocument, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Name, arg[7]); CtlC.AnyVar(ConfirmConversions, arg[6]); CtlC.AnyVar(ReadOnly, arg[5]); CtlC.AnyVar(PasswordDocument, arg[4]); CtlC.AnyVar(PasswordTemplate, arg[3]); CtlC.AnyVar(Revert, arg[2]); CtlC.AnyVar(WritePasswordDocument, arg[1]); CtlC.AnyVar(WritePasswordTemplate, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisSubdocument(CtlC.VarAny(ret)) END AddFromFile; PROCEDURE (this: Subdocuments) AddFromRange* (range: Range): Subdocument, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisSubdocument(CtlC.VarAny(ret)) END AddFromRange; PROCEDURE (this: Subdocuments) Merge* ((* optional *) FirstSubdocument: CtlT.Any; LastSubdocument: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.AnyVar(FirstSubdocument, arg[1]); CtlC.AnyVar(LastSubdocument, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END Merge; PROCEDURE (this: Subdocuments) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Delete; PROCEDURE (this: Subdocuments) Select* (), NEW; BEGIN CtlC.CallMethod(this, 104, NIL); END Select; (* ---------- Subdocument, dual, nonextensible ---------- *) PROCEDURE (this: Subdocument) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Subdocument) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Subdocument) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Subdocument) Locked* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END Locked; PROCEDURE (this: Subdocument) PUTLocked* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTLocked; PROCEDURE (this: Subdocument) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 2)) END Range; PROCEDURE (this: Subdocument) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Name; PROCEDURE (this: Subdocument) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Path; PROCEDURE (this: Subdocument) HasFile* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END HasFile; PROCEDURE (this: Subdocument) Level* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Level; PROCEDURE (this: Subdocument) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; PROCEDURE (this: Subdocument) Split* (range: Range), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END Split; PROCEDURE (this: Subdocument) Open* (): Document, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 102, ret); RETURN This_Document(CtlC.VarAny(ret)) END Open; (* ---------- HeadingStyles, dual, nonextensible ---------- *) PROCEDURE (this: HeadingStyles) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HeadingStyles) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HeadingStyles) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HeadingStyles) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HeadingStyles) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: HeadingStyles) Item* (Index: INTEGER): HeadingStyle, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHeadingStyle(CtlC.VarAny(ret)) END Item; PROCEDURE (this: HeadingStyles) Add* (Style: CtlT.Any; Level: SHORTINT): HeadingStyle, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Style, arg[1]); CtlC.SIntVar(Level, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisHeadingStyle(CtlC.VarAny(ret)) END Add; (* ---------- HeadingStyle, dual, nonextensible ---------- *) PROCEDURE (this: HeadingStyle) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HeadingStyle) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HeadingStyle) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HeadingStyle) Style* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 0) END Style; PROCEDURE (this: HeadingStyle) PUTStyle* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 0, p1) END PUTStyle; PROCEDURE (this: HeadingStyle) Level* (): SHORTINT, NEW; BEGIN RETURN CtlC.GetSInt(this, 2) END Level; PROCEDURE (this: HeadingStyle) PUTLevel* (p1: SHORTINT), NEW; BEGIN CtlC.PutSInt(this, 2, p1) END PUTLevel; PROCEDURE (this: HeadingStyle) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Delete; (* ---------- StoryRanges, dual, nonextensible ---------- *) PROCEDURE (this: StoryRanges) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: StoryRanges) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: StoryRanges) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: StoryRanges) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: StoryRanges) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: StoryRanges) Item* (Index: WdStoryType): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; (* ---------- ListLevel, dual, nonextensible ---------- *) PROCEDURE (this: ListLevel) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: ListLevel) NumberFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END NumberFormat; PROCEDURE (this: ListLevel) PUTNumberFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 2, p1) END PUTNumberFormat; PROCEDURE (this: ListLevel) TrailingCharacter* (): WdTrailingCharacter, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END TrailingCharacter; PROCEDURE (this: ListLevel) PUTTrailingCharacter* (p1: WdTrailingCharacter), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTTrailingCharacter; PROCEDURE (this: ListLevel) NumberStyle* (): WdListNumberStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END NumberStyle; PROCEDURE (this: ListLevel) PUTNumberStyle* (p1: WdListNumberStyle), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTNumberStyle; PROCEDURE (this: ListLevel) NumberPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 5) END NumberPosition; PROCEDURE (this: ListLevel) PUTNumberPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 5, p1) END PUTNumberPosition; PROCEDURE (this: ListLevel) Alignment* (): WdListLevelAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Alignment; PROCEDURE (this: ListLevel) PUTAlignment* (p1: WdListLevelAlignment), NEW; BEGIN CtlC.PutInt(this, 6, p1) END PUTAlignment; PROCEDURE (this: ListLevel) TextPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 7) END TextPosition; PROCEDURE (this: ListLevel) PUTTextPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 7, p1) END PUTTextPosition; PROCEDURE (this: ListLevel) TabPosition* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 8) END TabPosition; PROCEDURE (this: ListLevel) PUTTabPosition* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 8, p1) END PUTTabPosition; PROCEDURE (this: ListLevel) ResetOnHigherOld* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END ResetOnHigherOld; PROCEDURE (this: ListLevel) PUTResetOnHigherOld* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTResetOnHigherOld; PROCEDURE (this: ListLevel) StartAt* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END StartAt; PROCEDURE (this: ListLevel) PUTStartAt* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTStartAt; PROCEDURE (this: ListLevel) LinkedStyle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 11) END LinkedStyle; PROCEDURE (this: ListLevel) PUTLinkedStyle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 11, p1) END PUTLinkedStyle; PROCEDURE (this: ListLevel) Font* (): Font, NEW; BEGIN RETURN This_Font(CtlC.GetAny(this, 12)) END Font; PROCEDURE (this: ListLevel) PUTFont* (p1: Font), NEW; BEGIN CtlC.PutObj(this, 12, p1) END PUTFont; PROCEDURE (this: ListLevel) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListLevel) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListLevel) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListLevel) ResetOnHigher* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END ResetOnHigher; PROCEDURE (this: ListLevel) PUTResetOnHigher* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTResetOnHigher; (* ---------- ListLevels, dual, nonextensible ---------- *) PROCEDURE (this: ListLevels) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ListLevels) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ListLevels) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListLevels) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListLevels) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListLevels) Item* (Index: INTEGER): ListLevel, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisListLevel(CtlC.VarAny(ret)) END Item; (* ---------- ListTemplate, dual, nonextensible ---------- *) PROCEDURE (this: ListTemplate) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListTemplate) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListTemplate) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListTemplate) OutlineNumbered* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END OutlineNumbered; PROCEDURE (this: ListTemplate) PUTOutlineNumbered* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTOutlineNumbered; PROCEDURE (this: ListTemplate) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 3) END Name; PROCEDURE (this: ListTemplate) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 3, p1) END PUTName; PROCEDURE (this: ListTemplate) ListLevels* (): ListLevels, NEW; BEGIN RETURN ThisListLevels(CtlC.GetAny(this, 2)) END ListLevels; PROCEDURE (this: ListTemplate) Convert* ((* optional *) Level: CtlT.Any): ListTemplate, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisListTemplate(CtlC.VarAny(ret)) END Convert; (* ---------- ListTemplates, dual, nonextensible ---------- *) PROCEDURE (this: ListTemplates) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ListTemplates) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ListTemplates) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListTemplates) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListTemplates) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListTemplates) Item* (Index: CtlT.Any): ListTemplate, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisListTemplate(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ListTemplates) Add* ((* optional *) OutlineNumbered: CtlT.Any; Name: CtlT.Any): ListTemplate, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(OutlineNumbered, arg[1]); CtlC.AnyVar(Name, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisListTemplate(CtlC.VarAny(ret)) END Add; (* ---------- ListParagraphs, dual, nonextensible ---------- *) PROCEDURE (this: ListParagraphs) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ListParagraphs) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ListParagraphs) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListParagraphs) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListParagraphs) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListParagraphs) Item* (Index: INTEGER): Paragraph, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisParagraph(CtlC.VarAny(ret)) END Item; (* ---------- List, dual, nonextensible ---------- *) PROCEDURE (this: List) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1)) END Range; PROCEDURE (this: List) ListParagraphs* (): ListParagraphs, NEW; BEGIN RETURN ThisListParagraphs(CtlC.GetAny(this, 2)) END ListParagraphs; PROCEDURE (this: List) SingleListTemplate* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END SingleListTemplate; PROCEDURE (this: List) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: List) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: List) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: List) ConvertNumbersToText* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END ConvertNumbersToText; PROCEDURE (this: List) RemoveNumbers* ((* optional *) NumberType: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END RemoveNumbers; PROCEDURE (this: List) CountNumberedItems* ((* optional *) NumberType: CtlT.Any; Level: CtlT.Any): INTEGER, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(NumberType, arg[1]); CtlC.AnyVar(Level, arg[0]); CtlC.CallParMethod(this, 103, arg, ret); RETURN CtlC.VarInt(ret) END CountNumberedItems; PROCEDURE (this: List) ApplyListTemplateOld* (listTemplate: ListTemplate; (* optional *) ContinuePreviousList: CtlT.Any), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[1]); CtlC.AnyVar(ContinuePreviousList, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END ApplyListTemplateOld; PROCEDURE (this: List) CanContinuePreviousList* (listTemplate: ListTemplate): WdContinue, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN CtlC.VarInt(ret) END CanContinuePreviousList; PROCEDURE (this: List) ApplyListTemplate* (listTemplate: ListTemplate; (* optional *) ContinuePreviousList: CtlT.Any; DefaultListBehavior: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.ObjVar(listTemplate, arg[2]); CtlC.AnyVar(ContinuePreviousList, arg[1]); CtlC.AnyVar(DefaultListBehavior, arg[0]); CtlC.CallParMethod(this, 106, arg, NIL); END ApplyListTemplate; (* ---------- Lists, dual, nonextensible ---------- *) PROCEDURE (this: Lists) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Lists) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Lists) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Lists) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Lists) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Lists) Item* (Index: INTEGER): List, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisList(CtlC.VarAny(ret)) END Item; (* ---------- ListGallery, dual, nonextensible ---------- *) PROCEDURE (this: ListGallery) ListTemplates* (): ListTemplates, NEW; BEGIN RETURN ThisListTemplates(CtlC.GetAny(this, 1)) END ListTemplates; PROCEDURE (this: ListGallery) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListGallery) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListGallery) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListGallery) Modified* (Index: INTEGER): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 101, arg, ret); RETURN CtlC.VarBool(ret) END Modified; PROCEDURE (this: ListGallery) Reset* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 100, arg, NIL); END Reset; (* ---------- ListGalleries, dual, nonextensible ---------- *) PROCEDURE (this: ListGalleries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ListGalleries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ListGalleries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ListGalleries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ListGalleries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ListGalleries) Item* (Index: WdListGalleryType): ListGallery, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisListGallery(CtlC.VarAny(ret)) END Item; (* ---------- KeyBindings, dual, nonextensible ---------- *) PROCEDURE (this: KeyBindings) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: KeyBindings) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: KeyBindings) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: KeyBindings) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: KeyBindings) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: KeyBindings) Context* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 10) END Context; PROCEDURE (this: KeyBindings) Item* (Index: INTEGER): KeyBinding, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END Item; PROCEDURE (this: KeyBindings) Add* (KeyCategory: WdKeyCategory; Command: ARRAY OF CHAR; KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any; CommandParameter: CtlT.Any): KeyBinding, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCategory, arg[4]); CtlC.StrVar(Command, arg[3]); CtlC.IntVar(KeyCode, arg[2]); CtlC.AnyVar(KeyCode2, arg[1]); CtlC.AnyVar(CommandParameter, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END Add; PROCEDURE (this: KeyBindings) ClearAll* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END ClearAll; PROCEDURE (this: KeyBindings) Key* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): KeyBinding, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallParMethod(this, 110, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END Key; (* ---------- KeysBoundTo, dual, nonextensible ---------- *) PROCEDURE (this: KeysBoundTo) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: KeysBoundTo) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: KeysBoundTo) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: KeysBoundTo) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: KeysBoundTo) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: KeysBoundTo) KeyCategory* (): WdKeyCategory, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END KeyCategory; PROCEDURE (this: KeysBoundTo) Command* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 4) END Command; PROCEDURE (this: KeysBoundTo) CommandParameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 5) END CommandParameter; PROCEDURE (this: KeysBoundTo) Context* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 10) END Context; PROCEDURE (this: KeysBoundTo) Item* (Index: INTEGER): KeyBinding, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END Item; PROCEDURE (this: KeysBoundTo) Key* (KeyCode: INTEGER; (* optional *) KeyCode2: CtlT.Any): KeyBinding, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(KeyCode, arg[1]); CtlC.AnyVar(KeyCode2, arg[0]); CtlC.CallParMethod(this, 1, arg, ret); RETURN ThisKeyBinding(CtlC.VarAny(ret)) END Key; (* ---------- KeyBinding, dual, nonextensible ---------- *) PROCEDURE (this: KeyBinding) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: KeyBinding) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: KeyBinding) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: KeyBinding) Command* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Command; PROCEDURE (this: KeyBinding) KeyString* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END KeyString; PROCEDURE (this: KeyBinding) Protected* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END Protected; PROCEDURE (this: KeyBinding) KeyCategory* (): WdKeyCategory, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END KeyCategory; PROCEDURE (this: KeyBinding) KeyCode* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END KeyCode; PROCEDURE (this: KeyBinding) KeyCode2* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 7) END KeyCode2; PROCEDURE (this: KeyBinding) CommandParameter* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END CommandParameter; PROCEDURE (this: KeyBinding) Context* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 10) END Context; PROCEDURE (this: KeyBinding) Clear* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Clear; PROCEDURE (this: KeyBinding) Disable* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Disable; PROCEDURE (this: KeyBinding) Execute* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Execute; PROCEDURE (this: KeyBinding) Rebind* (KeyCategory: WdKeyCategory; Command: ARRAY OF CHAR; (* optional *) CommandParameter: CtlT.Any), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(KeyCategory, arg[2]); CtlC.StrVar(Command, arg[1]); CtlC.AnyVar(CommandParameter, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END Rebind; (* ---------- FileConverter, dual, nonextensible ---------- *) PROCEDURE (this: FileConverter) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FileConverter) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FileConverter) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FileConverter) FormatName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END FormatName; PROCEDURE (this: FileConverter) ClassName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END ClassName; PROCEDURE (this: FileConverter) SaveFormat* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END SaveFormat; PROCEDURE (this: FileConverter) OpenFormat* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END OpenFormat; PROCEDURE (this: FileConverter) CanSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END CanSave; PROCEDURE (this: FileConverter) CanOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END CanOpen; PROCEDURE (this: FileConverter) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 6) END Path; PROCEDURE (this: FileConverter) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 7) END Name; PROCEDURE (this: FileConverter) Extensions* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 8) END Extensions; (* ---------- FileConverters, dual, nonextensible ---------- *) PROCEDURE (this: FileConverters) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FileConverters) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FileConverters) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: FileConverters) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: FileConverters) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: FileConverters) ConvertMacWordChevrons* (): WdChevronConvertRule, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END ConvertMacWordChevrons; PROCEDURE (this: FileConverters) PUTConvertMacWordChevrons* (p1: WdChevronConvertRule), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTConvertMacWordChevrons; PROCEDURE (this: FileConverters) Item* (Index: CtlT.Any): FileConverter, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisFileConverter(CtlC.VarAny(ret)) END Item; (* ---------- SynonymInfo, dual, nonextensible ---------- *) PROCEDURE (this: SynonymInfo) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: SynonymInfo) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: SynonymInfo) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: SynonymInfo) Word* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Word; PROCEDURE (this: SynonymInfo) Found* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Found; PROCEDURE (this: SynonymInfo) MeaningCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END MeaningCount; PROCEDURE (this: SynonymInfo) MeaningList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 4) END MeaningList; PROCEDURE (this: SynonymInfo) PartOfSpeechList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 5) END PartOfSpeechList; PROCEDURE (this: SynonymInfo) SynonymList* (Meaning: CtlT.Any): CtlT.Any, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Meaning, arg[0]); CtlC.CallGetMethod(this, 7, arg, ret); RETURN CtlC.VarAny(ret) END SynonymList; PROCEDURE (this: SynonymInfo) AntonymList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 8) END AntonymList; PROCEDURE (this: SynonymInfo) RelatedExpressionList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 9) END RelatedExpressionList; PROCEDURE (this: SynonymInfo) RelatedWordList* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 10) END RelatedWordList; (* ---------- Hyperlinks, dual, nonextensible ---------- *) PROCEDURE (this: Hyperlinks) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Hyperlinks) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Hyperlinks) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Hyperlinks) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Hyperlinks) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Hyperlinks) Item* (Index: CtlT.Any): Hyperlink, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Hyperlinks) _Add* (Anchor: CtlT.Object; (* optional *) Address: CtlT.Any; SubAddress: CtlT.Any): Hyperlink, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Anchor, arg[2]); CtlC.AnyVar(Address, arg[1]); CtlC.AnyVar(SubAddress, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END _Add; PROCEDURE (this: Hyperlinks) Add* (Anchor: CtlT.Object; (* optional *) Address: CtlT.Any; SubAddress: CtlT.Any; ScreenTip: CtlT.Any; TextToDisplay: CtlT.Any; Target: CtlT.Any): Hyperlink, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(Anchor, arg[5]); CtlC.AnyVar(Address, arg[4]); CtlC.AnyVar(SubAddress, arg[3]); CtlC.AnyVar(ScreenTip, arg[2]); CtlC.AnyVar(TextToDisplay, arg[1]); CtlC.AnyVar(Target, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisHyperlink(CtlC.VarAny(ret)) END Add; (* ---------- Hyperlink, dual, nonextensible ---------- *) PROCEDURE (this: Hyperlink) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Hyperlink) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Hyperlink) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Hyperlink) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1003) END Name; PROCEDURE (this: Hyperlink) AddressOld* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1004) END AddressOld; PROCEDURE (this: Hyperlink) Type* (): CtlOffice.MsoHyperlinkType, NEW; BEGIN RETURN CtlC.GetInt(this, 1005) END Type; PROCEDURE (this: Hyperlink) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1006)) END Range; PROCEDURE (this: Hyperlink) Shape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1007)) END Shape; PROCEDURE (this: Hyperlink) SubAddressOld* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1008) END SubAddressOld; PROCEDURE (this: Hyperlink) ExtraInfoRequired* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1009) END ExtraInfoRequired; PROCEDURE (this: Hyperlink) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END Delete; PROCEDURE (this: Hyperlink) Follow* ((* optional *) NewWindow: CtlT.Any; AddHistory: CtlT.Any; ExtraInfo: CtlT.Any; Method: CtlT.Any; HeaderInfo: CtlT.Any), NEW; VAR arg: ARRAY 5 OF CtlT.Variant; BEGIN CtlC.AnyVar(NewWindow, arg[4]); CtlC.AnyVar(AddHistory, arg[3]); CtlC.AnyVar(ExtraInfo, arg[2]); CtlC.AnyVar(Method, arg[1]); CtlC.AnyVar(HeaderInfo, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END Follow; PROCEDURE (this: Hyperlink) AddToFavorites* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END AddToFavorites; PROCEDURE (this: Hyperlink) CreateNewDocument* (FileName: ARRAY OF CHAR; EditNow: BOOLEAN; Overwrite: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[2]); CtlC.BoolVar(EditNow, arg[1]); CtlC.BoolVar(Overwrite, arg[0]); CtlC.CallParMethod(this, 106, arg, NIL); END CreateNewDocument; PROCEDURE (this: Hyperlink) Address* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1100) END Address; PROCEDURE (this: Hyperlink) PUTAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1100, p1) END PUTAddress; PROCEDURE (this: Hyperlink) SubAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1101) END SubAddress; PROCEDURE (this: Hyperlink) PUTSubAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1101, p1) END PUTSubAddress; PROCEDURE (this: Hyperlink) EmailSubject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1010) END EmailSubject; PROCEDURE (this: Hyperlink) PUTEmailSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1010, p1) END PUTEmailSubject; PROCEDURE (this: Hyperlink) ScreenTip* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1011) END ScreenTip; PROCEDURE (this: Hyperlink) PUTScreenTip* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1011, p1) END PUTScreenTip; PROCEDURE (this: Hyperlink) TextToDisplay* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1012) END TextToDisplay; PROCEDURE (this: Hyperlink) PUTTextToDisplay* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1012, p1) END PUTTextToDisplay; PROCEDURE (this: Hyperlink) Target* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1013) END Target; PROCEDURE (this: Hyperlink) PUTTarget* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 1013, p1) END PUTTarget; (* ---------- Shapes, dual, nonextensible ---------- *) PROCEDURE (this: Shapes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 8000)) END Application; PROCEDURE (this: Shapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8001) END Creator; PROCEDURE (this: Shapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Shapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Shapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Shapes) AddCallout* (Type: CtlOffice.MsoCalloutType; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[5]); CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 10, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCallout; PROCEDURE (this: Shapes) AddConnector* (Type: CtlOffice.MsoConnectorType; BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[4]); CtlC.SRealVar(BeginX, arg[3]); CtlC.SRealVar(BeginY, arg[2]); CtlC.SRealVar(EndX, arg[1]); CtlC.SRealVar(EndY, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddConnector; PROCEDURE (this: Shapes) AddCurve* (SafeArrayOfPoints: CtlT.Any; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 12, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddCurve; PROCEDURE (this: Shapes) AddLabel* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[5]); CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 13, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLabel; PROCEDURE (this: Shapes) AddLine* (BeginX: SHORTREAL; BeginY: SHORTREAL; EndX: SHORTREAL; EndY: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 5 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.SRealVar(BeginX, arg[4]); CtlC.SRealVar(BeginY, arg[3]); CtlC.SRealVar(EndX, arg[2]); CtlC.SRealVar(EndY, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 14, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddLine; PROCEDURE (this: Shapes) AddPicture* (FileName: ARRAY OF CHAR; (* optional *) LinkToFile: CtlT.Any; SaveWithDocument: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any; Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[7]); CtlC.AnyVar(LinkToFile, arg[6]); CtlC.AnyVar(SaveWithDocument, arg[5]); CtlC.AnyVar(Left, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Width, arg[2]); CtlC.AnyVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 15, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPicture; PROCEDURE (this: Shapes) AddPolyline* (SafeArrayOfPoints: CtlT.Any; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(SafeArrayOfPoints, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 16, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddPolyline; PROCEDURE (this: Shapes) AddShape* (Type: INTEGER; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Type, arg[5]); CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 17, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddShape; PROCEDURE (this: Shapes) AddTextEffect* (PresetTextEffect: CtlOffice.MsoPresetTextEffect; Text: ARRAY OF CHAR; FontName: ARRAY OF CHAR; FontSize: SHORTREAL; FontBold: CtlOffice.MsoTriState; FontItalic: CtlOffice.MsoTriState; Left: SHORTREAL; Top: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 9 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(PresetTextEffect, arg[8]); CtlC.StrVar(Text, arg[7]); CtlC.StrVar(FontName, arg[6]); CtlC.SRealVar(FontSize, arg[5]); CtlC.IntVar(FontBold, arg[4]); CtlC.IntVar(FontItalic, arg[3]); CtlC.SRealVar(Left, arg[2]); CtlC.SRealVar(Top, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 18, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextEffect; PROCEDURE (this: Shapes) AddTextbox* (Orientation: CtlOffice.MsoTextOrientation; Left: SHORTREAL; Top: SHORTREAL; Width: SHORTREAL; Height: SHORTREAL; (* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Orientation, arg[5]); CtlC.SRealVar(Left, arg[4]); CtlC.SRealVar(Top, arg[3]); CtlC.SRealVar(Width, arg[2]); CtlC.SRealVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 19, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddTextbox; PROCEDURE (this: Shapes) BuildFreeform* (EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL): FreeformBuilder, NEW; VAR arg: ARRAY 3 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(EditingType, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 20, arg, ret); RETURN ThisFreeformBuilder(CtlC.VarAny(ret)) END BuildFreeform; PROCEDURE (this: Shapes) Range* (Index: CtlT.Any): ShapeRange, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 21, arg, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Range; PROCEDURE (this: Shapes) SelectAll* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SelectAll; PROCEDURE (this: Shapes) AddOLEObject* ((* optional *) ClassType: CtlT.Any; FileName: CtlT.Any; LinkToFile: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any; Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 12 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[11]); CtlC.AnyVar(FileName, arg[10]); CtlC.AnyVar(LinkToFile, arg[9]); CtlC.AnyVar(DisplayAsIcon, arg[8]); CtlC.AnyVar(IconFileName, arg[7]); CtlC.AnyVar(IconIndex, arg[6]); CtlC.AnyVar(IconLabel, arg[5]); CtlC.AnyVar(Left, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Width, arg[2]); CtlC.AnyVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 24, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddOLEObject; PROCEDURE (this: Shapes) AddOLEControl* ((* optional *) ClassType: CtlT.Any; Left: CtlT.Any; Top: CtlT.Any; Width: CtlT.Any; Height: CtlT.Any; Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 6 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[5]); CtlC.AnyVar(Left, arg[4]); CtlC.AnyVar(Top, arg[3]); CtlC.AnyVar(Width, arg[2]); CtlC.AnyVar(Height, arg[1]); CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END AddOLEControl; (* ---------- ShapeRange, dual, nonextensible ---------- *) PROCEDURE (this: ShapeRange) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 8000)) END Application; PROCEDURE (this: ShapeRange) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8001) END Creator; PROCEDURE (this: ShapeRange) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeRange) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeRange) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeRange) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: ShapeRange) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: ShapeRange) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: ShapeRange) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: ShapeRange) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: ShapeRange) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: ShapeRange) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: ShapeRange) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: ShapeRange) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: ShapeRange) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: ShapeRange) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: ShapeRange) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: ShapeRange) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: ShapeRange) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: ShapeRange) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: ShapeRange) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: ShapeRange) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: ShapeRange) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: ShapeRange) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: ShapeRange) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: ShapeRange) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: ShapeRange) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: ShapeRange) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: ShapeRange) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: ShapeRange) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: ShapeRange) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: ShapeRange) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: ShapeRange) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: ShapeRange) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: ShapeRange) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: ShapeRange) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: ShapeRange) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: ShapeRange) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: ShapeRange) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: ShapeRange) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: ShapeRange) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: ShapeRange) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: ShapeRange) Hyperlink* (): Hyperlink, NEW; BEGIN RETURN ThisHyperlink(CtlC.GetAny(this, 1001)) END Hyperlink; PROCEDURE (this: ShapeRange) RelativeHorizontalPosition* (): WdRelativeHorizontalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 300) END RelativeHorizontalPosition; PROCEDURE (this: ShapeRange) PUTRelativeHorizontalPosition* (p1: WdRelativeHorizontalPosition), NEW; BEGIN CtlC.PutInt(this, 300, p1) END PUTRelativeHorizontalPosition; PROCEDURE (this: ShapeRange) RelativeVerticalPosition* (): WdRelativeVerticalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 301) END RelativeVerticalPosition; PROCEDURE (this: ShapeRange) PUTRelativeVerticalPosition* (p1: WdRelativeVerticalPosition), NEW; BEGIN CtlC.PutInt(this, 301, p1) END PUTRelativeVerticalPosition; PROCEDURE (this: ShapeRange) LockAnchor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 302) END LockAnchor; PROCEDURE (this: ShapeRange) PUTLockAnchor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 302, p1) END PUTLockAnchor; PROCEDURE (this: ShapeRange) WrapFormat* (): WrapFormat, NEW; BEGIN RETURN ThisWrapFormat(CtlC.GetAny(this, 303)) END WrapFormat; PROCEDURE (this: ShapeRange) Anchor* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 304)) END Anchor; PROCEDURE (this: ShapeRange) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeRange) Align* (Align: CtlOffice.MsoAlignCmd; RelativeTo: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Align, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END Align; PROCEDURE (this: ShapeRange) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Apply; PROCEDURE (this: ShapeRange) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END Delete; PROCEDURE (this: ShapeRange) Distribute* (Distribute: CtlOffice.MsoDistributeCmd; RelativeTo: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Distribute, arg[1]); CtlC.IntVar(RelativeTo, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Distribute; PROCEDURE (this: ShapeRange) Duplicate* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 14, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: ShapeRange) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END Flip; PROCEDURE (this: ShapeRange) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementLeft; PROCEDURE (this: ShapeRange) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END IncrementRotation; PROCEDURE (this: ShapeRange) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END IncrementTop; PROCEDURE (this: ShapeRange) Group* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 19, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Group; PROCEDURE (this: ShapeRange) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 20, NIL); END PickUp; PROCEDURE (this: ShapeRange) Regroup* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 21, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Regroup; PROCEDURE (this: ShapeRange) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END RerouteConnections; PROCEDURE (this: ShapeRange) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; Scale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(Scale, arg[0]); CtlC.CallParMethod(this, 23, arg, NIL); END ScaleHeight; PROCEDURE (this: ShapeRange) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; Scale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(Scale, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ScaleWidth; PROCEDURE (this: ShapeRange) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 25, arg, NIL); END Select; PROCEDURE (this: ShapeRange) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 26, NIL); END SetShapesDefaultProperties; PROCEDURE (this: ShapeRange) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 27, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: ShapeRange) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 28, arg, NIL); END ZOrder; PROCEDURE (this: ShapeRange) ConvertToFrame* (): Frame, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 29, ret); RETURN ThisFrame(CtlC.VarAny(ret)) END ConvertToFrame; PROCEDURE (this: ShapeRange) ConvertToInlineShape* (): InlineShape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 30, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END ConvertToInlineShape; PROCEDURE (this: ShapeRange) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 50, NIL); END Activate; PROCEDURE (this: ShapeRange) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: ShapeRange) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; (* ---------- GroupShapes, dual, nonextensible ---------- *) PROCEDURE (this: GroupShapes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 8000)) END Application; PROCEDURE (this: GroupShapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8001) END Creator; PROCEDURE (this: GroupShapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: GroupShapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: GroupShapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: GroupShapes) Item* (Index: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Item; (* ---------- Shape, dual, nonextensible ---------- *) PROCEDURE (this: Shape) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 8000)) END Application; PROCEDURE (this: Shape) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8001) END Creator; PROCEDURE (this: Shape) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Shape) Adjustments* (): Adjustments, NEW; BEGIN RETURN ThisAdjustments(CtlC.GetAny(this, 100)) END Adjustments; PROCEDURE (this: Shape) AutoShapeType* (): CtlOffice.MsoAutoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END AutoShapeType; PROCEDURE (this: Shape) PUTAutoShapeType* (p1: CtlOffice.MsoAutoShapeType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAutoShapeType; PROCEDURE (this: Shape) Callout* (): CalloutFormat, NEW; BEGIN RETURN ThisCalloutFormat(CtlC.GetAny(this, 103)) END Callout; PROCEDURE (this: Shape) ConnectionSiteCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END ConnectionSiteCount; PROCEDURE (this: Shape) Connector* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Connector; PROCEDURE (this: Shape) ConnectorFormat* (): ConnectorFormat, NEW; BEGIN RETURN ThisConnectorFormat(CtlC.GetAny(this, 106)) END ConnectorFormat; PROCEDURE (this: Shape) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: Shape) GroupItems* (): GroupShapes, NEW; BEGIN RETURN ThisGroupShapes(CtlC.GetAny(this, 108)) END GroupItems; PROCEDURE (this: Shape) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END Height; PROCEDURE (this: Shape) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTHeight; PROCEDURE (this: Shape) HorizontalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END HorizontalFlip; PROCEDURE (this: Shape) Left* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Left; PROCEDURE (this: Shape) PUTLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTLeft; PROCEDURE (this: Shape) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: Shape) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END LockAspectRatio; PROCEDURE (this: Shape) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTLockAspectRatio; PROCEDURE (this: Shape) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END Name; PROCEDURE (this: Shape) PUTName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTName; PROCEDURE (this: Shape) Nodes* (): ShapeNodes, NEW; BEGIN RETURN ThisShapeNodes(CtlC.GetAny(this, 116)) END Nodes; PROCEDURE (this: Shape) Rotation* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 117) END Rotation; PROCEDURE (this: Shape) PUTRotation* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 117, p1) END PUTRotation; PROCEDURE (this: Shape) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: Shape) Shadow* (): ShadowFormat, NEW; BEGIN RETURN ThisShadowFormat(CtlC.GetAny(this, 119)) END Shadow; PROCEDURE (this: Shape) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: Shape) TextFrame* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 121)) END TextFrame; PROCEDURE (this: Shape) ThreeD* (): ThreeDFormat, NEW; BEGIN RETURN ThisThreeDFormat(CtlC.GetAny(this, 122)) END ThreeD; PROCEDURE (this: Shape) Top* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 123) END Top; PROCEDURE (this: Shape) PUTTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 123, p1) END PUTTop; PROCEDURE (this: Shape) Type* (): CtlOffice.MsoShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 124) END Type; PROCEDURE (this: Shape) VerticalFlip* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 125) END VerticalFlip; PROCEDURE (this: Shape) Vertices* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 126) END Vertices; PROCEDURE (this: Shape) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END Visible; PROCEDURE (this: Shape) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTVisible; PROCEDURE (this: Shape) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 128) END Width; PROCEDURE (this: Shape) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 128, p1) END PUTWidth; PROCEDURE (this: Shape) ZOrderPosition* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 129) END ZOrderPosition; PROCEDURE (this: Shape) Hyperlink* (): Hyperlink, NEW; BEGIN RETURN ThisHyperlink(CtlC.GetAny(this, 1001)) END Hyperlink; PROCEDURE (this: Shape) RelativeHorizontalPosition* (): WdRelativeHorizontalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 300) END RelativeHorizontalPosition; PROCEDURE (this: Shape) PUTRelativeHorizontalPosition* (p1: WdRelativeHorizontalPosition), NEW; BEGIN CtlC.PutInt(this, 300, p1) END PUTRelativeHorizontalPosition; PROCEDURE (this: Shape) RelativeVerticalPosition* (): WdRelativeVerticalPosition, NEW; BEGIN RETURN CtlC.GetInt(this, 301) END RelativeVerticalPosition; PROCEDURE (this: Shape) PUTRelativeVerticalPosition* (p1: WdRelativeVerticalPosition), NEW; BEGIN CtlC.PutInt(this, 301, p1) END PUTRelativeVerticalPosition; PROCEDURE (this: Shape) LockAnchor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 302) END LockAnchor; PROCEDURE (this: Shape) PUTLockAnchor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 302, p1) END PUTLockAnchor; PROCEDURE (this: Shape) WrapFormat* (): WrapFormat, NEW; BEGIN RETURN ThisWrapFormat(CtlC.GetAny(this, 303)) END WrapFormat; PROCEDURE (this: Shape) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 500)) END OLEFormat; PROCEDURE (this: Shape) Anchor* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 501)) END Anchor; PROCEDURE (this: Shape) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 502)) END LinkFormat; PROCEDURE (this: Shape) Apply* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Apply; PROCEDURE (this: Shape) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END Delete; PROCEDURE (this: Shape) Duplicate* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 12, ret); RETURN ThisShape(CtlC.VarAny(ret)) END Duplicate; PROCEDURE (this: Shape) Flip* (FlipCmd: CtlOffice.MsoFlipCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(FlipCmd, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END Flip; PROCEDURE (this: Shape) IncrementLeft* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END IncrementLeft; PROCEDURE (this: Shape) IncrementRotation* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END IncrementRotation; PROCEDURE (this: Shape) IncrementTop* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END IncrementTop; PROCEDURE (this: Shape) PickUp* (), NEW; BEGIN CtlC.CallMethod(this, 17, NIL); END PickUp; PROCEDURE (this: Shape) RerouteConnections* (), NEW; BEGIN CtlC.CallMethod(this, 18, NIL); END RerouteConnections; PROCEDURE (this: Shape) ScaleHeight* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; Scale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(Scale, arg[0]); CtlC.CallParMethod(this, 19, arg, NIL); END ScaleHeight; PROCEDURE (this: Shape) ScaleWidth* (Factor: SHORTREAL; RelativeToOriginalSize: CtlOffice.MsoTriState; Scale: CtlOffice.MsoScaleFrom), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.SRealVar(Factor, arg[2]); CtlC.IntVar(RelativeToOriginalSize, arg[1]); CtlC.IntVar(Scale, arg[0]); CtlC.CallParMethod(this, 20, arg, NIL); END ScaleWidth; PROCEDURE (this: Shape) Select* ((* optional *) Replace: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Replace, arg[0]); CtlC.CallParMethod(this, 21, arg, NIL); END Select; PROCEDURE (this: Shape) SetShapesDefaultProperties* (), NEW; BEGIN CtlC.CallMethod(this, 22, NIL); END SetShapesDefaultProperties; PROCEDURE (this: Shape) Ungroup* (): ShapeRange, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 23, ret); RETURN ThisShapeRange(CtlC.VarAny(ret)) END Ungroup; PROCEDURE (this: Shape) ZOrder* (ZOrderCmd: CtlOffice.MsoZOrderCmd), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(ZOrderCmd, arg[0]); CtlC.CallParMethod(this, 24, arg, NIL); END ZOrder; PROCEDURE (this: Shape) ConvertToInlineShape* (): InlineShape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 25, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END ConvertToInlineShape; PROCEDURE (this: Shape) ConvertToFrame* (): Frame, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 29, ret); RETURN ThisFrame(CtlC.VarAny(ret)) END ConvertToFrame; PROCEDURE (this: Shape) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 50, NIL); END Activate; PROCEDURE (this: Shape) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: Shape) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; PROCEDURE (this: Shape) Script* (): CtlOffice.Script, NEW; BEGIN RETURN CtlOffice.ThisScript(CtlC.GetAny(this, 503)) END Script; (* ---------- TextFrame, dual, nonextensible ---------- *) PROCEDURE (this: TextFrame) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 8000)) END Application; PROCEDURE (this: TextFrame) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 8001) END Creator; PROCEDURE (this: TextFrame) Parent* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 1)) END Parent; PROCEDURE (this: TextFrame) MarginBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END MarginBottom; PROCEDURE (this: TextFrame) PUTMarginBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTMarginBottom; PROCEDURE (this: TextFrame) MarginLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 101) END MarginLeft; PROCEDURE (this: TextFrame) PUTMarginLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 101, p1) END PUTMarginLeft; PROCEDURE (this: TextFrame) MarginRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END MarginRight; PROCEDURE (this: TextFrame) PUTMarginRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTMarginRight; PROCEDURE (this: TextFrame) MarginTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END MarginTop; PROCEDURE (this: TextFrame) PUTMarginTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTMarginTop; PROCEDURE (this: TextFrame) Orientation* (): CtlOffice.MsoTextOrientation, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Orientation; PROCEDURE (this: TextFrame) PUTOrientation* (p1: CtlOffice.MsoTextOrientation), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTOrientation; PROCEDURE (this: TextFrame) TextRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1001)) END TextRange; PROCEDURE (this: TextFrame) ContainingRange* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 1002)) END ContainingRange; PROCEDURE (this: TextFrame) Next* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 5001)) END Next; PROCEDURE (this: TextFrame) PUTNext* (p1: TextFrame), NEW; BEGIN CtlC.PutObj(this, 5001, p1) END PUTNext; PROCEDURE (this: TextFrame) Previous* (): TextFrame, NEW; BEGIN RETURN ThisTextFrame(CtlC.GetAny(this, 5002)) END Previous; PROCEDURE (this: TextFrame) PUTPrevious* (p1: TextFrame), NEW; BEGIN CtlC.PutObj(this, 5002, p1) END PUTPrevious; PROCEDURE (this: TextFrame) Overflowing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5003) END Overflowing; PROCEDURE (this: TextFrame) HasText* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5008) END HasText; PROCEDURE (this: TextFrame) BreakForwardLink* (), NEW; BEGIN CtlC.CallMethod(this, 5004, NIL); END BreakForwardLink; PROCEDURE (this: TextFrame) ValidLinkTarget* (TargetTextFrame: TextFrame): BOOLEAN, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(TargetTextFrame, arg[0]); CtlC.CallParMethod(this, 5006, arg, ret); RETURN CtlC.VarBool(ret) END ValidLinkTarget; (* ---------- _LetterContent, hidden, dual, nonextensible ---------- *) PROCEDURE (this: _LetterContent) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: _LetterContent) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: _LetterContent) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: _LetterContent) Duplicate* (): LetterContent, NEW; BEGIN RETURN This_LetterContent(CtlC.GetAny(this, 10)) END Duplicate; PROCEDURE (this: _LetterContent) DateFormat* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 101) END DateFormat; PROCEDURE (this: _LetterContent) PUTDateFormat* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 101, p1) END PUTDateFormat; PROCEDURE (this: _LetterContent) IncludeHeaderFooter* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 102) END IncludeHeaderFooter; PROCEDURE (this: _LetterContent) PUTIncludeHeaderFooter* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 102, p1) END PUTIncludeHeaderFooter; PROCEDURE (this: _LetterContent) PageDesign* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END PageDesign; PROCEDURE (this: _LetterContent) PUTPageDesign* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTPageDesign; PROCEDURE (this: _LetterContent) LetterStyle* (): WdLetterStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END LetterStyle; PROCEDURE (this: _LetterContent) PUTLetterStyle* (p1: WdLetterStyle), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTLetterStyle; PROCEDURE (this: _LetterContent) Letterhead* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 105) END Letterhead; PROCEDURE (this: _LetterContent) PUTLetterhead* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 105, p1) END PUTLetterhead; PROCEDURE (this: _LetterContent) LetterheadLocation* (): WdLetterheadLocation, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END LetterheadLocation; PROCEDURE (this: _LetterContent) PUTLetterheadLocation* (p1: WdLetterheadLocation), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTLetterheadLocation; PROCEDURE (this: _LetterContent) LetterheadSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END LetterheadSize; PROCEDURE (this: _LetterContent) PUTLetterheadSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTLetterheadSize; PROCEDURE (this: _LetterContent) RecipientName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 108) END RecipientName; PROCEDURE (this: _LetterContent) PUTRecipientName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 108, p1) END PUTRecipientName; PROCEDURE (this: _LetterContent) RecipientAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END RecipientAddress; PROCEDURE (this: _LetterContent) PUTRecipientAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 109, p1) END PUTRecipientAddress; PROCEDURE (this: _LetterContent) Salutation* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Salutation; PROCEDURE (this: _LetterContent) PUTSalutation* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTSalutation; PROCEDURE (this: _LetterContent) SalutationType* (): WdSalutationType, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END SalutationType; PROCEDURE (this: _LetterContent) PUTSalutationType* (p1: WdSalutationType), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTSalutationType; PROCEDURE (this: _LetterContent) RecipientReference* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 112) END RecipientReference; PROCEDURE (this: _LetterContent) PUTRecipientReference* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 112, p1) END PUTRecipientReference; PROCEDURE (this: _LetterContent) MailingInstructions* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 114) END MailingInstructions; PROCEDURE (this: _LetterContent) PUTMailingInstructions* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 114, p1) END PUTMailingInstructions; PROCEDURE (this: _LetterContent) AttentionLine* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 115) END AttentionLine; PROCEDURE (this: _LetterContent) PUTAttentionLine* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 115, p1) END PUTAttentionLine; PROCEDURE (this: _LetterContent) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 116) END Subject; PROCEDURE (this: _LetterContent) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 116, p1) END PUTSubject; PROCEDURE (this: _LetterContent) EnclosureNumber* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 117) END EnclosureNumber; PROCEDURE (this: _LetterContent) PUTEnclosureNumber* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 117, p1) END PUTEnclosureNumber; PROCEDURE (this: _LetterContent) CCList* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 118) END CCList; PROCEDURE (this: _LetterContent) PUTCCList* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 118, p1) END PUTCCList; PROCEDURE (this: _LetterContent) ReturnAddress* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 119) END ReturnAddress; PROCEDURE (this: _LetterContent) PUTReturnAddress* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 119, p1) END PUTReturnAddress; PROCEDURE (this: _LetterContent) SenderName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 120) END SenderName; PROCEDURE (this: _LetterContent) PUTSenderName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 120, p1) END PUTSenderName; PROCEDURE (this: _LetterContent) Closing* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 121) END Closing; PROCEDURE (this: _LetterContent) PUTClosing* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 121, p1) END PUTClosing; PROCEDURE (this: _LetterContent) SenderCompany* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 122) END SenderCompany; PROCEDURE (this: _LetterContent) PUTSenderCompany* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 122, p1) END PUTSenderCompany; PROCEDURE (this: _LetterContent) SenderJobTitle* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 123) END SenderJobTitle; PROCEDURE (this: _LetterContent) PUTSenderJobTitle* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 123, p1) END PUTSenderJobTitle; PROCEDURE (this: _LetterContent) SenderInitials* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 124) END SenderInitials; PROCEDURE (this: _LetterContent) PUTSenderInitials* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 124, p1) END PUTSenderInitials; PROCEDURE (this: _LetterContent) InfoBlock* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 125) END InfoBlock; PROCEDURE (this: _LetterContent) PUTInfoBlock* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 125, p1) END PUTInfoBlock; PROCEDURE (this: _LetterContent) RecipientCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 126) END RecipientCode; PROCEDURE (this: _LetterContent) PUTRecipientCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 126, p1) END PUTRecipientCode; PROCEDURE (this: _LetterContent) RecipientGender* (): WdSalutationGender, NEW; BEGIN RETURN CtlC.GetInt(this, 127) END RecipientGender; PROCEDURE (this: _LetterContent) PUTRecipientGender* (p1: WdSalutationGender), NEW; BEGIN CtlC.PutInt(this, 127, p1) END PUTRecipientGender; PROCEDURE (this: _LetterContent) ReturnAddressShortForm* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 128) END ReturnAddressShortForm; PROCEDURE (this: _LetterContent) PUTReturnAddressShortForm* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 128, p1) END PUTReturnAddressShortForm; PROCEDURE (this: _LetterContent) SenderCity* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 129) END SenderCity; PROCEDURE (this: _LetterContent) PUTSenderCity* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 129, p1) END PUTSenderCity; PROCEDURE (this: _LetterContent) SenderCode* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 130) END SenderCode; PROCEDURE (this: _LetterContent) PUTSenderCode* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 130, p1) END PUTSenderCode; PROCEDURE (this: _LetterContent) SenderGender* (): WdSalutationGender, NEW; BEGIN RETURN CtlC.GetInt(this, 131) END SenderGender; PROCEDURE (this: _LetterContent) PUTSenderGender* (p1: WdSalutationGender), NEW; BEGIN CtlC.PutInt(this, 131, p1) END PUTSenderGender; PROCEDURE (this: _LetterContent) SenderReference* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 132) END SenderReference; PROCEDURE (this: _LetterContent) PUTSenderReference* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 132, p1) END PUTSenderReference; (* ---------- View, dual, nonextensible ---------- *) PROCEDURE (this: View) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: View) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: View) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: View) Type* (): WdViewType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Type; PROCEDURE (this: View) PUTType* (p1: WdViewType), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTType; PROCEDURE (this: View) FullScreen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END FullScreen; PROCEDURE (this: View) PUTFullScreen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTFullScreen; PROCEDURE (this: View) Draft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 2) END Draft; PROCEDURE (this: View) PUTDraft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 2, p1) END PUTDraft; PROCEDURE (this: View) ShowAll* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END ShowAll; PROCEDURE (this: View) PUTShowAll* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTShowAll; PROCEDURE (this: View) ShowFieldCodes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END ShowFieldCodes; PROCEDURE (this: View) PUTShowFieldCodes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTShowFieldCodes; PROCEDURE (this: View) MailMergeDataView* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END MailMergeDataView; PROCEDURE (this: View) PUTMailMergeDataView* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTMailMergeDataView; PROCEDURE (this: View) Magnifier* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END Magnifier; PROCEDURE (this: View) PUTMagnifier* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTMagnifier; PROCEDURE (this: View) ShowFirstLineOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END ShowFirstLineOnly; PROCEDURE (this: View) PUTShowFirstLineOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTShowFirstLineOnly; PROCEDURE (this: View) ShowFormat* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END ShowFormat; PROCEDURE (this: View) PUTShowFormat* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTShowFormat; PROCEDURE (this: View) Zoom* (): Zoom, NEW; BEGIN RETURN ThisZoom(CtlC.GetAny(this, 10)) END Zoom; PROCEDURE (this: View) ShowObjectAnchors* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 11) END ShowObjectAnchors; PROCEDURE (this: View) PUTShowObjectAnchors* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 11, p1) END PUTShowObjectAnchors; PROCEDURE (this: View) ShowTextBoundaries* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 12) END ShowTextBoundaries; PROCEDURE (this: View) PUTShowTextBoundaries* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 12, p1) END PUTShowTextBoundaries; PROCEDURE (this: View) ShowHighlight* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 13) END ShowHighlight; PROCEDURE (this: View) PUTShowHighlight* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 13, p1) END PUTShowHighlight; PROCEDURE (this: View) ShowDrawings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END ShowDrawings; PROCEDURE (this: View) PUTShowDrawings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTShowDrawings; PROCEDURE (this: View) ShowTabs* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 15) END ShowTabs; PROCEDURE (this: View) PUTShowTabs* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 15, p1) END PUTShowTabs; PROCEDURE (this: View) ShowSpaces* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 16) END ShowSpaces; PROCEDURE (this: View) PUTShowSpaces* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 16, p1) END PUTShowSpaces; PROCEDURE (this: View) ShowParagraphs* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 17) END ShowParagraphs; PROCEDURE (this: View) PUTShowParagraphs* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 17, p1) END PUTShowParagraphs; PROCEDURE (this: View) ShowHyphens* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 18) END ShowHyphens; PROCEDURE (this: View) PUTShowHyphens* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 18, p1) END PUTShowHyphens; PROCEDURE (this: View) ShowHiddenText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 19) END ShowHiddenText; PROCEDURE (this: View) PUTShowHiddenText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 19, p1) END PUTShowHiddenText; PROCEDURE (this: View) WrapToWindow* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END WrapToWindow; PROCEDURE (this: View) PUTWrapToWindow* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTWrapToWindow; PROCEDURE (this: View) ShowPicturePlaceHolders* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 21) END ShowPicturePlaceHolders; PROCEDURE (this: View) PUTShowPicturePlaceHolders* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 21, p1) END PUTShowPicturePlaceHolders; PROCEDURE (this: View) ShowBookmarks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 22) END ShowBookmarks; PROCEDURE (this: View) PUTShowBookmarks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 22, p1) END PUTShowBookmarks; PROCEDURE (this: View) FieldShading* (): WdFieldShading, NEW; BEGIN RETURN CtlC.GetInt(this, 23) END FieldShading; PROCEDURE (this: View) PUTFieldShading* (p1: WdFieldShading), NEW; BEGIN CtlC.PutInt(this, 23, p1) END PUTFieldShading; PROCEDURE (this: View) ShowAnimation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END ShowAnimation; PROCEDURE (this: View) PUTShowAnimation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTShowAnimation; PROCEDURE (this: View) TableGridlines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 25) END TableGridlines; PROCEDURE (this: View) PUTTableGridlines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 25, p1) END PUTTableGridlines; PROCEDURE (this: View) EnlargeFontsLessThan* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END EnlargeFontsLessThan; PROCEDURE (this: View) PUTEnlargeFontsLessThan* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTEnlargeFontsLessThan; PROCEDURE (this: View) ShowMainTextLayer* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 27) END ShowMainTextLayer; PROCEDURE (this: View) PUTShowMainTextLayer* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 27, p1) END PUTShowMainTextLayer; PROCEDURE (this: View) SeekView* (): WdSeekView, NEW; BEGIN RETURN CtlC.GetInt(this, 28) END SeekView; PROCEDURE (this: View) PUTSeekView* (p1: WdSeekView), NEW; BEGIN CtlC.PutInt(this, 28, p1) END PUTSeekView; PROCEDURE (this: View) SplitSpecial* (): WdSpecialPane, NEW; BEGIN RETURN CtlC.GetInt(this, 29) END SplitSpecial; PROCEDURE (this: View) PUTSplitSpecial* (p1: WdSpecialPane), NEW; BEGIN CtlC.PutInt(this, 29, p1) END PUTSplitSpecial; PROCEDURE (this: View) BrowseToWindow* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 30) END BrowseToWindow; PROCEDURE (this: View) PUTBrowseToWindow* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 30, p1) END PUTBrowseToWindow; PROCEDURE (this: View) ShowOptionalBreaks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 31) END ShowOptionalBreaks; PROCEDURE (this: View) PUTShowOptionalBreaks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 31, p1) END PUTShowOptionalBreaks; PROCEDURE (this: View) CollapseOutline* ((* optional *) Range: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 101, arg, NIL); END CollapseOutline; PROCEDURE (this: View) ExpandOutline* ((* optional *) Range: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 102, arg, NIL); END ExpandOutline; PROCEDURE (this: View) ShowAllHeadings* (), NEW; BEGIN CtlC.CallMethod(this, 103, NIL); END ShowAllHeadings; PROCEDURE (this: View) ShowHeading* (Level: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Level, arg[0]); CtlC.CallParMethod(this, 104, arg, NIL); END ShowHeading; PROCEDURE (this: View) PreviousHeaderFooter* (), NEW; BEGIN CtlC.CallMethod(this, 105, NIL); END PreviousHeaderFooter; PROCEDURE (this: View) NextHeaderFooter* (), NEW; BEGIN CtlC.CallMethod(this, 106, NIL); END NextHeaderFooter; (* ---------- Zoom, dual, nonextensible ---------- *) PROCEDURE (this: Zoom) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Zoom) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Zoom) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Zoom) Percentage* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Percentage; PROCEDURE (this: Zoom) PUTPercentage* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTPercentage; PROCEDURE (this: Zoom) PageFit* (): WdPageFit, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END PageFit; PROCEDURE (this: Zoom) PUTPageFit* (p1: WdPageFit), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTPageFit; PROCEDURE (this: Zoom) PageRows* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END PageRows; PROCEDURE (this: Zoom) PUTPageRows* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTPageRows; PROCEDURE (this: Zoom) PageColumns* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END PageColumns; PROCEDURE (this: Zoom) PUTPageColumns* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTPageColumns; (* ---------- Zooms, dual, nonextensible ---------- *) PROCEDURE (this: Zooms) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Zooms) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Zooms) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Zooms) Item* (Index: WdViewType): Zoom, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisZoom(CtlC.VarAny(ret)) END Item; (* ---------- InlineShape, dual, nonextensible ---------- *) PROCEDURE (this: InlineShape) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: InlineShape) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: InlineShape) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: InlineShape) Borders* (): Borders, NEW; BEGIN RETURN ThisBorders(CtlC.GetAny(this, 1100)) END Borders; PROCEDURE (this: InlineShape) PUTBorders* (p1: Borders), NEW; BEGIN CtlC.PutObj(this, 1100, p1) END PUTBorders; PROCEDURE (this: InlineShape) Range* (): Range, NEW; BEGIN RETURN ThisRange(CtlC.GetAny(this, 2)) END Range; PROCEDURE (this: InlineShape) LinkFormat* (): LinkFormat, NEW; BEGIN RETURN ThisLinkFormat(CtlC.GetAny(this, 3)) END LinkFormat; PROCEDURE (this: InlineShape) Field* (): Field, NEW; BEGIN RETURN ThisField(CtlC.GetAny(this, 4)) END Field; PROCEDURE (this: InlineShape) OLEFormat* (): OLEFormat, NEW; BEGIN RETURN ThisOLEFormat(CtlC.GetAny(this, 5)) END OLEFormat; PROCEDURE (this: InlineShape) Type* (): WdInlineShapeType, NEW; BEGIN RETURN CtlC.GetInt(this, 6) END Type; PROCEDURE (this: InlineShape) Hyperlink* (): Hyperlink, NEW; BEGIN RETURN ThisHyperlink(CtlC.GetAny(this, 7)) END Hyperlink; PROCEDURE (this: InlineShape) Height* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 8) END Height; PROCEDURE (this: InlineShape) PUTHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 8, p1) END PUTHeight; PROCEDURE (this: InlineShape) Width* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 9) END Width; PROCEDURE (this: InlineShape) PUTWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 9, p1) END PUTWidth; PROCEDURE (this: InlineShape) ScaleHeight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 10) END ScaleHeight; PROCEDURE (this: InlineShape) PUTScaleHeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 10, p1) END PUTScaleHeight; PROCEDURE (this: InlineShape) ScaleWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 11) END ScaleWidth; PROCEDURE (this: InlineShape) PUTScaleWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 11, p1) END PUTScaleWidth; PROCEDURE (this: InlineShape) LockAspectRatio* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END LockAspectRatio; PROCEDURE (this: InlineShape) PUTLockAspectRatio* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTLockAspectRatio; PROCEDURE (this: InlineShape) Line* (): LineFormat, NEW; BEGIN RETURN ThisLineFormat(CtlC.GetAny(this, 112)) END Line; PROCEDURE (this: InlineShape) Fill* (): FillFormat, NEW; BEGIN RETURN ThisFillFormat(CtlC.GetAny(this, 107)) END Fill; PROCEDURE (this: InlineShape) PictureFormat* (): PictureFormat, NEW; BEGIN RETURN ThisPictureFormat(CtlC.GetAny(this, 118)) END PictureFormat; PROCEDURE (this: InlineShape) PUTPictureFormat* (p1: PictureFormat), NEW; BEGIN CtlC.PutObj(this, 118, p1) END PUTPictureFormat; PROCEDURE (this: InlineShape) Activate* (), NEW; BEGIN CtlC.CallMethod(this, 100, NIL); END Activate; PROCEDURE (this: InlineShape) Reset* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Reset; PROCEDURE (this: InlineShape) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Delete; PROCEDURE (this: InlineShape) Select* (), NEW; BEGIN CtlC.CallMethod(this, 65535, NIL); END Select; PROCEDURE (this: InlineShape) ConvertToShape* (): Shape, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 104, ret); RETURN ThisShape(CtlC.VarAny(ret)) END ConvertToShape; PROCEDURE (this: InlineShape) HorizontalLineFormat* (): HorizontalLineFormat, NEW; BEGIN RETURN ThisHorizontalLineFormat(CtlC.GetAny(this, 119)) END HorizontalLineFormat; PROCEDURE (this: InlineShape) Script* (): CtlOffice.Script, NEW; BEGIN RETURN CtlOffice.ThisScript(CtlC.GetAny(this, 122)) END Script; PROCEDURE (this: InlineShape) OWSAnchor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 130) END OWSAnchor; PROCEDURE (this: InlineShape) TextEffect* (): TextEffectFormat, NEW; BEGIN RETURN ThisTextEffectFormat(CtlC.GetAny(this, 120)) END TextEffect; PROCEDURE (this: InlineShape) PUTTextEffect* (p1: TextEffectFormat), NEW; BEGIN CtlC.PutObj(this, 120, p1) END PUTTextEffect; PROCEDURE (this: InlineShape) AlternativeText* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 131) END AlternativeText; PROCEDURE (this: InlineShape) PUTAlternativeText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 131, p1) END PUTAlternativeText; (* ---------- InlineShapes, dual, nonextensible ---------- *) PROCEDURE (this: InlineShapes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: InlineShapes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: InlineShapes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: InlineShapes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: InlineShapes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: InlineShapes) Item* (Index: INTEGER): InlineShape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END Item; PROCEDURE (this: InlineShapes) AddPicture* (FileName: ARRAY OF CHAR; (* optional *) LinkToFile: CtlT.Any; SaveWithDocument: CtlT.Any; Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 4 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[3]); CtlC.AnyVar(LinkToFile, arg[2]); CtlC.AnyVar(SaveWithDocument, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 100, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddPicture; PROCEDURE (this: InlineShapes) AddOLEObject* ((* optional *) ClassType: CtlT.Any; FileName: CtlT.Any; LinkToFile: CtlT.Any; DisplayAsIcon: CtlT.Any; IconFileName: CtlT.Any; IconIndex: CtlT.Any; IconLabel: CtlT.Any; Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 8 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[7]); CtlC.AnyVar(FileName, arg[6]); CtlC.AnyVar(LinkToFile, arg[5]); CtlC.AnyVar(DisplayAsIcon, arg[4]); CtlC.AnyVar(IconFileName, arg[3]); CtlC.AnyVar(IconIndex, arg[2]); CtlC.AnyVar(IconLabel, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 24, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddOLEObject; PROCEDURE (this: InlineShapes) AddOLEControl* ((* optional *) ClassType: CtlT.Any; Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(ClassType, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 102, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddOLEControl; PROCEDURE (this: InlineShapes) New* (range: Range): InlineShape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.ObjVar(range, arg[0]); CtlC.CallParMethod(this, 200, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END New; PROCEDURE (this: InlineShapes) AddHorizontalLine* (FileName: ARRAY OF CHAR; (* optional *) Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 104, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddHorizontalLine; PROCEDURE (this: InlineShapes) AddHorizontalLineStandard* ((* optional *) Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 105, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddHorizontalLineStandard; PROCEDURE (this: InlineShapes) AddPictureBullet* (FileName: ARRAY OF CHAR; (* optional *) Range: CtlT.Any): InlineShape, NEW; VAR arg: ARRAY 2 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[1]); CtlC.AnyVar(Range, arg[0]); CtlC.CallParMethod(this, 106, arg, ret); RETURN ThisInlineShape(CtlC.VarAny(ret)) END AddPictureBullet; (* ---------- SpellingSuggestions, dual, nonextensible ---------- *) PROCEDURE (this: SpellingSuggestions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: SpellingSuggestions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: SpellingSuggestions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: SpellingSuggestions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: SpellingSuggestions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: SpellingSuggestions) SpellingErrorType* (): WdSpellingErrorType, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END SpellingErrorType; PROCEDURE (this: SpellingSuggestions) Item* (Index: INTEGER): SpellingSuggestion, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisSpellingSuggestion(CtlC.VarAny(ret)) END Item; (* ---------- SpellingSuggestion, dual, nonextensible ---------- *) PROCEDURE (this: SpellingSuggestion) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: SpellingSuggestion) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: SpellingSuggestion) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: SpellingSuggestion) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; (* ---------- Dictionaries, dual, nonextensible ---------- *) PROCEDURE (this: Dictionaries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Dictionaries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Dictionaries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Dictionaries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Dictionaries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: Dictionaries) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Maximum; PROCEDURE (this: Dictionaries) ActiveCustomDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 3)) END ActiveCustomDictionary; PROCEDURE (this: Dictionaries) PUTActiveCustomDictionary* (p1: Dictionary), NEW; BEGIN CtlC.PutObj(this, 3, p1) END PUTActiveCustomDictionary; PROCEDURE (this: Dictionaries) Item* (Index: CtlT.Any): Dictionary, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisDictionary(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Dictionaries) Add* (FileName: ARRAY OF CHAR): Dictionary, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisDictionary(CtlC.VarAny(ret)) END Add; PROCEDURE (this: Dictionaries) ClearAll* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END ClearAll; (* ---------- HangulHanjaConversionDictionaries, dual, nonextensible ---------- *) PROCEDURE (this: HangulHanjaConversionDictionaries) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HangulHanjaConversionDictionaries) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HangulHanjaConversionDictionaries) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HangulHanjaConversionDictionaries) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HangulHanjaConversionDictionaries) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: HangulHanjaConversionDictionaries) Maximum* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Maximum; PROCEDURE (this: HangulHanjaConversionDictionaries) ActiveCustomDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 3)) END ActiveCustomDictionary; PROCEDURE (this: HangulHanjaConversionDictionaries) PUTActiveCustomDictionary* (p1: Dictionary), NEW; BEGIN CtlC.PutObj(this, 3, p1) END PUTActiveCustomDictionary; PROCEDURE (this: HangulHanjaConversionDictionaries) BuiltinDictionary* (): Dictionary, NEW; BEGIN RETURN ThisDictionary(CtlC.GetAny(this, 4)) END BuiltinDictionary; PROCEDURE (this: HangulHanjaConversionDictionaries) Item* (Index: CtlT.Any): Dictionary, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisDictionary(CtlC.VarAny(ret)) END Item; PROCEDURE (this: HangulHanjaConversionDictionaries) Add* (FileName: ARRAY OF CHAR): Dictionary, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(FileName, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisDictionary(CtlC.VarAny(ret)) END Add; PROCEDURE (this: HangulHanjaConversionDictionaries) ClearAll* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END ClearAll; (* ---------- Dictionary, dual, nonextensible ---------- *) PROCEDURE (this: Dictionary) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Dictionary) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Dictionary) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Dictionary) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: Dictionary) Path* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1) END Path; PROCEDURE (this: Dictionary) LanguageID* (): WdLanguageID, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END LanguageID; PROCEDURE (this: Dictionary) PUTLanguageID* (p1: WdLanguageID), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTLanguageID; PROCEDURE (this: Dictionary) ReadOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END ReadOnly; PROCEDURE (this: Dictionary) Type* (): WdDictionaryType, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Type; PROCEDURE (this: Dictionary) LanguageSpecific* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END LanguageSpecific; PROCEDURE (this: Dictionary) PUTLanguageSpecific* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTLanguageSpecific; PROCEDURE (this: Dictionary) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- ReadabilityStatistics, dual, nonextensible ---------- *) PROCEDURE (this: ReadabilityStatistics) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ReadabilityStatistics) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ReadabilityStatistics) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ReadabilityStatistics) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ReadabilityStatistics) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: ReadabilityStatistics) Item* (Index: CtlT.Any): ReadabilityStatistic, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisReadabilityStatistic(CtlC.VarAny(ret)) END Item; (* ---------- ReadabilityStatistic, dual, nonextensible ---------- *) PROCEDURE (this: ReadabilityStatistic) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ReadabilityStatistic) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ReadabilityStatistic) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ReadabilityStatistic) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 0) END Name; PROCEDURE (this: ReadabilityStatistic) Value* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 1) END Value; (* ---------- Versions, dual, nonextensible ---------- *) PROCEDURE (this: Versions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Versions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Versions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Versions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Versions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Versions) AutoVersion* (): WdAutoVersions, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END AutoVersion; PROCEDURE (this: Versions) PUTAutoVersion* (p1: WdAutoVersions), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTAutoVersion; PROCEDURE (this: Versions) Item* (Index: INTEGER): Version, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisVersion(CtlC.VarAny(ret)) END Item; PROCEDURE (this: Versions) Save* ((* optional *) Comment: CtlT.Any), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.AnyVar(Comment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Save; (* ---------- Version, dual, nonextensible ---------- *) PROCEDURE (this: Version) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Version) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Version) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Version) SavedBy* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1003) END SavedBy; PROCEDURE (this: Version) Comment* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 1004) END Comment; PROCEDURE (this: Version) Date* (): CtlT.OleDate; BEGIN RETURN CtlC.GetDate(this, 1005) END Date; PROCEDURE (this: Version) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Index; PROCEDURE (this: Version) OpenOld* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END OpenOld; PROCEDURE (this: Version) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 102, NIL); END Delete; PROCEDURE (this: Version) Open* (): Document, NEW; VAR ret: CtlT.Variant; BEGIN CtlC.CallMethod(this, 103, ret); RETURN This_Document(CtlC.VarAny(ret)) END Open; (* ---------- Options, dual, nonextensible ---------- *) PROCEDURE (this: Options) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Options) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Options) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Options) AllowAccentedUppercase* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END AllowAccentedUppercase; PROCEDURE (this: Options) PUTAllowAccentedUppercase* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTAllowAccentedUppercase; PROCEDURE (this: Options) WPHelp* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 17) END WPHelp; PROCEDURE (this: Options) PUTWPHelp* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 17, p1) END PUTWPHelp; PROCEDURE (this: Options) WPDocNavKeys* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 18) END WPDocNavKeys; PROCEDURE (this: Options) PUTWPDocNavKeys* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 18, p1) END PUTWPDocNavKeys; PROCEDURE (this: Options) Pagination* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 19) END Pagination; PROCEDURE (this: Options) PUTPagination* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 19, p1) END PUTPagination; PROCEDURE (this: Options) BlueScreen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 20) END BlueScreen; PROCEDURE (this: Options) PUTBlueScreen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 20, p1) END PUTBlueScreen; PROCEDURE (this: Options) EnableSound* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 21) END EnableSound; PROCEDURE (this: Options) PUTEnableSound* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 21, p1) END PUTEnableSound; PROCEDURE (this: Options) ConfirmConversions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 22) END ConfirmConversions; PROCEDURE (this: Options) PUTConfirmConversions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 22, p1) END PUTConfirmConversions; PROCEDURE (this: Options) UpdateLinksAtOpen* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 23) END UpdateLinksAtOpen; PROCEDURE (this: Options) PUTUpdateLinksAtOpen* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 23, p1) END PUTUpdateLinksAtOpen; PROCEDURE (this: Options) SendMailAttach* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 24) END SendMailAttach; PROCEDURE (this: Options) PUTSendMailAttach* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 24, p1) END PUTSendMailAttach; PROCEDURE (this: Options) MeasurementUnit* (): WdMeasurementUnits, NEW; BEGIN RETURN CtlC.GetInt(this, 26) END MeasurementUnit; PROCEDURE (this: Options) PUTMeasurementUnit* (p1: WdMeasurementUnits), NEW; BEGIN CtlC.PutInt(this, 26, p1) END PUTMeasurementUnit; PROCEDURE (this: Options) ButtonFieldClicks* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 27) END ButtonFieldClicks; PROCEDURE (this: Options) PUTButtonFieldClicks* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 27, p1) END PUTButtonFieldClicks; PROCEDURE (this: Options) ShortMenuNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 28) END ShortMenuNames; PROCEDURE (this: Options) PUTShortMenuNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 28, p1) END PUTShortMenuNames; PROCEDURE (this: Options) RTFInClipboard* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 29) END RTFInClipboard; PROCEDURE (this: Options) PUTRTFInClipboard* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 29, p1) END PUTRTFInClipboard; PROCEDURE (this: Options) UpdateFieldsAtPrint* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 30) END UpdateFieldsAtPrint; PROCEDURE (this: Options) PUTUpdateFieldsAtPrint* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 30, p1) END PUTUpdateFieldsAtPrint; PROCEDURE (this: Options) PrintProperties* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 31) END PrintProperties; PROCEDURE (this: Options) PUTPrintProperties* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 31, p1) END PUTPrintProperties; PROCEDURE (this: Options) PrintFieldCodes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 32) END PrintFieldCodes; PROCEDURE (this: Options) PUTPrintFieldCodes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 32, p1) END PUTPrintFieldCodes; PROCEDURE (this: Options) PrintComments* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 33) END PrintComments; PROCEDURE (this: Options) PUTPrintComments* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 33, p1) END PUTPrintComments; PROCEDURE (this: Options) PrintHiddenText* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 34) END PrintHiddenText; PROCEDURE (this: Options) PUTPrintHiddenText* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 34, p1) END PUTPrintHiddenText; PROCEDURE (this: Options) EnvelopeFeederInstalled* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END EnvelopeFeederInstalled; PROCEDURE (this: Options) UpdateLinksAtPrint* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 36) END UpdateLinksAtPrint; PROCEDURE (this: Options) PUTUpdateLinksAtPrint* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 36, p1) END PUTUpdateLinksAtPrint; PROCEDURE (this: Options) PrintBackground* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 37) END PrintBackground; PROCEDURE (this: Options) PUTPrintBackground* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 37, p1) END PUTPrintBackground; PROCEDURE (this: Options) PrintDrawingObjects* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 38) END PrintDrawingObjects; PROCEDURE (this: Options) PUTPrintDrawingObjects* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 38, p1) END PUTPrintDrawingObjects; PROCEDURE (this: Options) DefaultTray* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 39) END DefaultTray; PROCEDURE (this: Options) PUTDefaultTray* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 39, p1) END PUTDefaultTray; PROCEDURE (this: Options) DefaultTrayID* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 40) END DefaultTrayID; PROCEDURE (this: Options) PUTDefaultTrayID* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 40, p1) END PUTDefaultTrayID; PROCEDURE (this: Options) CreateBackup* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 41) END CreateBackup; PROCEDURE (this: Options) PUTCreateBackup* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 41, p1) END PUTCreateBackup; PROCEDURE (this: Options) AllowFastSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 42) END AllowFastSave; PROCEDURE (this: Options) PUTAllowFastSave* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 42, p1) END PUTAllowFastSave; PROCEDURE (this: Options) SavePropertiesPrompt* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 43) END SavePropertiesPrompt; PROCEDURE (this: Options) PUTSavePropertiesPrompt* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 43, p1) END PUTSavePropertiesPrompt; PROCEDURE (this: Options) SaveNormalPrompt* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 44) END SaveNormalPrompt; PROCEDURE (this: Options) PUTSaveNormalPrompt* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 44, p1) END PUTSaveNormalPrompt; PROCEDURE (this: Options) SaveInterval* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 45) END SaveInterval; PROCEDURE (this: Options) PUTSaveInterval* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 45, p1) END PUTSaveInterval; PROCEDURE (this: Options) BackgroundSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 46) END BackgroundSave; PROCEDURE (this: Options) PUTBackgroundSave* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 46, p1) END PUTBackgroundSave; PROCEDURE (this: Options) InsertedTextMark* (): WdInsertedTextMark, NEW; BEGIN RETURN CtlC.GetInt(this, 57) END InsertedTextMark; PROCEDURE (this: Options) PUTInsertedTextMark* (p1: WdInsertedTextMark), NEW; BEGIN CtlC.PutInt(this, 57, p1) END PUTInsertedTextMark; PROCEDURE (this: Options) DeletedTextMark* (): WdDeletedTextMark, NEW; BEGIN RETURN CtlC.GetInt(this, 58) END DeletedTextMark; PROCEDURE (this: Options) PUTDeletedTextMark* (p1: WdDeletedTextMark), NEW; BEGIN CtlC.PutInt(this, 58, p1) END PUTDeletedTextMark; PROCEDURE (this: Options) RevisedLinesMark* (): WdRevisedLinesMark, NEW; BEGIN RETURN CtlC.GetInt(this, 59) END RevisedLinesMark; PROCEDURE (this: Options) PUTRevisedLinesMark* (p1: WdRevisedLinesMark), NEW; BEGIN CtlC.PutInt(this, 59, p1) END PUTRevisedLinesMark; PROCEDURE (this: Options) InsertedTextColor* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 60) END InsertedTextColor; PROCEDURE (this: Options) PUTInsertedTextColor* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 60, p1) END PUTInsertedTextColor; PROCEDURE (this: Options) DeletedTextColor* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 61) END DeletedTextColor; PROCEDURE (this: Options) PUTDeletedTextColor* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 61, p1) END PUTDeletedTextColor; PROCEDURE (this: Options) RevisedLinesColor* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 62) END RevisedLinesColor; PROCEDURE (this: Options) PUTRevisedLinesColor* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 62, p1) END PUTRevisedLinesColor; PROCEDURE (this: Options) DefaultFilePath* (Path: WdDefaultFilePath): CtlT.Strg, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Path, arg[0]); CtlC.CallGetMethod(this, 65, arg, ret); RETURN CtlC.VarStr(ret) END DefaultFilePath; PROCEDURE (this: Options) PUTDefaultFilePath* (Path: WdDefaultFilePath; p2: ARRAY OF CHAR), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Path, arg[1]); CtlC.StrVar(p2, arg[0]); CtlC.CallPutMethod(this, 65, arg, NIL); END PUTDefaultFilePath; PROCEDURE (this: Options) Overtype* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 66) END Overtype; PROCEDURE (this: Options) PUTOvertype* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 66, p1) END PUTOvertype; PROCEDURE (this: Options) ReplaceSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 67) END ReplaceSelection; PROCEDURE (this: Options) PUTReplaceSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 67, p1) END PUTReplaceSelection; PROCEDURE (this: Options) AllowDragAndDrop* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 68) END AllowDragAndDrop; PROCEDURE (this: Options) PUTAllowDragAndDrop* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 68, p1) END PUTAllowDragAndDrop; PROCEDURE (this: Options) AutoWordSelection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 69) END AutoWordSelection; PROCEDURE (this: Options) PUTAutoWordSelection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 69, p1) END PUTAutoWordSelection; PROCEDURE (this: Options) INSKeyForPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 70) END INSKeyForPaste; PROCEDURE (this: Options) PUTINSKeyForPaste* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 70, p1) END PUTINSKeyForPaste; PROCEDURE (this: Options) SmartCutPaste* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 71) END SmartCutPaste; PROCEDURE (this: Options) PUTSmartCutPaste* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 71, p1) END PUTSmartCutPaste; PROCEDURE (this: Options) TabIndentKey* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 72) END TabIndentKey; PROCEDURE (this: Options) PUTTabIndentKey* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 72, p1) END PUTTabIndentKey; PROCEDURE (this: Options) PictureEditor* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 73) END PictureEditor; PROCEDURE (this: Options) PUTPictureEditor* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 73, p1) END PUTPictureEditor; PROCEDURE (this: Options) AnimateScreenMovements* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 74) END AnimateScreenMovements; PROCEDURE (this: Options) PUTAnimateScreenMovements* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 74, p1) END PUTAnimateScreenMovements; PROCEDURE (this: Options) VirusProtection* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 75) END VirusProtection; PROCEDURE (this: Options) PUTVirusProtection* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 75, p1) END PUTVirusProtection; PROCEDURE (this: Options) RevisedPropertiesMark* (): WdRevisedPropertiesMark, NEW; BEGIN RETURN CtlC.GetInt(this, 76) END RevisedPropertiesMark; PROCEDURE (this: Options) PUTRevisedPropertiesMark* (p1: WdRevisedPropertiesMark), NEW; BEGIN CtlC.PutInt(this, 76, p1) END PUTRevisedPropertiesMark; PROCEDURE (this: Options) RevisedPropertiesColor* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 77) END RevisedPropertiesColor; PROCEDURE (this: Options) PUTRevisedPropertiesColor* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 77, p1) END PUTRevisedPropertiesColor; PROCEDURE (this: Options) SnapToGrid* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 79) END SnapToGrid; PROCEDURE (this: Options) PUTSnapToGrid* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 79, p1) END PUTSnapToGrid; PROCEDURE (this: Options) SnapToShapes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 80) END SnapToShapes; PROCEDURE (this: Options) PUTSnapToShapes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 80, p1) END PUTSnapToShapes; PROCEDURE (this: Options) GridDistanceHorizontal* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 81) END GridDistanceHorizontal; PROCEDURE (this: Options) PUTGridDistanceHorizontal* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 81, p1) END PUTGridDistanceHorizontal; PROCEDURE (this: Options) GridDistanceVertical* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 82) END GridDistanceVertical; PROCEDURE (this: Options) PUTGridDistanceVertical* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 82, p1) END PUTGridDistanceVertical; PROCEDURE (this: Options) GridOriginHorizontal* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 83) END GridOriginHorizontal; PROCEDURE (this: Options) PUTGridOriginHorizontal* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 83, p1) END PUTGridOriginHorizontal; PROCEDURE (this: Options) GridOriginVertical* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 84) END GridOriginVertical; PROCEDURE (this: Options) PUTGridOriginVertical* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 84, p1) END PUTGridOriginVertical; PROCEDURE (this: Options) InlineConversion* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 86) END InlineConversion; PROCEDURE (this: Options) PUTInlineConversion* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 86, p1) END PUTInlineConversion; PROCEDURE (this: Options) IMEAutomaticControl* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 87) END IMEAutomaticControl; PROCEDURE (this: Options) PUTIMEAutomaticControl* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 87, p1) END PUTIMEAutomaticControl; PROCEDURE (this: Options) AutoFormatApplyHeadings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 250) END AutoFormatApplyHeadings; PROCEDURE (this: Options) PUTAutoFormatApplyHeadings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 250, p1) END PUTAutoFormatApplyHeadings; PROCEDURE (this: Options) AutoFormatApplyLists* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 251) END AutoFormatApplyLists; PROCEDURE (this: Options) PUTAutoFormatApplyLists* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 251, p1) END PUTAutoFormatApplyLists; PROCEDURE (this: Options) AutoFormatApplyBulletedLists* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 252) END AutoFormatApplyBulletedLists; PROCEDURE (this: Options) PUTAutoFormatApplyBulletedLists* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 252, p1) END PUTAutoFormatApplyBulletedLists; PROCEDURE (this: Options) AutoFormatApplyOtherParas* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 253) END AutoFormatApplyOtherParas; PROCEDURE (this: Options) PUTAutoFormatApplyOtherParas* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 253, p1) END PUTAutoFormatApplyOtherParas; PROCEDURE (this: Options) AutoFormatReplaceQuotes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 254) END AutoFormatReplaceQuotes; PROCEDURE (this: Options) PUTAutoFormatReplaceQuotes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 254, p1) END PUTAutoFormatReplaceQuotes; PROCEDURE (this: Options) AutoFormatReplaceSymbols* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 255) END AutoFormatReplaceSymbols; PROCEDURE (this: Options) PUTAutoFormatReplaceSymbols* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 255, p1) END PUTAutoFormatReplaceSymbols; PROCEDURE (this: Options) AutoFormatReplaceOrdinals* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 256) END AutoFormatReplaceOrdinals; PROCEDURE (this: Options) PUTAutoFormatReplaceOrdinals* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 256, p1) END PUTAutoFormatReplaceOrdinals; PROCEDURE (this: Options) AutoFormatReplaceFractions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 257) END AutoFormatReplaceFractions; PROCEDURE (this: Options) PUTAutoFormatReplaceFractions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 257, p1) END PUTAutoFormatReplaceFractions; PROCEDURE (this: Options) AutoFormatReplacePlainTextEmphasis* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 258) END AutoFormatReplacePlainTextEmphasis; PROCEDURE (this: Options) PUTAutoFormatReplacePlainTextEmphasis* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 258, p1) END PUTAutoFormatReplacePlainTextEmphasis; PROCEDURE (this: Options) AutoFormatPreserveStyles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 259) END AutoFormatPreserveStyles; PROCEDURE (this: Options) PUTAutoFormatPreserveStyles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 259, p1) END PUTAutoFormatPreserveStyles; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyHeadings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 260) END AutoFormatAsYouTypeApplyHeadings; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyHeadings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 260, p1) END PUTAutoFormatAsYouTypeApplyHeadings; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyBorders* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 261) END AutoFormatAsYouTypeApplyBorders; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyBorders* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 261, p1) END PUTAutoFormatAsYouTypeApplyBorders; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyBulletedLists* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 262) END AutoFormatAsYouTypeApplyBulletedLists; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyBulletedLists* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 262, p1) END PUTAutoFormatAsYouTypeApplyBulletedLists; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyNumberedLists* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 263) END AutoFormatAsYouTypeApplyNumberedLists; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyNumberedLists* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 263, p1) END PUTAutoFormatAsYouTypeApplyNumberedLists; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceQuotes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 264) END AutoFormatAsYouTypeReplaceQuotes; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceQuotes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 264, p1) END PUTAutoFormatAsYouTypeReplaceQuotes; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceSymbols* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 265) END AutoFormatAsYouTypeReplaceSymbols; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceSymbols* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 265, p1) END PUTAutoFormatAsYouTypeReplaceSymbols; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceOrdinals* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 266) END AutoFormatAsYouTypeReplaceOrdinals; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceOrdinals* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 266, p1) END PUTAutoFormatAsYouTypeReplaceOrdinals; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceFractions* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 267) END AutoFormatAsYouTypeReplaceFractions; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceFractions* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 267, p1) END PUTAutoFormatAsYouTypeReplaceFractions; PROCEDURE (this: Options) AutoFormatAsYouTypeReplacePlainTextEmphasis* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 268) END AutoFormatAsYouTypeReplacePlainTextEmphasis; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplacePlainTextEmphasis* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 268, p1) END PUTAutoFormatAsYouTypeReplacePlainTextEmphasis; PROCEDURE (this: Options) AutoFormatAsYouTypeFormatListItemBeginning* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 269) END AutoFormatAsYouTypeFormatListItemBeginning; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeFormatListItemBeginning* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 269, p1) END PUTAutoFormatAsYouTypeFormatListItemBeginning; PROCEDURE (this: Options) AutoFormatAsYouTypeDefineStyles* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 270) END AutoFormatAsYouTypeDefineStyles; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeDefineStyles* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 270, p1) END PUTAutoFormatAsYouTypeDefineStyles; PROCEDURE (this: Options) AutoFormatPlainTextWordMail* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 271) END AutoFormatPlainTextWordMail; PROCEDURE (this: Options) PUTAutoFormatPlainTextWordMail* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 271, p1) END PUTAutoFormatPlainTextWordMail; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceHyperlinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 272) END AutoFormatAsYouTypeReplaceHyperlinks; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceHyperlinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 272, p1) END PUTAutoFormatAsYouTypeReplaceHyperlinks; PROCEDURE (this: Options) AutoFormatReplaceHyperlinks* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 273) END AutoFormatReplaceHyperlinks; PROCEDURE (this: Options) PUTAutoFormatReplaceHyperlinks* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 273, p1) END PUTAutoFormatReplaceHyperlinks; PROCEDURE (this: Options) DefaultHighlightColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 274) END DefaultHighlightColorIndex; PROCEDURE (this: Options) PUTDefaultHighlightColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 274, p1) END PUTDefaultHighlightColorIndex; PROCEDURE (this: Options) DefaultBorderLineStyle* (): WdLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 275) END DefaultBorderLineStyle; PROCEDURE (this: Options) PUTDefaultBorderLineStyle* (p1: WdLineStyle), NEW; BEGIN CtlC.PutInt(this, 275, p1) END PUTDefaultBorderLineStyle; PROCEDURE (this: Options) CheckSpellingAsYouType* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 276) END CheckSpellingAsYouType; PROCEDURE (this: Options) PUTCheckSpellingAsYouType* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 276, p1) END PUTCheckSpellingAsYouType; PROCEDURE (this: Options) CheckGrammarAsYouType* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 277) END CheckGrammarAsYouType; PROCEDURE (this: Options) PUTCheckGrammarAsYouType* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 277, p1) END PUTCheckGrammarAsYouType; PROCEDURE (this: Options) IgnoreInternetAndFileAddresses* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 278) END IgnoreInternetAndFileAddresses; PROCEDURE (this: Options) PUTIgnoreInternetAndFileAddresses* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 278, p1) END PUTIgnoreInternetAndFileAddresses; PROCEDURE (this: Options) ShowReadabilityStatistics* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 279) END ShowReadabilityStatistics; PROCEDURE (this: Options) PUTShowReadabilityStatistics* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 279, p1) END PUTShowReadabilityStatistics; PROCEDURE (this: Options) IgnoreUppercase* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 280) END IgnoreUppercase; PROCEDURE (this: Options) PUTIgnoreUppercase* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 280, p1) END PUTIgnoreUppercase; PROCEDURE (this: Options) IgnoreMixedDigits* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 281) END IgnoreMixedDigits; PROCEDURE (this: Options) PUTIgnoreMixedDigits* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 281, p1) END PUTIgnoreMixedDigits; PROCEDURE (this: Options) SuggestFromMainDictionaryOnly* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 282) END SuggestFromMainDictionaryOnly; PROCEDURE (this: Options) PUTSuggestFromMainDictionaryOnly* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 282, p1) END PUTSuggestFromMainDictionaryOnly; PROCEDURE (this: Options) SuggestSpellingCorrections* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 283) END SuggestSpellingCorrections; PROCEDURE (this: Options) PUTSuggestSpellingCorrections* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 283, p1) END PUTSuggestSpellingCorrections; PROCEDURE (this: Options) DefaultBorderLineWidth* (): WdLineWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 284) END DefaultBorderLineWidth; PROCEDURE (this: Options) PUTDefaultBorderLineWidth* (p1: WdLineWidth), NEW; BEGIN CtlC.PutInt(this, 284, p1) END PUTDefaultBorderLineWidth; PROCEDURE (this: Options) CheckGrammarWithSpelling* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 285) END CheckGrammarWithSpelling; PROCEDURE (this: Options) PUTCheckGrammarWithSpelling* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 285, p1) END PUTCheckGrammarWithSpelling; PROCEDURE (this: Options) DefaultOpenFormat* (): WdOpenFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 286) END DefaultOpenFormat; PROCEDURE (this: Options) PUTDefaultOpenFormat* (p1: WdOpenFormat), NEW; BEGIN CtlC.PutInt(this, 286, p1) END PUTDefaultOpenFormat; PROCEDURE (this: Options) PrintDraft* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 287) END PrintDraft; PROCEDURE (this: Options) PUTPrintDraft* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 287, p1) END PUTPrintDraft; PROCEDURE (this: Options) PrintReverse* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 288) END PrintReverse; PROCEDURE (this: Options) PUTPrintReverse* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 288, p1) END PUTPrintReverse; PROCEDURE (this: Options) MapPaperSize* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 289) END MapPaperSize; PROCEDURE (this: Options) PUTMapPaperSize* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 289, p1) END PUTMapPaperSize; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyTables* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 290) END AutoFormatAsYouTypeApplyTables; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyTables* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 290, p1) END PUTAutoFormatAsYouTypeApplyTables; PROCEDURE (this: Options) AutoFormatApplyFirstIndents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 291) END AutoFormatApplyFirstIndents; PROCEDURE (this: Options) PUTAutoFormatApplyFirstIndents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 291, p1) END PUTAutoFormatApplyFirstIndents; PROCEDURE (this: Options) AutoFormatMatchParentheses* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 294) END AutoFormatMatchParentheses; PROCEDURE (this: Options) PUTAutoFormatMatchParentheses* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 294, p1) END PUTAutoFormatMatchParentheses; PROCEDURE (this: Options) AutoFormatReplaceFarEastDashes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 295) END AutoFormatReplaceFarEastDashes; PROCEDURE (this: Options) PUTAutoFormatReplaceFarEastDashes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 295, p1) END PUTAutoFormatReplaceFarEastDashes; PROCEDURE (this: Options) AutoFormatDeleteAutoSpaces* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 296) END AutoFormatDeleteAutoSpaces; PROCEDURE (this: Options) PUTAutoFormatDeleteAutoSpaces* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 296, p1) END PUTAutoFormatDeleteAutoSpaces; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyFirstIndents* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 297) END AutoFormatAsYouTypeApplyFirstIndents; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyFirstIndents* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 297, p1) END PUTAutoFormatAsYouTypeApplyFirstIndents; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyDates* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 298) END AutoFormatAsYouTypeApplyDates; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyDates* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 298, p1) END PUTAutoFormatAsYouTypeApplyDates; PROCEDURE (this: Options) AutoFormatAsYouTypeApplyClosings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 299) END AutoFormatAsYouTypeApplyClosings; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeApplyClosings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 299, p1) END PUTAutoFormatAsYouTypeApplyClosings; PROCEDURE (this: Options) AutoFormatAsYouTypeMatchParentheses* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 300) END AutoFormatAsYouTypeMatchParentheses; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeMatchParentheses* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 300, p1) END PUTAutoFormatAsYouTypeMatchParentheses; PROCEDURE (this: Options) AutoFormatAsYouTypeReplaceFarEastDashes* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 301) END AutoFormatAsYouTypeReplaceFarEastDashes; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeReplaceFarEastDashes* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 301, p1) END PUTAutoFormatAsYouTypeReplaceFarEastDashes; PROCEDURE (this: Options) AutoFormatAsYouTypeDeleteAutoSpaces* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 302) END AutoFormatAsYouTypeDeleteAutoSpaces; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeDeleteAutoSpaces* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 302, p1) END PUTAutoFormatAsYouTypeDeleteAutoSpaces; PROCEDURE (this: Options) AutoFormatAsYouTypeInsertClosings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 303) END AutoFormatAsYouTypeInsertClosings; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeInsertClosings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 303, p1) END PUTAutoFormatAsYouTypeInsertClosings; PROCEDURE (this: Options) AutoFormatAsYouTypeAutoLetterWizard* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 304) END AutoFormatAsYouTypeAutoLetterWizard; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeAutoLetterWizard* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 304, p1) END PUTAutoFormatAsYouTypeAutoLetterWizard; PROCEDURE (this: Options) AutoFormatAsYouTypeInsertOvers* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 305) END AutoFormatAsYouTypeInsertOvers; PROCEDURE (this: Options) PUTAutoFormatAsYouTypeInsertOvers* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 305, p1) END PUTAutoFormatAsYouTypeInsertOvers; PROCEDURE (this: Options) DisplayGridLines* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 306) END DisplayGridLines; PROCEDURE (this: Options) PUTDisplayGridLines* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 306, p1) END PUTDisplayGridLines; PROCEDURE (this: Options) MatchFuzzyCase* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 309) END MatchFuzzyCase; PROCEDURE (this: Options) PUTMatchFuzzyCase* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 309, p1) END PUTMatchFuzzyCase; PROCEDURE (this: Options) MatchFuzzyByte* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 310) END MatchFuzzyByte; PROCEDURE (this: Options) PUTMatchFuzzyByte* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 310, p1) END PUTMatchFuzzyByte; PROCEDURE (this: Options) MatchFuzzyHiragana* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 311) END MatchFuzzyHiragana; PROCEDURE (this: Options) PUTMatchFuzzyHiragana* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 311, p1) END PUTMatchFuzzyHiragana; PROCEDURE (this: Options) MatchFuzzySmallKana* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 312) END MatchFuzzySmallKana; PROCEDURE (this: Options) PUTMatchFuzzySmallKana* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 312, p1) END PUTMatchFuzzySmallKana; PROCEDURE (this: Options) MatchFuzzyDash* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 313) END MatchFuzzyDash; PROCEDURE (this: Options) PUTMatchFuzzyDash* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 313, p1) END PUTMatchFuzzyDash; PROCEDURE (this: Options) MatchFuzzyIterationMark* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 314) END MatchFuzzyIterationMark; PROCEDURE (this: Options) PUTMatchFuzzyIterationMark* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 314, p1) END PUTMatchFuzzyIterationMark; PROCEDURE (this: Options) MatchFuzzyKanji* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 315) END MatchFuzzyKanji; PROCEDURE (this: Options) PUTMatchFuzzyKanji* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 315, p1) END PUTMatchFuzzyKanji; PROCEDURE (this: Options) MatchFuzzyOldKana* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 316) END MatchFuzzyOldKana; PROCEDURE (this: Options) PUTMatchFuzzyOldKana* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 316, p1) END PUTMatchFuzzyOldKana; PROCEDURE (this: Options) MatchFuzzyProlongedSoundMark* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 317) END MatchFuzzyProlongedSoundMark; PROCEDURE (this: Options) PUTMatchFuzzyProlongedSoundMark* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 317, p1) END PUTMatchFuzzyProlongedSoundMark; PROCEDURE (this: Options) MatchFuzzyDZ* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 318) END MatchFuzzyDZ; PROCEDURE (this: Options) PUTMatchFuzzyDZ* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 318, p1) END PUTMatchFuzzyDZ; PROCEDURE (this: Options) MatchFuzzyBV* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 319) END MatchFuzzyBV; PROCEDURE (this: Options) PUTMatchFuzzyBV* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 319, p1) END PUTMatchFuzzyBV; PROCEDURE (this: Options) MatchFuzzyTC* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 320) END MatchFuzzyTC; PROCEDURE (this: Options) PUTMatchFuzzyTC* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 320, p1) END PUTMatchFuzzyTC; PROCEDURE (this: Options) MatchFuzzyHF* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 321) END MatchFuzzyHF; PROCEDURE (this: Options) PUTMatchFuzzyHF* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 321, p1) END PUTMatchFuzzyHF; PROCEDURE (this: Options) MatchFuzzyZJ* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 322) END MatchFuzzyZJ; PROCEDURE (this: Options) PUTMatchFuzzyZJ* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 322, p1) END PUTMatchFuzzyZJ; PROCEDURE (this: Options) MatchFuzzyAY* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 323) END MatchFuzzyAY; PROCEDURE (this: Options) PUTMatchFuzzyAY* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 323, p1) END PUTMatchFuzzyAY; PROCEDURE (this: Options) MatchFuzzyKiKu* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 324) END MatchFuzzyKiKu; PROCEDURE (this: Options) PUTMatchFuzzyKiKu* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 324, p1) END PUTMatchFuzzyKiKu; PROCEDURE (this: Options) MatchFuzzyPunctuation* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 325) END MatchFuzzyPunctuation; PROCEDURE (this: Options) PUTMatchFuzzyPunctuation* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 325, p1) END PUTMatchFuzzyPunctuation; PROCEDURE (this: Options) MatchFuzzySpace* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 326) END MatchFuzzySpace; PROCEDURE (this: Options) PUTMatchFuzzySpace* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 326, p1) END PUTMatchFuzzySpace; PROCEDURE (this: Options) ApplyFarEastFontsToAscii* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 327) END ApplyFarEastFontsToAscii; PROCEDURE (this: Options) PUTApplyFarEastFontsToAscii* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 327, p1) END PUTApplyFarEastFontsToAscii; PROCEDURE (this: Options) ConvertHighAnsiToFarEast* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 328) END ConvertHighAnsiToFarEast; PROCEDURE (this: Options) PUTConvertHighAnsiToFarEast* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 328, p1) END PUTConvertHighAnsiToFarEast; PROCEDURE (this: Options) PrintOddPagesInAscendingOrder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 330) END PrintOddPagesInAscendingOrder; PROCEDURE (this: Options) PUTPrintOddPagesInAscendingOrder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 330, p1) END PUTPrintOddPagesInAscendingOrder; PROCEDURE (this: Options) PrintEvenPagesInAscendingOrder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 331) END PrintEvenPagesInAscendingOrder; PROCEDURE (this: Options) PUTPrintEvenPagesInAscendingOrder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 331, p1) END PUTPrintEvenPagesInAscendingOrder; PROCEDURE (this: Options) DefaultBorderColorIndex* (): WdColorIndex, NEW; BEGIN RETURN CtlC.GetInt(this, 337) END DefaultBorderColorIndex; PROCEDURE (this: Options) PUTDefaultBorderColorIndex* (p1: WdColorIndex), NEW; BEGIN CtlC.PutInt(this, 337, p1) END PUTDefaultBorderColorIndex; PROCEDURE (this: Options) EnableMisusedWordsDictionary* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 338) END EnableMisusedWordsDictionary; PROCEDURE (this: Options) PUTEnableMisusedWordsDictionary* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 338, p1) END PUTEnableMisusedWordsDictionary; PROCEDURE (this: Options) AllowCombinedAuxiliaryForms* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 339) END AllowCombinedAuxiliaryForms; PROCEDURE (this: Options) PUTAllowCombinedAuxiliaryForms* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 339, p1) END PUTAllowCombinedAuxiliaryForms; PROCEDURE (this: Options) HangulHanjaFastConversion* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 340) END HangulHanjaFastConversion; PROCEDURE (this: Options) PUTHangulHanjaFastConversion* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 340, p1) END PUTHangulHanjaFastConversion; PROCEDURE (this: Options) CheckHangulEndings* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 341) END CheckHangulEndings; PROCEDURE (this: Options) PUTCheckHangulEndings* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 341, p1) END PUTCheckHangulEndings; PROCEDURE (this: Options) EnableHangulHanjaRecentOrdering* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 342) END EnableHangulHanjaRecentOrdering; PROCEDURE (this: Options) PUTEnableHangulHanjaRecentOrdering* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 342, p1) END PUTEnableHangulHanjaRecentOrdering; PROCEDURE (this: Options) MultipleWordConversionsMode* (): WdMultipleWordConversionsMode, NEW; BEGIN RETURN CtlC.GetInt(this, 343) END MultipleWordConversionsMode; PROCEDURE (this: Options) PUTMultipleWordConversionsMode* (p1: WdMultipleWordConversionsMode), NEW; BEGIN CtlC.PutInt(this, 343, p1) END PUTMultipleWordConversionsMode; PROCEDURE (this: Options) SetWPHelpOptions* ((* optional *) CommandKeyHelp: CtlT.Any; DocNavigationKeys: CtlT.Any; MouseSimulation: CtlT.Any; DemoGuidance: CtlT.Any; DemoSpeed: CtlT.Any; HelpType: CtlT.Any), NEW; VAR arg: ARRAY 6 OF CtlT.Variant; BEGIN CtlC.AnyVar(CommandKeyHelp, arg[5]); CtlC.AnyVar(DocNavigationKeys, arg[4]); CtlC.AnyVar(MouseSimulation, arg[3]); CtlC.AnyVar(DemoGuidance, arg[2]); CtlC.AnyVar(DemoSpeed, arg[1]); CtlC.AnyVar(HelpType, arg[0]); CtlC.CallParMethod(this, 333, arg, NIL); END SetWPHelpOptions; PROCEDURE (this: Options) DefaultBorderColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 344) END DefaultBorderColor; PROCEDURE (this: Options) PUTDefaultBorderColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 344, p1) END PUTDefaultBorderColor; PROCEDURE (this: Options) AllowPixelUnits* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 345) END AllowPixelUnits; PROCEDURE (this: Options) PUTAllowPixelUnits* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 345, p1) END PUTAllowPixelUnits; PROCEDURE (this: Options) UseCharacterUnit* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 346) END UseCharacterUnit; PROCEDURE (this: Options) PUTUseCharacterUnit* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 346, p1) END PUTUseCharacterUnit; PROCEDURE (this: Options) AllowCompoundNounProcessing* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 347) END AllowCompoundNounProcessing; PROCEDURE (this: Options) PUTAllowCompoundNounProcessing* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 347, p1) END PUTAllowCompoundNounProcessing; PROCEDURE (this: Options) AutoKeyboardSwitching* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 399) END AutoKeyboardSwitching; PROCEDURE (this: Options) PUTAutoKeyboardSwitching* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 399, p1) END PUTAutoKeyboardSwitching; PROCEDURE (this: Options) DocumentViewDirection* (): WdDocumentViewDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 400) END DocumentViewDirection; PROCEDURE (this: Options) PUTDocumentViewDirection* (p1: WdDocumentViewDirection), NEW; BEGIN CtlC.PutInt(this, 400, p1) END PUTDocumentViewDirection; PROCEDURE (this: Options) ArabicNumeral* (): WdArabicNumeral, NEW; BEGIN RETURN CtlC.GetInt(this, 401) END ArabicNumeral; PROCEDURE (this: Options) PUTArabicNumeral* (p1: WdArabicNumeral), NEW; BEGIN CtlC.PutInt(this, 401, p1) END PUTArabicNumeral; PROCEDURE (this: Options) MonthNames* (): WdMonthNames, NEW; BEGIN RETURN CtlC.GetInt(this, 402) END MonthNames; PROCEDURE (this: Options) PUTMonthNames* (p1: WdMonthNames), NEW; BEGIN CtlC.PutInt(this, 402, p1) END PUTMonthNames; PROCEDURE (this: Options) CursorMovement* (): WdCursorMovement, NEW; BEGIN RETURN CtlC.GetInt(this, 403) END CursorMovement; PROCEDURE (this: Options) PUTCursorMovement* (p1: WdCursorMovement), NEW; BEGIN CtlC.PutInt(this, 403, p1) END PUTCursorMovement; PROCEDURE (this: Options) VisualSelection* (): WdVisualSelection, NEW; BEGIN RETURN CtlC.GetInt(this, 404) END VisualSelection; PROCEDURE (this: Options) PUTVisualSelection* (p1: WdVisualSelection), NEW; BEGIN CtlC.PutInt(this, 404, p1) END PUTVisualSelection; PROCEDURE (this: Options) ShowDiacritics* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 405) END ShowDiacritics; PROCEDURE (this: Options) PUTShowDiacritics* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 405, p1) END PUTShowDiacritics; PROCEDURE (this: Options) ShowControlCharacters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 406) END ShowControlCharacters; PROCEDURE (this: Options) PUTShowControlCharacters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 406, p1) END PUTShowControlCharacters; PROCEDURE (this: Options) AddControlCharacters* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 407) END AddControlCharacters; PROCEDURE (this: Options) PUTAddControlCharacters* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 407, p1) END PUTAddControlCharacters; PROCEDURE (this: Options) AddBiDirectionalMarksWhenSavingTextFile* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 408) END AddBiDirectionalMarksWhenSavingTextFile; PROCEDURE (this: Options) PUTAddBiDirectionalMarksWhenSavingTextFile* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 408, p1) END PUTAddBiDirectionalMarksWhenSavingTextFile; PROCEDURE (this: Options) StrictInitialAlefHamza* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 409) END StrictInitialAlefHamza; PROCEDURE (this: Options) PUTStrictInitialAlefHamza* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 409, p1) END PUTStrictInitialAlefHamza; PROCEDURE (this: Options) StrictFinalYaa* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 410) END StrictFinalYaa; PROCEDURE (this: Options) PUTStrictFinalYaa* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 410, p1) END PUTStrictFinalYaa; PROCEDURE (this: Options) HebrewMode* (): WdHebSpellStart, NEW; BEGIN RETURN CtlC.GetInt(this, 411) END HebrewMode; PROCEDURE (this: Options) PUTHebrewMode* (p1: WdHebSpellStart), NEW; BEGIN CtlC.PutInt(this, 411, p1) END PUTHebrewMode; PROCEDURE (this: Options) ArabicMode* (): WdAraSpeller, NEW; BEGIN RETURN CtlC.GetInt(this, 412) END ArabicMode; PROCEDURE (this: Options) PUTArabicMode* (p1: WdAraSpeller), NEW; BEGIN CtlC.PutInt(this, 412, p1) END PUTArabicMode; PROCEDURE (this: Options) AllowClickAndTypeMouse* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 413) END AllowClickAndTypeMouse; PROCEDURE (this: Options) PUTAllowClickAndTypeMouse* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 413, p1) END PUTAllowClickAndTypeMouse; PROCEDURE (this: Options) UseGermanSpellingReform* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 415) END UseGermanSpellingReform; PROCEDURE (this: Options) PUTUseGermanSpellingReform* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 415, p1) END PUTUseGermanSpellingReform; PROCEDURE (this: Options) InterpretHighAnsi* (): WdHighAnsiText, NEW; BEGIN RETURN CtlC.GetInt(this, 418) END InterpretHighAnsi; PROCEDURE (this: Options) PUTInterpretHighAnsi* (p1: WdHighAnsiText), NEW; BEGIN CtlC.PutInt(this, 418, p1) END PUTInterpretHighAnsi; PROCEDURE (this: Options) AddHebDoubleQuote* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 419) END AddHebDoubleQuote; PROCEDURE (this: Options) PUTAddHebDoubleQuote* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 419, p1) END PUTAddHebDoubleQuote; PROCEDURE (this: Options) UseDiffDiacColor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 420) END UseDiffDiacColor; PROCEDURE (this: Options) PUTUseDiffDiacColor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 420, p1) END PUTUseDiffDiacColor; PROCEDURE (this: Options) DiacriticColorVal* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 421) END DiacriticColorVal; PROCEDURE (this: Options) PUTDiacriticColorVal* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 421, p1) END PUTDiacriticColorVal; PROCEDURE (this: Options) OptimizeForWord97byDefault* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 423) END OptimizeForWord97byDefault; PROCEDURE (this: Options) PUTOptimizeForWord97byDefault* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 423, p1) END PUTOptimizeForWord97byDefault; (* ---------- MailMessage, dual, nonextensible ---------- *) PROCEDURE (this: MailMessage) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: MailMessage) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: MailMessage) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: MailMessage) CheckName* (), NEW; BEGIN CtlC.CallMethod(this, 334, NIL); END CheckName; PROCEDURE (this: MailMessage) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 335, NIL); END Delete; PROCEDURE (this: MailMessage) DisplayMoveDialog* (), NEW; BEGIN CtlC.CallMethod(this, 336, NIL); END DisplayMoveDialog; PROCEDURE (this: MailMessage) DisplayProperties* (), NEW; BEGIN CtlC.CallMethod(this, 337, NIL); END DisplayProperties; PROCEDURE (this: MailMessage) DisplaySelectNamesDialog* (), NEW; BEGIN CtlC.CallMethod(this, 338, NIL); END DisplaySelectNamesDialog; PROCEDURE (this: MailMessage) Forward* (), NEW; BEGIN CtlC.CallMethod(this, 339, NIL); END Forward; PROCEDURE (this: MailMessage) GoToNext* (), NEW; BEGIN CtlC.CallMethod(this, 340, NIL); END GoToNext; PROCEDURE (this: MailMessage) GoToPrevious* (), NEW; BEGIN CtlC.CallMethod(this, 341, NIL); END GoToPrevious; PROCEDURE (this: MailMessage) Reply* (), NEW; BEGIN CtlC.CallMethod(this, 342, NIL); END Reply; PROCEDURE (this: MailMessage) ReplyAll* (), NEW; BEGIN CtlC.CallMethod(this, 343, NIL); END ReplyAll; PROCEDURE (this: MailMessage) ToggleHeader* (), NEW; BEGIN CtlC.CallMethod(this, 344, NIL); END ToggleHeader; (* ---------- ProofreadingErrors, dual, nonextensible ---------- *) PROCEDURE (this: ProofreadingErrors) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ProofreadingErrors) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ProofreadingErrors) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: ProofreadingErrors) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ProofreadingErrors) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: ProofreadingErrors) Type* (): WdProofreadingErrorType, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Type; PROCEDURE (this: ProofreadingErrors) Item* (Index: INTEGER): Range, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisRange(CtlC.VarAny(ret)) END Item; (* ---------- Mailer, dual, nonextensible ---------- *) PROCEDURE (this: Mailer) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Mailer) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Mailer) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Mailer) BCCRecipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 100) END BCCRecipients; PROCEDURE (this: Mailer) PUTBCCRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 100, p1) END PUTBCCRecipients; PROCEDURE (this: Mailer) CCRecipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END CCRecipients; PROCEDURE (this: Mailer) PUTCCRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 101, p1) END PUTCCRecipients; PROCEDURE (this: Mailer) Recipients* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 102) END Recipients; PROCEDURE (this: Mailer) PUTRecipients* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 102, p1) END PUTRecipients; PROCEDURE (this: Mailer) Enclosures* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 103) END Enclosures; PROCEDURE (this: Mailer) PUTEnclosures* (p1: CtlT.Any), NEW; BEGIN CtlC.PutAny(this, 103, p1) END PUTEnclosures; PROCEDURE (this: Mailer) Sender* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END Sender; PROCEDURE (this: Mailer) SendDateTime* (): CtlT.OleDate, NEW; BEGIN RETURN CtlC.GetDate(this, 105) END SendDateTime; PROCEDURE (this: Mailer) Received* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 106) END Received; PROCEDURE (this: Mailer) Subject* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 107) END Subject; PROCEDURE (this: Mailer) PUTSubject* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 107, p1) END PUTSubject; (* ---------- WrapFormat, dual, nonextensible ---------- *) PROCEDURE (this: WrapFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: WrapFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: WrapFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: WrapFormat) Type* (): WdWrapType, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Type; PROCEDURE (this: WrapFormat) PUTType* (p1: WdWrapType), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTType; PROCEDURE (this: WrapFormat) Side* (): WdWrapSideType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Side; PROCEDURE (this: WrapFormat) PUTSide* (p1: WdWrapSideType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTSide; PROCEDURE (this: WrapFormat) DistanceTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END DistanceTop; PROCEDURE (this: WrapFormat) PUTDistanceTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTDistanceTop; PROCEDURE (this: WrapFormat) DistanceBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END DistanceBottom; PROCEDURE (this: WrapFormat) PUTDistanceBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTDistanceBottom; PROCEDURE (this: WrapFormat) DistanceLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END DistanceLeft; PROCEDURE (this: WrapFormat) PUTDistanceLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTDistanceLeft; PROCEDURE (this: WrapFormat) DistanceRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END DistanceRight; PROCEDURE (this: WrapFormat) PUTDistanceRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTDistanceRight; PROCEDURE (this: WrapFormat) AllowOverlap* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END AllowOverlap; PROCEDURE (this: WrapFormat) PUTAllowOverlap* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTAllowOverlap; (* ---------- HangulAndAlphabetExceptions, dual, nonextensible ---------- *) PROCEDURE (this: HangulAndAlphabetExceptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HangulAndAlphabetExceptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HangulAndAlphabetExceptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HangulAndAlphabetExceptions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: HangulAndAlphabetExceptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: HangulAndAlphabetExceptions) Item* (Index: CtlT.Any): HangulAndAlphabetException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisHangulAndAlphabetException(CtlC.VarAny(ret)) END Item; PROCEDURE (this: HangulAndAlphabetExceptions) Add* (Name: ARRAY OF CHAR): HangulAndAlphabetException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisHangulAndAlphabetException(CtlC.VarAny(ret)) END Add; (* ---------- HangulAndAlphabetException, dual, nonextensible ---------- *) PROCEDURE (this: HangulAndAlphabetException) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HangulAndAlphabetException) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HangulAndAlphabetException) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HangulAndAlphabetException) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: HangulAndAlphabetException) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: HangulAndAlphabetException) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; (* ---------- Adjustments, dual, nonextensible ---------- *) PROCEDURE (this: Adjustments) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Adjustments) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Adjustments) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: Adjustments) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: Adjustments) Item* (Index: INTEGER): SHORTREAL, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 0, arg, ret); RETURN CtlC.VarSReal(ret) END Item; PROCEDURE (this: Adjustments) PUTItem* (Index: INTEGER; p2: SHORTREAL), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.SRealVar(p2, arg[0]); CtlC.CallPutMethod(this, 0, arg, NIL); END PUTItem; (* ---------- CalloutFormat, dual, nonextensible ---------- *) PROCEDURE (this: CalloutFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: CalloutFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: CalloutFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: CalloutFormat) Accent* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Accent; PROCEDURE (this: CalloutFormat) PUTAccent* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAccent; PROCEDURE (this: CalloutFormat) Angle* (): CtlOffice.MsoCalloutAngleType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Angle; PROCEDURE (this: CalloutFormat) PUTAngle* (p1: CtlOffice.MsoCalloutAngleType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTAngle; PROCEDURE (this: CalloutFormat) AutoAttach* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END AutoAttach; PROCEDURE (this: CalloutFormat) PUTAutoAttach* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTAutoAttach; PROCEDURE (this: CalloutFormat) AutoLength* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END AutoLength; PROCEDURE (this: CalloutFormat) Border* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END Border; PROCEDURE (this: CalloutFormat) PUTBorder* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTBorder; PROCEDURE (this: CalloutFormat) Drop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END Drop; PROCEDURE (this: CalloutFormat) DropType* (): CtlOffice.MsoCalloutDropType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END DropType; PROCEDURE (this: CalloutFormat) Gap* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 107) END Gap; PROCEDURE (this: CalloutFormat) PUTGap* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 107, p1) END PUTGap; PROCEDURE (this: CalloutFormat) Length* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 108) END Length; PROCEDURE (this: CalloutFormat) Type* (): CtlOffice.MsoCalloutType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Type; PROCEDURE (this: CalloutFormat) PUTType* (p1: CtlOffice.MsoCalloutType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTType; PROCEDURE (this: CalloutFormat) AutomaticLength* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END AutomaticLength; PROCEDURE (this: CalloutFormat) CustomDrop* (Drop: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Drop, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END CustomDrop; PROCEDURE (this: CalloutFormat) CustomLength* (Length: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Length, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END CustomLength; PROCEDURE (this: CalloutFormat) PresetDrop* (DropType: CtlOffice.MsoCalloutDropType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(DropType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetDrop; (* ---------- ColorFormat, dual, nonextensible ---------- *) PROCEDURE (this: ColorFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ColorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ColorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ColorFormat) RGB* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END RGB; PROCEDURE (this: ColorFormat) PUTRGB* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 0, p1) END PUTRGB; PROCEDURE (this: ColorFormat) SchemeColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END SchemeColor; PROCEDURE (this: ColorFormat) PUTSchemeColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTSchemeColor; PROCEDURE (this: ColorFormat) Type* (): CtlOffice.MsoColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Type; (* ---------- ConnectorFormat, hidden, dual, nonextensible ---------- *) PROCEDURE (this: ConnectorFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ConnectorFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ConnectorFormat) BeginConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END BeginConnected; PROCEDURE (this: ConnectorFormat) BeginConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 101)) END BeginConnectedShape; PROCEDURE (this: ConnectorFormat) BeginConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginConnectionSite; PROCEDURE (this: ConnectorFormat) EndConnected* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END EndConnected; PROCEDURE (this: ConnectorFormat) EndConnectedShape* (): Shape, NEW; BEGIN RETURN ThisShape(CtlC.GetAny(this, 104)) END EndConnectedShape; PROCEDURE (this: ConnectorFormat) EndConnectionSite* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndConnectionSite; PROCEDURE (this: ConnectorFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ConnectorFormat) Type* (): CtlOffice.MsoConnectorType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Type; PROCEDURE (this: ConnectorFormat) PUTType* (p1: CtlOffice.MsoConnectorType), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTType; PROCEDURE (this: ConnectorFormat) BeginConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END BeginConnect; PROCEDURE (this: ConnectorFormat) BeginDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 11, NIL); END BeginDisconnect; PROCEDURE (this: ConnectorFormat) EndConnect* (ConnectedShape: Shape; ConnectionSite: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(ConnectedShape, arg[1]); CtlC.IntVar(ConnectionSite, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END EndConnect; PROCEDURE (this: ConnectorFormat) EndDisconnect* (), NEW; BEGIN CtlC.CallMethod(this, 13, NIL); END EndDisconnect; (* ---------- FillFormat, dual, nonextensible ---------- *) PROCEDURE (this: FillFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FillFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FillFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FillFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: FillFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ForeColor; PROCEDURE (this: FillFormat) GradientColorType* (): CtlOffice.MsoGradientColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END GradientColorType; PROCEDURE (this: FillFormat) GradientDegree* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END GradientDegree; PROCEDURE (this: FillFormat) GradientStyle* (): CtlOffice.MsoGradientStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END GradientStyle; PROCEDURE (this: FillFormat) GradientVariant* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END GradientVariant; PROCEDURE (this: FillFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Pattern; PROCEDURE (this: FillFormat) PresetGradientType* (): CtlOffice.MsoPresetGradientType, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetGradientType; PROCEDURE (this: FillFormat) PresetTexture* (): CtlOffice.MsoPresetTexture, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTexture; PROCEDURE (this: FillFormat) TextureName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 109) END TextureName; PROCEDURE (this: FillFormat) TextureType* (): CtlOffice.MsoTextureType, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END TextureType; PROCEDURE (this: FillFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: FillFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: FillFormat) Type* (): CtlOffice.MsoFillType, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Type; PROCEDURE (this: FillFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 113) END Visible; PROCEDURE (this: FillFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 113, p1) END PUTVisible; PROCEDURE (this: FillFormat) Background* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END Background; PROCEDURE (this: FillFormat) OneColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; Degree: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.SRealVar(Degree, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END OneColorGradient; PROCEDURE (this: FillFormat) Patterned* (Pattern: CtlOffice.MsoPatternType), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Pattern, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Patterned; PROCEDURE (this: FillFormat) PresetGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER; PresetGradientType: CtlOffice.MsoPresetGradientType), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[2]); CtlC.IntVar(Variant, arg[1]); CtlC.IntVar(PresetGradientType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END PresetGradient; PROCEDURE (this: FillFormat) PresetTextured* (PresetTexture: CtlOffice.MsoPresetTexture), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetTexture, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END PresetTextured; PROCEDURE (this: FillFormat) Solid* (), NEW; BEGIN CtlC.CallMethod(this, 15, NIL); END Solid; PROCEDURE (this: FillFormat) TwoColorGradient* (Style: CtlOffice.MsoGradientStyle; Variant: INTEGER), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Style, arg[1]); CtlC.IntVar(Variant, arg[0]); CtlC.CallParMethod(this, 16, arg, NIL); END TwoColorGradient; PROCEDURE (this: FillFormat) UserPicture* (PictureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(PictureFile, arg[0]); CtlC.CallParMethod(this, 17, arg, NIL); END UserPicture; PROCEDURE (this: FillFormat) UserTextured* (TextureFile: ARRAY OF CHAR), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.StrVar(TextureFile, arg[0]); CtlC.CallParMethod(this, 18, arg, NIL); END UserTextured; (* ---------- FreeformBuilder, dual, nonextensible ---------- *) PROCEDURE (this: FreeformBuilder) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: FreeformBuilder) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: FreeformBuilder) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: FreeformBuilder) AddNodes* (SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 8 OF CtlT.Variant; BEGIN CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END AddNodes; PROCEDURE (this: FreeformBuilder) ConvertToShape* ((* optional *) Anchor: CtlT.Any): Shape, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Anchor, arg[0]); CtlC.CallParMethod(this, 11, arg, ret); RETURN ThisShape(CtlC.VarAny(ret)) END ConvertToShape; (* ---------- LineFormat, dual, nonextensible ---------- *) PROCEDURE (this: LineFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: LineFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: LineFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: LineFormat) BackColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END BackColor; PROCEDURE (this: LineFormat) BeginArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END BeginArrowheadLength; PROCEDURE (this: LineFormat) PUTBeginArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTBeginArrowheadLength; PROCEDURE (this: LineFormat) BeginArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END BeginArrowheadStyle; PROCEDURE (this: LineFormat) PUTBeginArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTBeginArrowheadStyle; PROCEDURE (this: LineFormat) BeginArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END BeginArrowheadWidth; PROCEDURE (this: LineFormat) PUTBeginArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTBeginArrowheadWidth; PROCEDURE (this: LineFormat) DashStyle* (): CtlOffice.MsoLineDashStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END DashStyle; PROCEDURE (this: LineFormat) PUTDashStyle* (p1: CtlOffice.MsoLineDashStyle), NEW; BEGIN CtlC.PutInt(this, 104, p1) END PUTDashStyle; PROCEDURE (this: LineFormat) EndArrowheadLength* (): CtlOffice.MsoArrowheadLength, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END EndArrowheadLength; PROCEDURE (this: LineFormat) PUTEndArrowheadLength* (p1: CtlOffice.MsoArrowheadLength), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTEndArrowheadLength; PROCEDURE (this: LineFormat) EndArrowheadStyle* (): CtlOffice.MsoArrowheadStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END EndArrowheadStyle; PROCEDURE (this: LineFormat) PUTEndArrowheadStyle* (p1: CtlOffice.MsoArrowheadStyle), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTEndArrowheadStyle; PROCEDURE (this: LineFormat) EndArrowheadWidth* (): CtlOffice.MsoArrowheadWidth, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END EndArrowheadWidth; PROCEDURE (this: LineFormat) PUTEndArrowheadWidth* (p1: CtlOffice.MsoArrowheadWidth), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTEndArrowheadWidth; PROCEDURE (this: LineFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 108)) END ForeColor; PROCEDURE (this: LineFormat) Pattern* (): CtlOffice.MsoPatternType, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END Pattern; PROCEDURE (this: LineFormat) PUTPattern* (p1: CtlOffice.MsoPatternType), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTPattern; PROCEDURE (this: LineFormat) Style* (): CtlOffice.MsoLineStyle, NEW; BEGIN RETURN CtlC.GetInt(this, 110) END Style; PROCEDURE (this: LineFormat) PUTStyle* (p1: CtlOffice.MsoLineStyle), NEW; BEGIN CtlC.PutInt(this, 110, p1) END PUTStyle; PROCEDURE (this: LineFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Transparency; PROCEDURE (this: LineFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTransparency; PROCEDURE (this: LineFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 112) END Visible; PROCEDURE (this: LineFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 112, p1) END PUTVisible; PROCEDURE (this: LineFormat) Weight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 113) END Weight; PROCEDURE (this: LineFormat) PUTWeight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 113, p1) END PUTWeight; (* ---------- PictureFormat, dual, nonextensible ---------- *) PROCEDURE (this: PictureFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: PictureFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: PictureFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: PictureFormat) Brightness* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Brightness; PROCEDURE (this: PictureFormat) PUTBrightness* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTBrightness; PROCEDURE (this: PictureFormat) ColorType* (): CtlOffice.MsoPictureColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END ColorType; PROCEDURE (this: PictureFormat) PUTColorType* (p1: CtlOffice.MsoPictureColorType), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTColorType; PROCEDURE (this: PictureFormat) Contrast* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END Contrast; PROCEDURE (this: PictureFormat) PUTContrast* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTContrast; PROCEDURE (this: PictureFormat) CropBottom* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END CropBottom; PROCEDURE (this: PictureFormat) PUTCropBottom* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTCropBottom; PROCEDURE (this: PictureFormat) CropLeft* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END CropLeft; PROCEDURE (this: PictureFormat) PUTCropLeft* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTCropLeft; PROCEDURE (this: PictureFormat) CropRight* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 105) END CropRight; PROCEDURE (this: PictureFormat) PUTCropRight* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 105, p1) END PUTCropRight; PROCEDURE (this: PictureFormat) CropTop* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 106) END CropTop; PROCEDURE (this: PictureFormat) PUTCropTop* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 106, p1) END PUTCropTop; PROCEDURE (this: PictureFormat) TransparencyColor* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END TransparencyColor; PROCEDURE (this: PictureFormat) PUTTransparencyColor* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTTransparencyColor; PROCEDURE (this: PictureFormat) TransparentBackground* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END TransparentBackground; PROCEDURE (this: PictureFormat) PUTTransparentBackground* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTTransparentBackground; PROCEDURE (this: PictureFormat) IncrementBrightness* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementBrightness; PROCEDURE (this: PictureFormat) IncrementContrast* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementContrast; (* ---------- ShadowFormat, dual, nonextensible ---------- *) PROCEDURE (this: ShadowFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ShadowFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ShadowFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShadowFormat) ForeColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 100)) END ForeColor; PROCEDURE (this: ShadowFormat) Obscured* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Obscured; PROCEDURE (this: ShadowFormat) PUTObscured* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTObscured; PROCEDURE (this: ShadowFormat) OffsetX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 102) END OffsetX; PROCEDURE (this: ShadowFormat) PUTOffsetX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 102, p1) END PUTOffsetX; PROCEDURE (this: ShadowFormat) OffsetY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 103) END OffsetY; PROCEDURE (this: ShadowFormat) PUTOffsetY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 103, p1) END PUTOffsetY; PROCEDURE (this: ShadowFormat) Transparency* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END Transparency; PROCEDURE (this: ShadowFormat) PUTTransparency* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTTransparency; PROCEDURE (this: ShadowFormat) Type* (): CtlOffice.MsoShadowType, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END Type; PROCEDURE (this: ShadowFormat) PUTType* (p1: CtlOffice.MsoShadowType), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTType; PROCEDURE (this: ShadowFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END Visible; PROCEDURE (this: ShadowFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTVisible; PROCEDURE (this: ShadowFormat) IncrementOffsetX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementOffsetX; PROCEDURE (this: ShadowFormat) IncrementOffsetY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementOffsetY; (* ---------- ShapeNode, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNode) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ShapeNode) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ShapeNode) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNode) EditingType* (): CtlOffice.MsoEditingType, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END EditingType; PROCEDURE (this: ShapeNode) Points* (): CtlT.Any, NEW; BEGIN RETURN CtlC.GetAny(this, 101) END Points; PROCEDURE (this: ShapeNode) SegmentType* (): CtlOffice.MsoSegmentType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END SegmentType; (* ---------- ShapeNodes, dual, nonextensible ---------- *) PROCEDURE (this: ShapeNodes) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ShapeNodes) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ShapeNodes) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ShapeNodes) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END Count; PROCEDURE (this: ShapeNodes) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: ShapeNodes) Delete* (Index: INTEGER), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END Delete; PROCEDURE (this: ShapeNodes) Item* (Index: CtlT.Any): ShapeNode, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisShapeNode(CtlC.VarAny(ret)) END Item; PROCEDURE (this: ShapeNodes) SetEditingType* (Index: INTEGER; EditingType: CtlOffice.MsoEditingType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(EditingType, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetEditingType; PROCEDURE (this: ShapeNodes) SetPosition* (Index: INTEGER; X1: SHORTREAL; Y1: SHORTREAL), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[2]); CtlC.SRealVar(X1, arg[1]); CtlC.SRealVar(Y1, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetPosition; PROCEDURE (this: ShapeNodes) SetSegmentType* (Index: INTEGER; SegmentType: CtlOffice.MsoSegmentType), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[1]); CtlC.IntVar(SegmentType, arg[0]); CtlC.CallParMethod(this, 15, arg, NIL); END SetSegmentType; PROCEDURE (this: ShapeNodes) Insert* (Index: INTEGER; SegmentType: CtlOffice.MsoSegmentType; EditingType: CtlOffice.MsoEditingType; X1: SHORTREAL; Y1: SHORTREAL; X2: SHORTREAL; Y2: SHORTREAL; X3: SHORTREAL; Y3: SHORTREAL), NEW; VAR arg: ARRAY 9 OF CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[8]); CtlC.IntVar(SegmentType, arg[7]); CtlC.IntVar(EditingType, arg[6]); CtlC.SRealVar(X1, arg[5]); CtlC.SRealVar(Y1, arg[4]); CtlC.SRealVar(X2, arg[3]); CtlC.SRealVar(Y2, arg[2]); CtlC.SRealVar(X3, arg[1]); CtlC.SRealVar(Y3, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END Insert; (* ---------- TextEffectFormat, dual, nonextensible ---------- *) PROCEDURE (this: TextEffectFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: TextEffectFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: TextEffectFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: TextEffectFormat) Alignment* (): CtlOffice.MsoTextEffectAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 100) END Alignment; PROCEDURE (this: TextEffectFormat) PUTAlignment* (p1: CtlOffice.MsoTextEffectAlignment), NEW; BEGIN CtlC.PutInt(this, 100, p1) END PUTAlignment; PROCEDURE (this: TextEffectFormat) FontBold* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END FontBold; PROCEDURE (this: TextEffectFormat) PUTFontBold* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 101, p1) END PUTFontBold; PROCEDURE (this: TextEffectFormat) FontItalic* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END FontItalic; PROCEDURE (this: TextEffectFormat) PUTFontItalic* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTFontItalic; PROCEDURE (this: TextEffectFormat) FontName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END FontName; PROCEDURE (this: TextEffectFormat) PUTFontName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTFontName; PROCEDURE (this: TextEffectFormat) FontSize* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 104) END FontSize; PROCEDURE (this: TextEffectFormat) PUTFontSize* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 104, p1) END PUTFontSize; PROCEDURE (this: TextEffectFormat) KernedPairs* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END KernedPairs; PROCEDURE (this: TextEffectFormat) PUTKernedPairs* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTKernedPairs; PROCEDURE (this: TextEffectFormat) NormalizedHeight* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END NormalizedHeight; PROCEDURE (this: TextEffectFormat) PUTNormalizedHeight* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTNormalizedHeight; PROCEDURE (this: TextEffectFormat) PresetShape* (): CtlOffice.MsoPresetTextEffectShape, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetShape; PROCEDURE (this: TextEffectFormat) PUTPresetShape* (p1: CtlOffice.MsoPresetTextEffectShape), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetShape; PROCEDURE (this: TextEffectFormat) PresetTextEffect* (): CtlOffice.MsoPresetTextEffect, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetTextEffect; PROCEDURE (this: TextEffectFormat) PUTPresetTextEffect* (p1: CtlOffice.MsoPresetTextEffect), NEW; BEGIN CtlC.PutInt(this, 108, p1) END PUTPresetTextEffect; PROCEDURE (this: TextEffectFormat) RotatedChars* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 109) END RotatedChars; PROCEDURE (this: TextEffectFormat) PUTRotatedChars* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 109, p1) END PUTRotatedChars; PROCEDURE (this: TextEffectFormat) Text* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 110) END Text; PROCEDURE (this: TextEffectFormat) PUTText* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 110, p1) END PUTText; PROCEDURE (this: TextEffectFormat) Tracking* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 111) END Tracking; PROCEDURE (this: TextEffectFormat) PUTTracking* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 111, p1) END PUTTracking; PROCEDURE (this: TextEffectFormat) ToggleVerticalText* (), NEW; BEGIN CtlC.CallMethod(this, 10, NIL); END ToggleVerticalText; (* ---------- ThreeDFormat, dual, nonextensible ---------- *) PROCEDURE (this: ThreeDFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: ThreeDFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: ThreeDFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1) END Parent; PROCEDURE (this: ThreeDFormat) Depth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 100) END Depth; PROCEDURE (this: ThreeDFormat) PUTDepth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 100, p1) END PUTDepth; PROCEDURE (this: ThreeDFormat) ExtrusionColor* (): ColorFormat, NEW; BEGIN RETURN ThisColorFormat(CtlC.GetAny(this, 101)) END ExtrusionColor; PROCEDURE (this: ThreeDFormat) ExtrusionColorType* (): CtlOffice.MsoExtrusionColorType, NEW; BEGIN RETURN CtlC.GetInt(this, 102) END ExtrusionColorType; PROCEDURE (this: ThreeDFormat) PUTExtrusionColorType* (p1: CtlOffice.MsoExtrusionColorType), NEW; BEGIN CtlC.PutInt(this, 102, p1) END PUTExtrusionColorType; PROCEDURE (this: ThreeDFormat) Perspective* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 103) END Perspective; PROCEDURE (this: ThreeDFormat) PUTPerspective* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 103, p1) END PUTPerspective; PROCEDURE (this: ThreeDFormat) PresetExtrusionDirection* (): CtlOffice.MsoPresetExtrusionDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 104) END PresetExtrusionDirection; PROCEDURE (this: ThreeDFormat) PresetLightingDirection* (): CtlOffice.MsoPresetLightingDirection, NEW; BEGIN RETURN CtlC.GetInt(this, 105) END PresetLightingDirection; PROCEDURE (this: ThreeDFormat) PUTPresetLightingDirection* (p1: CtlOffice.MsoPresetLightingDirection), NEW; BEGIN CtlC.PutInt(this, 105, p1) END PUTPresetLightingDirection; PROCEDURE (this: ThreeDFormat) PresetLightingSoftness* (): CtlOffice.MsoPresetLightingSoftness, NEW; BEGIN RETURN CtlC.GetInt(this, 106) END PresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PUTPresetLightingSoftness* (p1: CtlOffice.MsoPresetLightingSoftness), NEW; BEGIN CtlC.PutInt(this, 106, p1) END PUTPresetLightingSoftness; PROCEDURE (this: ThreeDFormat) PresetMaterial* (): CtlOffice.MsoPresetMaterial, NEW; BEGIN RETURN CtlC.GetInt(this, 107) END PresetMaterial; PROCEDURE (this: ThreeDFormat) PUTPresetMaterial* (p1: CtlOffice.MsoPresetMaterial), NEW; BEGIN CtlC.PutInt(this, 107, p1) END PUTPresetMaterial; PROCEDURE (this: ThreeDFormat) PresetThreeDFormat* (): CtlOffice.MsoPresetThreeDFormat, NEW; BEGIN RETURN CtlC.GetInt(this, 108) END PresetThreeDFormat; PROCEDURE (this: ThreeDFormat) RotationX* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 109) END RotationX; PROCEDURE (this: ThreeDFormat) PUTRotationX* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 109, p1) END PUTRotationX; PROCEDURE (this: ThreeDFormat) RotationY* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 110) END RotationY; PROCEDURE (this: ThreeDFormat) PUTRotationY* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 110, p1) END PUTRotationY; PROCEDURE (this: ThreeDFormat) Visible* (): CtlOffice.MsoTriState, NEW; BEGIN RETURN CtlC.GetInt(this, 111) END Visible; PROCEDURE (this: ThreeDFormat) PUTVisible* (p1: CtlOffice.MsoTriState), NEW; BEGIN CtlC.PutInt(this, 111, p1) END PUTVisible; PROCEDURE (this: ThreeDFormat) IncrementRotationX* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END IncrementRotationX; PROCEDURE (this: ThreeDFormat) IncrementRotationY* (Increment: SHORTREAL), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.SRealVar(Increment, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END IncrementRotationY; PROCEDURE (this: ThreeDFormat) ResetRotation* (), NEW; BEGIN CtlC.CallMethod(this, 12, NIL); END ResetRotation; PROCEDURE (this: ThreeDFormat) SetExtrusionDirection* (PresetExtrusionDirection: CtlOffice.MsoPresetExtrusionDirection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetExtrusionDirection, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); END SetExtrusionDirection; PROCEDURE (this: ThreeDFormat) SetThreeDFormat* (PresetThreeDFormat: CtlOffice.MsoPresetThreeDFormat), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.IntVar(PresetThreeDFormat, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); END SetThreeDFormat; (* ---------- ApplicationEvents, hidden ---------- *) PROCEDURE (this: ApplicationEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF END END Invoke; PROCEDURE (this: ApplicationEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000209F7-0000-0000-C000-000000000046}" END GetIID; (* ---------- DocumentEvents, hidden ---------- *) PROCEDURE (this: DocumentEvents) New* (), NEW, ABSTRACT; PROCEDURE (this: DocumentEvents) Open* (), NEW, ABSTRACT; PROCEDURE (this: DocumentEvents) Close* (), NEW, ABSTRACT; PROCEDURE (this: DocumentEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 4: ASSERT(n = 0, 11); this.New() | 5: ASSERT(n = 0, 11); this.Open() | 6: ASSERT(n = 0, 11); this.Close() END END Invoke; PROCEDURE (this: DocumentEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000209F6-0000-0000-C000-000000000046}" END GetIID; (* ---------- OCXEvents, hidden ---------- *) PROCEDURE (this: OCXEvents) GotFocus* (), NEW, ABSTRACT; PROCEDURE (this: OCXEvents) LostFocus* (), NEW, ABSTRACT; PROCEDURE (this: OCXEvents) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | -2147417888: ASSERT(n = 0, 11); this.GotFocus() | -2147417887: ASSERT(n = 0, 11); this.LostFocus() END END Invoke; PROCEDURE (this: OCXEvents) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000209F3-0000-0000-C000-000000000046}" END GetIID; (* ---------- IApplicationEvents, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IApplicationEvents) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 2, NIL); END Quit; PROCEDURE (this: IApplicationEvents) DocumentChange* (), NEW; BEGIN CtlC.CallMethod(this, 3, NIL); END DocumentChange; (* ---------- IApplicationEvents2, hidden, dual, nonextensible ---------- *) PROCEDURE (this: IApplicationEvents2) Quit* (), NEW; BEGIN CtlC.CallMethod(this, 2, NIL); END Quit; PROCEDURE (this: IApplicationEvents2) DocumentChange* (), NEW; BEGIN CtlC.CallMethod(this, 3, NIL); END DocumentChange; PROCEDURE (this: IApplicationEvents2) DocumentOpen* (Doc: Document), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[0]); CtlC.CallParMethod(this, 4, arg, NIL); END DocumentOpen; PROCEDURE (this: IApplicationEvents2) DocumentBeforeClose* (Doc: Document; VAR Cancel: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; Cancel_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[1]); CtlC.BoolVar(Cancel, Cancel_TEMP); CtlC.RefBoolVar(Cancel_TEMP, arg[0]); CtlC.CallParMethod(this, 6, arg, NIL); Cancel := CtlC.VarBool(Cancel_TEMP); END DocumentBeforeClose; PROCEDURE (this: IApplicationEvents2) DocumentBeforePrint* (Doc: Document; VAR Cancel: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; Cancel_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[1]); CtlC.BoolVar(Cancel, Cancel_TEMP); CtlC.RefBoolVar(Cancel_TEMP, arg[0]); CtlC.CallParMethod(this, 7, arg, NIL); Cancel := CtlC.VarBool(Cancel_TEMP); END DocumentBeforePrint; PROCEDURE (this: IApplicationEvents2) DocumentBeforeSave* (Doc: Document; VAR SaveAsUI: BOOLEAN; VAR Cancel: BOOLEAN), NEW; VAR arg: ARRAY 3 OF CtlT.Variant; SaveAsUI_TEMP: CtlT.Variant; Cancel_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[2]); CtlC.BoolVar(SaveAsUI, SaveAsUI_TEMP); CtlC.RefBoolVar(SaveAsUI_TEMP, arg[1]); CtlC.BoolVar(Cancel, Cancel_TEMP); CtlC.RefBoolVar(Cancel_TEMP, arg[0]); CtlC.CallParMethod(this, 8, arg, NIL); SaveAsUI := CtlC.VarBool(SaveAsUI_TEMP); Cancel := CtlC.VarBool(Cancel_TEMP); END DocumentBeforeSave; PROCEDURE (this: IApplicationEvents2) NewDocument* (Doc: Document), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[0]); CtlC.CallParMethod(this, 9, arg, NIL); END NewDocument; PROCEDURE (this: IApplicationEvents2) WindowActivate* (Doc: Document; Wn: Window), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[1]); CtlC.ObjVar(Wn, arg[0]); CtlC.CallParMethod(this, 10, arg, NIL); END WindowActivate; PROCEDURE (this: IApplicationEvents2) WindowDeactivate* (Doc: Document; Wn: Window), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; BEGIN CtlC.ObjVar(Doc, arg[1]); CtlC.ObjVar(Wn, arg[0]); CtlC.CallParMethod(this, 11, arg, NIL); END WindowDeactivate; PROCEDURE (this: IApplicationEvents2) WindowSelectionChange* (Sel: Selection), NEW; VAR arg: ARRAY 1 OF CtlT.Variant; BEGIN CtlC.ObjVar(Sel, arg[0]); CtlC.CallParMethod(this, 12, arg, NIL); END WindowSelectionChange; PROCEDURE (this: IApplicationEvents2) WindowBeforeRightClick* (Sel: Selection; VAR Cancel: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; Cancel_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Sel, arg[1]); CtlC.BoolVar(Cancel, Cancel_TEMP); CtlC.RefBoolVar(Cancel_TEMP, arg[0]); CtlC.CallParMethod(this, 13, arg, NIL); Cancel := CtlC.VarBool(Cancel_TEMP); END WindowBeforeRightClick; PROCEDURE (this: IApplicationEvents2) WindowBeforeDoubleClick* (Sel: Selection; VAR Cancel: BOOLEAN), NEW; VAR arg: ARRAY 2 OF CtlT.Variant; Cancel_TEMP: CtlT.Variant; BEGIN CtlC.ObjVar(Sel, arg[1]); CtlC.BoolVar(Cancel, Cancel_TEMP); CtlC.RefBoolVar(Cancel_TEMP, arg[0]); CtlC.CallParMethod(this, 14, arg, NIL); Cancel := CtlC.VarBool(Cancel_TEMP); END WindowBeforeDoubleClick; (* ---------- ApplicationEvents2, hidden ---------- *) PROCEDURE (this: ApplicationEvents2) Quit* (), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) DocumentChange* (), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) DocumentOpen* (Doc: Document), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) DocumentBeforeClose* (Doc: Document; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) DocumentBeforePrint* (Doc: Document; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) DocumentBeforeSave* (Doc: Document; VAR SaveAsUI: BOOLEAN; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) NewDocument* (Doc: Document), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) WindowActivate* (Doc: Document; Wn: Window), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) WindowDeactivate* (Doc: Document; Wn: Window), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) WindowSelectionChange* (Sel: Selection), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) WindowBeforeRightClick* (Sel: Selection; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) WindowBeforeDoubleClick* (Sel: Selection; VAR Cancel: BOOLEAN), NEW, ABSTRACT; PROCEDURE (this: ApplicationEvents2) Invoke* (id, n: INTEGER; VAR par: CtlT.ParList; VAR ret: CtlT.Variant); BEGIN CASE id OF | 2: ASSERT(n = 0, 11); this.Quit() | 3: ASSERT(n = 0, 11); this.DocumentChange() | 4: ASSERT(n = 1, 11); this.DocumentOpen(This_Document(CtlC.VarAny(par[0]))) | 6: ASSERT(n = 2, 11); this.DocumentBeforeClose(This_Document(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 7: ASSERT(n = 2, 11); this.DocumentBeforePrint(This_Document(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 8: ASSERT(n = 3, 11); this.DocumentBeforeSave(This_Document(CtlC.VarAny(par[2])), CtlC.VarRefBool(par[1])[0], CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[1]); CtlC.RetBool(par[0]) | 9: ASSERT(n = 1, 11); this.NewDocument(This_Document(CtlC.VarAny(par[0]))) | 10: ASSERT(n = 2, 11); this.WindowActivate(This_Document(CtlC.VarAny(par[1])), ThisWindow(CtlC.VarAny(par[0]))) | 11: ASSERT(n = 2, 11); this.WindowDeactivate(This_Document(CtlC.VarAny(par[1])), ThisWindow(CtlC.VarAny(par[0]))) | 12: ASSERT(n = 1, 11); this.WindowSelectionChange(ThisSelection(CtlC.VarAny(par[0]))) | 13: ASSERT(n = 2, 11); this.WindowBeforeRightClick(ThisSelection(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) | 14: ASSERT(n = 2, 11); this.WindowBeforeDoubleClick(ThisSelection(CtlC.VarAny(par[1])), CtlC.VarRefBool(par[0])[0]); CtlC.RetBool(par[0]) END END Invoke; PROCEDURE (this: ApplicationEvents2) GetIID* (OUT iid: CtlT.GUID); BEGIN iid := "{000209FE-0000-0000-C000-000000000046}" END GetIID; (* ---------- EmailAuthor, dual, nonextensible ---------- *) PROCEDURE (this: EmailAuthor) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: EmailAuthor) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: EmailAuthor) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: EmailAuthor) Style* (): Style, NEW; BEGIN RETURN ThisStyle(CtlC.GetAny(this, 103)) END Style; (* ---------- EmailOptions, dual, nonextensible ---------- *) PROCEDURE (this: EmailOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 100)) END Application; PROCEDURE (this: EmailOptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Creator; PROCEDURE (this: EmailOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 102) END Parent; PROCEDURE (this: EmailOptions) UseThemeStyle* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 103) END UseThemeStyle; PROCEDURE (this: EmailOptions) PUTUseThemeStyle* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 103, p1) END PUTUseThemeStyle; PROCEDURE (this: EmailOptions) MarkCommentsWith* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 106) END MarkCommentsWith; PROCEDURE (this: EmailOptions) PUTMarkCommentsWith* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 106, p1) END PUTMarkCommentsWith; PROCEDURE (this: EmailOptions) MarkComments* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 107) END MarkComments; PROCEDURE (this: EmailOptions) PUTMarkComments* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 107, p1) END PUTMarkComments; PROCEDURE (this: EmailOptions) EmailSignature* (): EmailSignature, NEW; BEGIN RETURN ThisEmailSignature(CtlC.GetAny(this, 108)) END EmailSignature; PROCEDURE (this: EmailOptions) ComposeStyle* (): Style, NEW; BEGIN RETURN ThisStyle(CtlC.GetAny(this, 109)) END ComposeStyle; PROCEDURE (this: EmailOptions) ReplyStyle* (): Style, NEW; BEGIN RETURN ThisStyle(CtlC.GetAny(this, 110)) END ReplyStyle; PROCEDURE (this: EmailOptions) ThemeName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 114) END ThemeName; PROCEDURE (this: EmailOptions) PUTThemeName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 114, p1) END PUTThemeName; (* ---------- EmailSignature, dual, nonextensible ---------- *) PROCEDURE (this: EmailSignature) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 100)) END Application; PROCEDURE (this: EmailSignature) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Creator; PROCEDURE (this: EmailSignature) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 102) END Parent; PROCEDURE (this: EmailSignature) NewMessageSignature* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 103) END NewMessageSignature; PROCEDURE (this: EmailSignature) PUTNewMessageSignature* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 103, p1) END PUTNewMessageSignature; PROCEDURE (this: EmailSignature) ReplyMessageSignature* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 104) END ReplyMessageSignature; PROCEDURE (this: EmailSignature) PUTReplyMessageSignature* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 104, p1) END PUTReplyMessageSignature; (* ---------- Email, dual, nonextensible ---------- *) PROCEDURE (this: Email) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 100)) END Application; PROCEDURE (this: Email) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 101) END Creator; PROCEDURE (this: Email) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 102) END Parent; PROCEDURE (this: Email) CurrentEmailAuthor* (): EmailAuthor, NEW; BEGIN RETURN ThisEmailAuthor(CtlC.GetAny(this, 105)) END CurrentEmailAuthor; (* ---------- HorizontalLineFormat, dual, nonextensible ---------- *) PROCEDURE (this: HorizontalLineFormat) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: HorizontalLineFormat) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: HorizontalLineFormat) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: HorizontalLineFormat) PercentWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 2) END PercentWidth; PROCEDURE (this: HorizontalLineFormat) PUTPercentWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 2, p1) END PUTPercentWidth; PROCEDURE (this: HorizontalLineFormat) NoShade* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END NoShade; PROCEDURE (this: HorizontalLineFormat) PUTNoShade* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTNoShade; PROCEDURE (this: HorizontalLineFormat) Alignment* (): WdHorizontalLineAlignment, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Alignment; PROCEDURE (this: HorizontalLineFormat) PUTAlignment* (p1: WdHorizontalLineAlignment), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTAlignment; PROCEDURE (this: HorizontalLineFormat) WidthType* (): WdHorizontalLineWidthType, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END WidthType; PROCEDURE (this: HorizontalLineFormat) PUTWidthType* (p1: WdHorizontalLineWidthType), NEW; BEGIN CtlC.PutInt(this, 5, p1) END PUTWidthType; (* ---------- Frameset, dual, nonextensible ---------- *) PROCEDURE (this: Frameset) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: Frameset) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: Frameset) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: Frameset) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: Frameset) ParentFrameset* (): Frameset, NEW; BEGIN RETURN ThisFrameset(CtlC.GetAny(this, 1003)) END ParentFrameset; PROCEDURE (this: Frameset) Type* (): WdFramesetType, NEW; BEGIN RETURN CtlC.GetInt(this, 0) END Type; PROCEDURE (this: Frameset) WidthType* (): WdFramesetSizeType, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END WidthType; PROCEDURE (this: Frameset) PUTWidthType* (p1: WdFramesetSizeType), NEW; BEGIN CtlC.PutInt(this, 1, p1) END PUTWidthType; PROCEDURE (this: Frameset) HeightType* (): WdFramesetSizeType, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END HeightType; PROCEDURE (this: Frameset) PUTHeightType* (p1: WdFramesetSizeType), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTHeightType; PROCEDURE (this: Frameset) Width* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 3) END Width; PROCEDURE (this: Frameset) PUTWidth* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 3, p1) END PUTWidth; PROCEDURE (this: Frameset) Height* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 4) END Height; PROCEDURE (this: Frameset) PUTHeight* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 4, p1) END PUTHeight; PROCEDURE (this: Frameset) ChildFramesetCount* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 5) END ChildFramesetCount; PROCEDURE (this: Frameset) ChildFramesetItem* (Index: INTEGER): Frameset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Index, arg[0]); CtlC.CallGetMethod(this, 6, arg, ret); RETURN ThisFrameset(CtlC.VarAny(ret)) END ChildFramesetItem; PROCEDURE (this: Frameset) FramesetBorderWidth* (): SHORTREAL, NEW; BEGIN RETURN CtlC.GetSReal(this, 20) END FramesetBorderWidth; PROCEDURE (this: Frameset) PUTFramesetBorderWidth* (p1: SHORTREAL), NEW; BEGIN CtlC.PutSReal(this, 20, p1) END PUTFramesetBorderWidth; PROCEDURE (this: Frameset) FramesetBorderColor* (): WdColor, NEW; BEGIN RETURN CtlC.GetInt(this, 21) END FramesetBorderColor; PROCEDURE (this: Frameset) PUTFramesetBorderColor* (p1: WdColor), NEW; BEGIN CtlC.PutInt(this, 21, p1) END PUTFramesetBorderColor; PROCEDURE (this: Frameset) FrameScrollbarType* (): WdScrollbarType, NEW; BEGIN RETURN CtlC.GetInt(this, 30) END FrameScrollbarType; PROCEDURE (this: Frameset) PUTFrameScrollbarType* (p1: WdScrollbarType), NEW; BEGIN CtlC.PutInt(this, 30, p1) END PUTFrameScrollbarType; PROCEDURE (this: Frameset) FrameResizable* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 31) END FrameResizable; PROCEDURE (this: Frameset) PUTFrameResizable* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 31, p1) END PUTFrameResizable; PROCEDURE (this: Frameset) FrameName* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 34) END FrameName; PROCEDURE (this: Frameset) PUTFrameName* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 34, p1) END PUTFrameName; PROCEDURE (this: Frameset) FrameDisplayBorders* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 35) END FrameDisplayBorders; PROCEDURE (this: Frameset) PUTFrameDisplayBorders* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 35, p1) END PUTFrameDisplayBorders; PROCEDURE (this: Frameset) FrameDefaultURL* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 36) END FrameDefaultURL; PROCEDURE (this: Frameset) PUTFrameDefaultURL* (p1: ARRAY OF CHAR), NEW; BEGIN CtlC.PutStr(this, 36, p1) END PUTFrameDefaultURL; PROCEDURE (this: Frameset) FrameLinkToFile* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 37) END FrameLinkToFile; PROCEDURE (this: Frameset) PUTFrameLinkToFile* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 37, p1) END PUTFrameLinkToFile; PROCEDURE (this: Frameset) AddNewFrame* (Where: WdFramesetNewFrameLocation): Frameset, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.IntVar(Where, arg[0]); CtlC.CallParMethod(this, 50, arg, ret); RETURN ThisFrameset(CtlC.VarAny(ret)) END AddNewFrame; PROCEDURE (this: Frameset) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 51, NIL); END Delete; (* ---------- DefaultWebOptions, dual, nonextensible ---------- *) PROCEDURE (this: DefaultWebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: DefaultWebOptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: DefaultWebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: DefaultWebOptions) OptimizeForBrowser* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END OptimizeForBrowser; PROCEDURE (this: DefaultWebOptions) PUTOptimizeForBrowser* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTOptimizeForBrowser; PROCEDURE (this: DefaultWebOptions) BrowserLevel* (): WdBrowserLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END BrowserLevel; PROCEDURE (this: DefaultWebOptions) PUTBrowserLevel* (p1: WdBrowserLevel), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTBrowserLevel; PROCEDURE (this: DefaultWebOptions) RelyOnCSS* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END RelyOnCSS; PROCEDURE (this: DefaultWebOptions) PUTRelyOnCSS* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTRelyOnCSS; PROCEDURE (this: DefaultWebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END OrganizeInFolder; PROCEDURE (this: DefaultWebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTOrganizeInFolder; PROCEDURE (this: DefaultWebOptions) UpdateLinksOnSave* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END UpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) PUTUpdateLinksOnSave* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTUpdateLinksOnSave; PROCEDURE (this: DefaultWebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END UseLongFileNames; PROCEDURE (this: DefaultWebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTUseLongFileNames; PROCEDURE (this: DefaultWebOptions) CheckIfOfficeIsHTMLEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END CheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) PUTCheckIfOfficeIsHTMLEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTCheckIfOfficeIsHTMLEditor; PROCEDURE (this: DefaultWebOptions) CheckIfWordIsDefaultHTMLEditor* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 8) END CheckIfWordIsDefaultHTMLEditor; PROCEDURE (this: DefaultWebOptions) PUTCheckIfWordIsDefaultHTMLEditor* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 8, p1) END PUTCheckIfWordIsDefaultHTMLEditor; PROCEDURE (this: DefaultWebOptions) RelyOnVML* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 9) END RelyOnVML; PROCEDURE (this: DefaultWebOptions) PUTRelyOnVML* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 9, p1) END PUTRelyOnVML; PROCEDURE (this: DefaultWebOptions) AllowPNG* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 10) END AllowPNG; PROCEDURE (this: DefaultWebOptions) PUTAllowPNG* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 10, p1) END PUTAllowPNG; PROCEDURE (this: DefaultWebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 11) END ScreenSize; PROCEDURE (this: DefaultWebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 11, p1) END PUTScreenSize; PROCEDURE (this: DefaultWebOptions) PixelsPerInch* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 12) END PixelsPerInch; PROCEDURE (this: DefaultWebOptions) PUTPixelsPerInch* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 12, p1) END PUTPixelsPerInch; PROCEDURE (this: DefaultWebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 13) END Encoding; PROCEDURE (this: DefaultWebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 13, p1) END PUTEncoding; PROCEDURE (this: DefaultWebOptions) AlwaysSaveInDefaultEncoding* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 14) END AlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) PUTAlwaysSaveInDefaultEncoding* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 14, p1) END PUTAlwaysSaveInDefaultEncoding; PROCEDURE (this: DefaultWebOptions) Fonts* (): CtlOffice.WebPageFonts, NEW; BEGIN RETURN CtlOffice.ThisWebPageFonts(CtlC.GetAny(this, 15)) END Fonts; PROCEDURE (this: DefaultWebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 16) END FolderSuffix; (* ---------- WebOptions, dual, nonextensible ---------- *) PROCEDURE (this: WebOptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: WebOptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: WebOptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: WebOptions) OptimizeForBrowser* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 1) END OptimizeForBrowser; PROCEDURE (this: WebOptions) PUTOptimizeForBrowser* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 1, p1) END PUTOptimizeForBrowser; PROCEDURE (this: WebOptions) BrowserLevel* (): WdBrowserLevel, NEW; BEGIN RETURN CtlC.GetInt(this, 2) END BrowserLevel; PROCEDURE (this: WebOptions) PUTBrowserLevel* (p1: WdBrowserLevel), NEW; BEGIN CtlC.PutInt(this, 2, p1) END PUTBrowserLevel; PROCEDURE (this: WebOptions) RelyOnCSS* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 3) END RelyOnCSS; PROCEDURE (this: WebOptions) PUTRelyOnCSS* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 3, p1) END PUTRelyOnCSS; PROCEDURE (this: WebOptions) OrganizeInFolder* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 4) END OrganizeInFolder; PROCEDURE (this: WebOptions) PUTOrganizeInFolder* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 4, p1) END PUTOrganizeInFolder; PROCEDURE (this: WebOptions) UseLongFileNames* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 5) END UseLongFileNames; PROCEDURE (this: WebOptions) PUTUseLongFileNames* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 5, p1) END PUTUseLongFileNames; PROCEDURE (this: WebOptions) RelyOnVML* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 6) END RelyOnVML; PROCEDURE (this: WebOptions) PUTRelyOnVML* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 6, p1) END PUTRelyOnVML; PROCEDURE (this: WebOptions) AllowPNG* (): BOOLEAN, NEW; BEGIN RETURN CtlC.GetBool(this, 7) END AllowPNG; PROCEDURE (this: WebOptions) PUTAllowPNG* (p1: BOOLEAN), NEW; BEGIN CtlC.PutBool(this, 7, p1) END PUTAllowPNG; PROCEDURE (this: WebOptions) ScreenSize* (): CtlOffice.MsoScreenSize, NEW; BEGIN RETURN CtlC.GetInt(this, 8) END ScreenSize; PROCEDURE (this: WebOptions) PUTScreenSize* (p1: CtlOffice.MsoScreenSize), NEW; BEGIN CtlC.PutInt(this, 8, p1) END PUTScreenSize; PROCEDURE (this: WebOptions) PixelsPerInch* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 9) END PixelsPerInch; PROCEDURE (this: WebOptions) PUTPixelsPerInch* (p1: INTEGER), NEW; BEGIN CtlC.PutInt(this, 9, p1) END PUTPixelsPerInch; PROCEDURE (this: WebOptions) Encoding* (): CtlOffice.MsoEncoding, NEW; BEGIN RETURN CtlC.GetInt(this, 10) END Encoding; PROCEDURE (this: WebOptions) PUTEncoding* (p1: CtlOffice.MsoEncoding), NEW; BEGIN CtlC.PutInt(this, 10, p1) END PUTEncoding; PROCEDURE (this: WebOptions) FolderSuffix* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 11) END FolderSuffix; PROCEDURE (this: WebOptions) UseDefaultFolderSuffix* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END UseDefaultFolderSuffix; (* ---------- OtherCorrectionsExceptions, dual, nonextensible ---------- *) PROCEDURE (this: OtherCorrectionsExceptions) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: OtherCorrectionsExceptions) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: OtherCorrectionsExceptions) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: OtherCorrectionsExceptions) _NewEnum* (): CtlT.Enumerator, NEW; BEGIN RETURN CtlC.GetEnum(this, -4) END _NewEnum; PROCEDURE (this: OtherCorrectionsExceptions) Count* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Count; PROCEDURE (this: OtherCorrectionsExceptions) Item* (Index: CtlT.Any): OtherCorrectionsException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.AnyVar(Index, arg[0]); CtlC.CallParMethod(this, 0, arg, ret); RETURN ThisOtherCorrectionsException(CtlC.VarAny(ret)) END Item; PROCEDURE (this: OtherCorrectionsExceptions) Add* (Name: ARRAY OF CHAR): OtherCorrectionsException, NEW; VAR arg: ARRAY 1 OF CtlT.Variant; ret: CtlT.Variant; BEGIN CtlC.StrVar(Name, arg[0]); CtlC.CallParMethod(this, 101, arg, ret); RETURN ThisOtherCorrectionsException(CtlC.VarAny(ret)) END Add; (* ---------- OtherCorrectionsException, dual, nonextensible ---------- *) PROCEDURE (this: OtherCorrectionsException) Application* (): Application, NEW; BEGIN RETURN This_Application(CtlC.GetAny(this, 1000)) END Application; PROCEDURE (this: OtherCorrectionsException) Creator* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1001) END Creator; PROCEDURE (this: OtherCorrectionsException) Parent* (): CtlT.Object, NEW; BEGIN RETURN CtlC.GetObj(this, 1002) END Parent; PROCEDURE (this: OtherCorrectionsException) Index* (): INTEGER, NEW; BEGIN RETURN CtlC.GetInt(this, 1) END Index; PROCEDURE (this: OtherCorrectionsException) Name* (): CtlT.Strg, NEW; BEGIN RETURN CtlC.GetStr(this, 2) END Name; PROCEDURE (this: OtherCorrectionsException) Delete* (), NEW; BEGIN CtlC.CallMethod(this, 101, NIL); END Delete; PROCEDURE NewGlobal* (): _Global; BEGIN RETURN This_Global(CtlC.NewObj("{000209F0-0000-0000-C000-000000000046}")) END NewGlobal; PROCEDURE NewApplication* (): _Application; BEGIN RETURN This_Application(CtlC.NewObj("{000209FF-0000-0000-C000-000000000046}")) END NewApplication; PROCEDURE NewDocument* (): _Document; BEGIN RETURN This_Document(CtlC.NewObj("{00020906-0000-0000-C000-000000000046}")) END NewDocument; PROCEDURE NewFont* (): _Font; BEGIN RETURN This_Font(CtlC.NewObj("{000209F5-0000-0000-C000-000000000046}")) END NewFont; PROCEDURE NewParagraphFormat* (): _ParagraphFormat; BEGIN RETURN This_ParagraphFormat(CtlC.NewObj("{000209F4-0000-0000-C000-000000000046}")) END NewParagraphFormat; PROCEDURE NewOLEControl* (): _OLEControl; BEGIN RETURN This_OLEControl(CtlC.NewObj("{000209F2-0000-0000-C000-000000000046}")) END NewOLEControl; PROCEDURE NewLetterContent* (): _LetterContent; BEGIN RETURN This_LetterContent(CtlC.NewObj("{000209F1-0000-0000-C000-000000000046}")) END NewLetterContent; END CtlWord9.

Ctl/Mod/Word9.odc