WO2000021001A1 - Object-oriented tag browser - Google Patents

Abstract

A system and method for displaying representations of tag sources representative of corresponding component devices includes a tag dictionary for defining the tag sources in a predefined object-oriented format. The tag dictionary is comprised of tag definition objects (152), each containing information relating to a given tag source and each being associated with a tag type object (156). A tag browser (144) allows for display and editing of the tag source representations in accordance with the tag definition objects (152). In a preferred implementation each of the representations includes information relating to a predefined set of parameters characterizing the tag sources. The tag browser (144) also optionally includes a tag filter for causing display of those tag source representations comporting with tag selection criteria, and for suppressing display of all other tag source representations.

Description

OBJECT-ORIENTED TAG BROWSER

FIELD OF THE INVENTION

This invention relates generally to industrial automation and control systems and, more particularly, to software for identifying and viewing representations of sensing and control devices included within such systems.

BACKGROUND OF THE INVENTION

The operation of industrial equipment such as assembly lines, machine tools and processing equipment is often governed by an automation controller in accordance with a stored program. In conventional automation controllers, the control program is stored in a memory and includes instructions which are read out in rapid sequence and executed to examine the condition of selected sensing devices on the controlled equipment, or to energize or de-energize selected operating devices on the controlled equipment contingent on the status of one or more of the examined sensing devices.

Large controllers typically consist of a number of modules with different functions assigned to each module. For example, one module may execute the user control program, another may interface the controller to the remote sensing and operating devices, and yet another module may control communications with a host computer via a local area network. This arrangement permits one or more human operators to monitor and control an industrial process via computer workstations.

As part of this monitoring process, it is desirable that the control program be capable of presenting the human operator with some type of representation of the parameters of the various sensing devices associated with a given industrial process. Such a representation (hereinafter, a "tag") would enable an operator to, for example, specify a set of sensing devices for which parameter measurements would be displayed by the control program. Unfortunately, display and selection of the various tags associated with a given industrial process is complicated by the fact that proprietary software is currently utilized to provide interfaces for such tags. Accordingly, an industrial control program needs to include code peculiar to each type of tag for which parameter measurements are to be displayed by the control program. In addition, mechanisms are not available for centralized monitoring of the tags representative of sensing devices monitored by more than one industrial control program.

SUMMARY OF THE INVENTION Briefly, the present invention provides a system and method for displaying representations of tag sources corresponding to various component devices of a process control system or the like. The inventive system includes a tag dictionary for defining the tag sources in a predefined object-oriented format. The tag dictionary is comprised of tag definition objects, each containing information relating to a given tag source and each being associated with a tag type object. The system of the invention also includes a tag browser for displaying and editing the representations of the tag sources in accordance with the tag definition objects. In a preferred implementation each of the representations includes information relating to a predefined set of parameters characterizing the tag sources. The tag browser also optionally includes a tag filter for causing display of those tag source representations comporting with tag selection criteria and for suppressing display of all other tag source representations.

A template tag dictionary is preferably provided within a development environment to facilitate generation of each tag dictionary. The template tag dictionary is modified within this development environment to reflect attributes of the tag sources. One or more template object-oriented controls of a predefined format compatible with said tag dictionary may also be provided in the development environment. These template object-oriented controls may be modified within the development environment so as to create a representation of each tag source of interest.

BRIEF DESCRIPTION OF THE DRAWINGS

In the accompanying drawings:

FIG. 1 is a block diagram of a computer system in which the present invention may be implemented.

FIGS. 2a-2d provide a representation of a tag dictionary of the present invention implemented as a COM object. FIG. 3 is an illustrative representation of a dialog bog preferably generated upon user invocation of a tag browser of the present invention.

DETAILED DESCRIPTION OF THE INVENTION OVERVIEW

FIG. 1 is a block diagram of a computer system 100 in which the present invention may be implemented. The computer system 100 includes a computer workstation 102 that communicates with a system storage unit over network 106. The system storage unit 104 comprises a direct access storage device, such as magnetic disk storage, in which data files are stored. The workstation 102 includes a central processing unit ("CPU") 108, a display 110, and a main memory 112. The CPU 108 operates in response to user commands, which it receives via a keyboard 114 or a display mouse 116. The computer workstation 102 can communicate with one or more other user stations or a network server unit over the network 106. The main memory 112 contains a variety of data structures and information, including an operating system, application programs, program objects, and user data. The main memory is represented as a single entity, but those skilled in the art will appreciate that the main memory can comprise a combination of random access memory ("RAM"), hard disk drives, optical disk drives, and other storage devices containing logically segmented storage locations. The main memory includes a computer program (described hereinafter) containing a sequence of program instructions whose execution implements the present invention.

The operating system contained in the memory 112 supports an object- oriented programming environment for the execution of object-oriented programs, such as those written in, for example, the C++ programming language. Accordingly, the memory contains program objects that are data structures of an object-oriented programming language. Application programs are invoked, or launched, by a user through the keyboard 114 or graphical input device 116. The application programs can be written in a variety of languages, including C++. The display 110 comprises a display device such as a video terminal that displays computer output and indicates system operations. Display objects can be pictured on the display and the user can designate data operations on the display by using the mouse 116 or equivalent graphical user input device. In an exemplary implementation the computer system 100 sends commands to, and receives data from, one or more industrial sensor or process control devices 120 via a data bus 122. The state of each such device 120 is reflected by the value of an associated tag, each of which may be a parameter of the container application. The automation program 126 interfaces with the process control devices 120 by way of an input/output ("I/O") server module 128

In the exemplary implementation the container application comprises an industrial automation software program 126, such as the InTouch program module developed by Wonderware Corporation of Irvine, California. The Wonderware Intouch module includes a tool kit for building screens and interfaces, a graphical user interface for monitoring and controlling the devices 120, and a mechanism for establishing appropriate database server links. The InTouch program is disposed to interact with objects developed in accordance with the format known as "ActiveX" (i.e., objects based upon the Object Linking and Embedding ("OLE") developed by Microsoft Corporation).

An exemplary process control device 120a is implemented using a programmable logic controller ("PLC") 130 and one or more sensors 132. The PLC 130 will typically include a set of registers 134 or the like for storing parameter information characterizing the sensors 132. Such parameter information could include, for example, the type of value (e.g., integer) returned by a given sensor.

Since the parameter information associated with different sensors 132 is of differing formats, the I/O server module 128 functions to convert the parameter information from the sensors 132 into a format useable by the automation program 126. As indicated by FIG. 1, a register 134a holds parameter information for a sensor 132 identified as "pump", and a register 134b holds parameter information for a sensor 132 identified as "motor". The I/O server similarly includes a table 140 in which an index item II holds converted parameter information from register 134a, and in which an index item 13 holds converted parameter information from register 134b. In like manner the automation program 126 defines a table 142 configured to create an association between the tags monitored by the automation program 126 and the index items of the table 140. For example, the tag PumpState is seen to correspond to index item II and the tag MotorState is seen to correspond to index item 13. In this way the I/O server obviates the need for the automation program 126 to contain code specific to each type of sensor 132 in order to access relevant parameter information.

STRUCTURE OF TAG BROWSER AND TAG DICTIONARY In accordance with one aspect of the invention, a tag browser 144 and tag dictionary 148 cooperate to enable a user of automation program 126 to view the parameters of tags associated with sensing devices controlled by other automation programs 150. In the exemplary embodiment of FIG. 1, the other automation programs 150 are installed on workstations (not shown) distinct from the workstation 102. The tag dictionary 148 is preferably implemented within the same process space as the automation program 126 as an object comporting with the Component Object Model ("COM") specified by the Microsoft Corporation. In the preferred embodiment, each source of tags ("tag source") viewable using the tag browser 144 is instantiated as an ActiveX control and is made accessible to the browser 144 via the tag dictionary 148.

FIGS. 2a-2d provide a representation of the tag dictionary 148 implemented as a COM object. The tag dictionary 148 comprises a collection of tag definition objects 152. Each tag definition 152 defines properties characterizing a given tag. Associated with each tag definition object 152 is a tag type object 156 comprised of a plurality of dot field objects 158. In response to user selection of a tag source via the tag browser interface (FIG. 3), the tag browser 144 instantiates a tag dictionary 148 corresponding to the selected tag source. The tag browser 144 then enumerates the tag definition objects 152 of the instantiated tag dictionary 148, as well as the tag type objects 156 and dot field objects 158 for each tag definition object 152. Exemplary sets of properties and methods applicable to the tag definition objects 152, tag type objects 156 and dot field objects 158 are set forth in Appendix A. In addition, Appendix B includes source code for generating generic "templates" of the tag dictionary 148. Such template tag dictionaries may be adapted for implementation with specific tag sources in accordance with the teachings herein and in Appendix A.

FIG. 3 is an illustrative representation of a dialog bog preferably generated upon user invocation of the tag browser 144. Such invocation may be effected through, for example, one or more predefined operations involving graphical user input device 116 (e.g., "double-clicking" in a blank portion of the automation program inteface). Referring to FIG. 3, the tags available for viewing by an operator of the automation program 126 are included within an "InTouch" directory having "<local>" and "Provider" subdirectories. The <local> subdirectory includes other subdirectories (e.g., "Beef), each containing representations of tags associated with the sensors 132 monitored and potentially controlled by the automation program 126. The Provider subdirectory includes tags associated with the other automation programs 150 made available to the tag browser 144 via the tag dictionary 148.

The tag browser 144 is designed to display tag parameters capable of being monitored or controlled by the automation program 126. For example, the tag parameters "Tagname", "Tag Type" and "Alarm Group" are displayed by the tag browser 144 in the specific case when the automation program 126 comprises the Wonderware Intouch utility. As is indicated by FIG. 3, the "Tag Type" of the highlighted tag "Fan2Motor" is seen to be "Memory Discrete". The "Fan2Motor" tag is also identified as being a member of the "Alarm Group" named "$System". Appendix C includes a functional description and specification of other operations performed by an exemplary implementation of the tag browser 144.

TAG SOURCES Each tag source is preferably represented as an instance of an ActiveX control referred to hereinafter as the DataSource control. In the preferred embodiment this control may be implemented in C, C++, Visual Basic, or any other programming language supporting COM interfaces. The DataSource control must also be capable of providing an interface which enables a user to select its tag source when the control is invoked by the tag browser 144. In an exemplary implementation such an interface comprises a dialog box of 260x160 dialog units (5850 x 3900 twips), assuming utilization of an MS Sans Serif 8-point font.

The DataSource control corresponding to each tag source will incorporate a number of properties and methods to facilitate interaction with the tag dictionary 148. For example, in the preferred embodiment each tag dictionary will be disposed to implement the "ITagDictionary::GetDataSource ControClsid" method described in Appendix A. Since this method returns the COM coclass Identifier ("CLSID") of the called DataSource control, each DataSource control will be designed to provide its CLSID in response to this query. Each DataSource control will also define a read/write property named "DataSource" of type BSTR. This property of the DataSource control will be used to initialize the source of tag data for each instance of the control. In a specific alternate embodiment, the automation program 126 invokes the method DataSourceValidation method (Appendix E) to determine the validity of the DataSource property. If the property is found to be valid, it is read by the DataSourceValidation method and persisted.

In a preferred implementation the tag browser 144 provides a dialog box through which the DataSource control corresponding to each tag source may be bound to tag dictionary 148 ("Tag Source dialog"). Upon invocation of the Tag Source dialog, the location of the tag source is selected and associated with a tag dictionary 148 via a drop-down list accessible from the Tag Source dialog. The dropdown list preferably displays representations of all tag dictionaries 148 registered as in-process servers within the system environment.

TAG FILTERING

In a preferred embodiment the tag browser 144 is disposed to filter the tags presented by display 110 on the basis of user-defined selection criteria. Specifically, selection criteria in the form of a regular expression serves to define a set of tags to be retrieved by the tag browser from available tag sources. In response to such a user- defined regular expression, the tag browser generates a Non-Deterministic Finite Automation ("NFA") designed to accept names of tags ("tagnames") comporting with the regular expression. This approach is believed to be unique in the sense that, for example, the NFA is generated "on-the-fly" each time the filter selection criteria (i.e., the user-defined regular expression) is modified. The tag browser 144 will preferably provide a user interface allowing entry of such regular expressions in an edit mode or the like.

Appendix D includes source code corresponding to a preferred implementation of this filtering aspect of the tag browser 144. In Appendix C, the file "tagfltr.h" includes a declaration of the applicable class while the file "tagfltr.cpp" defines implementation of the class. As may be appreciated by reference to Appendix C, an object of type "CTagFilter" is created in response to submission of a regular expression constituting the filter selection criteria. The CTagFilter then creates the NFA required to accept strings corresponding to the submitted regular expression. In particular, a table of "CStateTableEntry" objects representing the "triples" of the required NFA is created. Each such triple is of the form: STATE x INPUT_SYMBOL yields STATE

The function "ConstructStateMachine" is called once during definition of each CTagFilter object by the code responsible for constructing such object. Similarly, the function "DestroyStateMachine" is called once in the code disposed to destroy each CTagFilter object. In this way an NFA is created on-the-fly in response to each modification of the user-defined selection criteria.

Once CTagFilterObject has created an NFA, the member function "IsAMember" may be called to initiate the filtering process. During such process the IsAMember retrieves all known tagnames and passes them through the NFA. A boolean that is true is returned by the IsAMember function if the tagname is accepted, and a false returned otherwise. The tag browser 144 then includes the tagname in the view presented by the display 110 in the case of a returned expression which is true, and otherwise excludes the tagname from view.

Although the above application has been described primarily in terms of a particular implementation of a tag browser and tag dictionary, those skilled in the art will be readily capable of creating alternate implementations based upon the teachings herein.. Thus the application is meant only to be limited by the scope of the appended claims.

% APPENDIX A

Dictionary Description

A Tag Dictionary is a COM object that provides tags to the FactorySuite. Therefore, the Tag Dictionary is a Tag Provider. All Tag Dictionaries have the same interface. It provides a window onto the Tag Source. In the case of InTouch tags, the Tag Definition source is tagname. x.

Glossary of Terms

There are a number of acronyms used in this document. The following table defines the acronyms used:

■ GUID Globally Unique Identifier

¹ CLSID COM coclass Identifier

! IDL Interface Definition Language

! ODL Object Description Language

BSTR A length prefixed, UNICODE (doublewide byte) string.

OCX OLE Control (ActiveX Control)

LCID Local. Identifier

ATL ActiveX Template Library coclass COM implementation class

PROGID Programmatic Identifier. A string that maps to a CLSID.

Apartment An execution context for COM objects. Refer to Microsoft Knowledge base article Q 150777 for more information on COM threading models.

> Object Model

Tag Dictionary COM Object Model.

ITagDictionary

_[SpecifyTagAttπbutes

ITagDictionary Delta (Optional)

-Unknown

ITagDefinition

Tag Definition Object

ITagType

rUnknown

IDotField Dot Field Object

ΛΛ Architecture

The following diagrams describe the rsiationsmp between tne components ot the too_lkit and the client ....plications.

Tag Toolkit Package Overview

CliβntPackaςe TagOictionary -^ ManaςβrPackace

-V -

TagOictionary Package

Tag Toolkit Overview

The CUentPackage represents the client application, such as Wonderwara's InTouch. InBatch, InContrσl. or other utility. T e CUentPackage will use the services of the TagDictionary Manager Package to select a particular tag dictionary and bind it to a tag source. The TagDictionary Manager Package also provides the services to initialize and invoke the Tag Browser. The initialization process is as follows:

1. The Client invokes the default Tag Dictionary binding it to the application's default tag source.

2. The Client invokes the Tag Browser (via the Tag Dictionary Manager Package) passing it default Tag dictionary and bound tag source and list of access names.

3. The user can pick tags and select other Tag Dictionary and associated tag sources via Tag Browser interface.

ΛZ Generic Tag Dictionary components

The Tag Dictionary implementation

"his diagram illustrates t e ocβratioπs and 3ata ^Λcw of :nβ Tag 3rowsβr Also note mat only ore ^"-<_ Source can oβ viewed Dy the orowsβr at a time

Λ3 How to Develop a Tag Provider

description

^"P . ^• oik.t orovides the capabilities to create a template Tag Provider A Tag Provider consists of r-vo ^ιou-.-s .-.. Ti Dictionary fan '.-.-process server COM object) and :he Tag Dictionary^'s DataSource ActiveX control Data Source Control). These components are split up like this to separate the user nter ace functionality (the ActiveX control) from the non-user interface model (the tag dictionary) The -ag dictionary manager instantiates the ActiveX control to allow the user to locate the tag data source associated with the custom dictionary Note that the developer is only responsible to create :he control. register it. and provide the CLSID (via a method on the custom tag dictionary) so that the dictionary manager may instantiate the conσol wiihm the context of the manager user interface. The developer is free to establish any proprietary communications (if required) between the custom tag dictionary and the custom ActiveX conσol.

Each tag dictionary must implement the ITagDictionary:. GetDataSourceControClsid method that returns the CLSID of an ActiveX Conσol. This conσol must be capable of providing a user interface that allows selection of a data source ^"or the tag dictionary. This conσol can be implemented in C. C-* , Visual Basic. or any other language that supports COM interfaces. There are only a few requirements for implementing this conσol:

The control must be 260-dialog units wide by 160-dialog units high (or 5850 x 3900 twips) assuming MS Sans Serif 3 point font

A required read/write property named " DataSource" of type BSTR. This property will be used to initialize the conσols data source upon instantiation. The control container will use the optional DataSourceValidation (see below) method to determine if the DataSource property is valid. And f the property is valid, will read the property (and persist it).

An optional method named" DataSource Validation" with the following signature:

O D L sy ntax: boolean DataSource Valiaatιon(faut]lon% * ph Wnd. [out] boolean * p Bis Edit)

IDL syntax: HRESULT DataSourceValidatιon((out]Iong* phWnd, [out)VA JANT_BOOL* pBIsEdit. (ou erval) VA -ANT.BOOL* pbFtesult);

Where the return value is VARIANTJTR.UE if the DataSource property is valid. V ARIANT_FALSE otherwise. The phWnd (if non-NULL) indicates a valid HWND so that the conσol container may set focus and the boolean pβlsEdit indicates if this HWND is an EDIT control. If it is an EDIT control, the conσol container will set the selection property after setting focus. If this method is not provided by the conσol. the control container assumes that the conσσl is always valid. If the validation fails, then the conσol has two options for allowing notification of the validation failure to be presented to the user. Either the control displays a message box or the control provides an optional read-only BSTR property called LastErrorDescrφuon (It is suggested that the control use the latter method).

Optional read-only property named " LastErrorDescrφuon ' of type BSTR. The control container. to determine the description of the validation failure (see DataSourceValidation), will query this property. This string should be a complete description of the reason for validation failure.

Optional read-write property named "LocallD" of type long. This optional property will be used by the control container to specify the local idennfier (LCID). The local identifier may affect the presentation of the conσol and the optional read-only LastErrorDescrtpuon property. REFERENCE GUIDE

Enumerations and Structures

WWImageTypβ enum

-¹. re-let i"!- 'agv ΛVTmageT pe l CπPE SMALL =^■ 16.

[UGπPE lG =^■ 32

( VTmageTvpe-

Description

Used in the ITagDictionary:. Get.mageList method.

Elements

IMGTΎPE_SMALL

Request small images

IMGTYPE_BIG

Request large (or normal) size images

WWFilterEIement structure typedef struct tag WWFilterEIement

{

DWORD L'mquelD; POLESTR pF terString;

OLECHAR XfuiuChαr,

OLECHAR S gteCkαr, boolean bCαseSensitrvr,

OLECHAR Placeholder,

DWORD Reserved } WWFilterEIement;

Description

Used in the ITagDictionaryDelta::GetChangedIDs. ITagDictιonaryDelta.:GetNewlDs, ITagDictιonary::GetTagIOs, and ITagDefιnmon:.GetMemberTagIDs methods.

Members

L'mquelD The unique attribute identifier pFtlterStrtng The filter stnng for this UmquelD ultiChar The wildcard character used to specify multiple characters

StngleChar The wildcard character used to specify a single character bCaseSensittve Determines whether the given filter cπteπa should be case sensitive. TRUE - * case sensitive. FALSE otherwise P' cer.oiMr Determines wmch cnaracter within the WWTilterSpecification s express.oπ -no. be replaced by the ooolean value associated with this acσtbute and filter sσiπg This field is reserved tor '-mplementation details

WWResetDelta enum

^■ypeiet enum tag WWResetDelta

RESET EW IDS ^« RΣSET DELETED IDS. R£SET~_ LLJDS WWReset elta

Description

Used in the ITagDictionary Delta: ResetDelta method.

Elements

emove a new from the collection

R£SET_CHΛNGEDJDS

Remove all changed IDs from the collection

RESET _^DELETED JDS

Remove all deleted IDs from the collection

RESET LLJDS

Remove all IDs from all of the delta collections (similar to calling ResetDelta three tunes with each of the enum values listed above).

WWFi.terSpecification structure cypedef struct tagWWFilterSpeeification

LPOLESTR pExpresstonr, DWORD Counc,

WWFilterEIement* pFilterElemena } WWFilterSpecificaαoα

Description

Used in the ITagDictionary: :GetTagIDs, ITagDictιonaryDelta.:GetChangedID«, lTagDιc..onaryDelta::GetNewlDs, and lTagDefιnιtιon::GetMemberTagIDs methods.

Members pExpression A boolean expression that descnbes the subset of IDs to be retrieved. It consists of the operators { & 1 ! ( ) } and the characters { A .. Z a .. z }. For ease of integration with the browser tt is highly recommended that master filters be resσicted to { A Z

Λ6 ; Each character is replaced with trie oooleaΛ v lue genera_ted by the WWFilterEIement associated with it and then tne whole expression is evaluate to determine whether or not tne ID is to oe included. : nt The number of W^'WFilterElements pointed to oy pFiiterElements

:F:!ter£!ements A pointer to an array of Count many WWFilterEIement objects

WWAttπbutelD enum typedef enum tagWWAππbutelD

A TTRIBID FULLYQL'ALIFIED NAME -1 TRJBID HIER. RCHICAL_SΑME. A TTRIBID TYPE. -I TTRJBID COMMENT. ATTRIBID ALARM GROUP. A TTRIBID DDE_ACCESS SAME. A TTRIBID LOGGED, ATTRIBID NESTED. A TTRIBID EXPANDABLE. A ΠRIBID UDT INSTANCE. A TTRIBID ΛAX ) WWAttπbuteΪD

Description

May be used with the (Specify TagAimbutes::GetAttributes method (or any other method or structure that requires an atσibute ID).

Elements

•l TTRIBID ULL YQUALIFIED ΛME

The fully qualified name attribute. This is a required attribute and is represented by a LPOLESTR value.

This attribute will have a display string.

A TTRJBID JilERARCHlCALJIΛStE

The hierarchical name attnbute. This is a required attnbute and is represented by a LPOLESTR value. If no hierarchical name is available for the given attnbute. then this ID should be mapped to

ATTRIBID J ULLYQUALlFlEDJiAME. This attnbute will have a display string.

ATTRIBID ΥPE

Optional attribute ID for type. Its value is an LPOLESTR if this attribute is implemented. This attnbute will have a display string.

ATTRIBID _^COMMENT

Optional attribute ID for comments. Its value is an LPOLESTR if this attnbute is implemented. This attnbute will have a display string.

.-I πRlBlD LΛRM GROUP

Optional attnbute ID for alarm group. Its value is an LPOLESTR if this attnbute is implemented. This attnbute will have a display string.

λlr . ΓTPJBID βoε_ A cczss_^ v.-i ME

Optional armbute ID for DDE access name. Its value is an LPOLESTR it this attribute is implemented This armbute will have a display sσing.

. ΪTRJ31D JOGGED

Crt'.onal a nbute ID for the logged command. Its value is an LPOLESTR that represents a 3oolean (" J -r O "I . t this armbute is implemented. This aππoute does not have a display sσwg.

A TTRIBID - ESTED

Required armbute ID for the nested command. Its value is an LPOLESTR that represents a Boolean r 1 ^' or O^") if this aππbute is implemented. This attnbute does not have a display sσing.

. TTRJBID J XPANDA BLE

Required atσibute ID for the expandable command. Its value is an LPOLESTR that represents a Boolean (" l " or "0") if this armbute is implemented. This attnbute does not have a display string.

A TTRJBID J DTJ STΛ CE

Required armbute ID for a super tag., tts value is an LPOLESTR that represents a Boolean ("I" or "0") if this armbute is implemented. This attnbute does not have a display string.

AπRJBlDJyfAX

Represents the number of valid standard IDs. This is not a valid armbute identifier.

WWExtende Attributβ structure r> pedef struct tagWWExtendedAttnbutβ i

LPOLESTR pAitrtbute OU- QRD mquelD

} WW SxiendedAftnbutrf;

Description

Used in the (Specify TagAttributes::GetAπnbutes method.

Members pAttribute tf non-NULL represents attribute display string. If no display string is available, then this element will be NULL untquelD The unique attribute identifiers.

% ITagDictionaryManager Interface

Defined m. TaglDL h (TaglDL IDL)

Description

Pπ -ies a method to retrieve an array of all tag dictionaries present on the local machine. Based On I Unknown

When to Implement

When to Use

When you wish to enumerate all of the tag dictionanes that have been msulled on the local machme.

Methods in Vtablβ Order

Query Interface Standard .Unknown method

AddRef Standard .Unknown method

Release Standard (Unknown method

GetDictionaryNames Retneves an array of strings. The strings are formatted as a sσingized GUID and a displayable dictionary name.

ITagDictionaryManager:: GetDictionaryNames Method

HRESVLT GetDictionaryNames (LPOLESTR* ^• dicttonαιγNαmes[ ], long' pCount )

Description

Retneves an array of strings. Each stnng has the following format:

" { XXΛXXXX-XΛXX-XXXX-XXXX-XXXXXXXXXXXX} YYYYYYYY'

Where the {xxxx...xxx} represents the CLSID of the tag dictionary coclass in Win32 registry standard form, and YYYYYYYY represents the display name of the tag dictionary. You are guaranteed that the GUID portion of the string is exactly 38 characters long.

Parameters

DicttonαryNαmβs [out] upon success, the callee allocated array of strings

Pcount [out) a pointer to long what will hold the element count (of strings in the array). This value may be zero, indicating no strings were returned

fl Return Values

S OK Returned one or more srr-πgs ( 'pCj nt > 0) S r LSE No array elements were returned. 'pCj nt ^» 0

Ξ^'OUTOFMEMORY Unable to allocate memory for returned aπay of sσings

E^~F λlL Indicates an exception. Additional descriptive information can be obtained by iccessing the COM error object if available (see ISupportErrorlnt^'o and Error

Objects;

Notes to Callers

Each sσing in the array is allocated within the dictionary via CoTaskMemAlloc (or IMalloc: Alloc). It is the responsibility of the caller to deallocate this memory us g CoTasmMemFree (or IMalloc: Free)

The outbound array is allocated with the dictionary via CoTaskMemAlloc (or IMalloc::Alloc.. It is the responsibility of the caller to deallocate this memory usmg CoTaskMemFree (or IMalloc:. Free). Refer to the following examples.

Notes to Implβmenters

Examples

Caller long count ■ 0;

LPOLESTR' pStr - 0;

HRESULT hr ■ pTagDictionaryManager->GetDictionaryNames(&pSff,<--count); for (long i * 0 : i<count; i*-)

' operate on the returned string CoTaskMemFree(pSσ(i]);

} CoTaskMemFree(pS«r);

Implememor. const count - m -ictionaryNames.GetSizeO; if (count)

{ ^•pCount - count; alloc up the array of string pointers LPOLESTR' pStrs - 'pArray * static _cast<LPOLESTR.'>< CoTaskMemAlloc( count ^• sizeofϊLPOLESTR) ) ); for (int i«0 ; i<count ; i-t )

{ pScrs(i] - ToWideSσ::NewStr(m_dictιonaryNames(i]);

to ITagBrowserOlg Interface

Defined m: TaglDL h (TaglDL.IDL)

Description

This 5 :..e ;rmary ntertace of the browser user interface. The implementation of the Tag Browser provides the mecnanism of tag selection from all Tag Dictionaries supportmg the ITagDictionary 'ntertace. It provides methods to initialize the dialog by providing a filename, array of access names, and a primary filter

There is also a method to display the browser dialog along with parameters to allow customization of the user interface.

Based On: (Unknown

When to Implement

No need to implement. Implementation already provided withm InTouch.

When to Use

Use this interface to perform tag selection UI from InTouch.

Methods in Vtable Order

Query Interface Standard [Unknown method AddRef Standard [Unknown method

Release Standard (Unknown method Init Initializes the browser by giving an ITagDictionary interface pomter and a base filter specification. Tag Browser may cache tags at this pomt.

SetAccessNames Initialize the dialog with an array of access name strings DoTagPickerUl Invoke the dialog, hand it more initialization, and returns values

ITagBrowserOlg::init Method

HRESULT Init (ITagDictionary' pTαgDicuonαry. WWFilterSpecificatton' pFilter)

Description

Initializes the browser by giving an ITagDictionary interface pomter and a base filter specification. Tags may be cached into the tag browser at this pomt, so this may be an expensive call for larger tag dictionanes.

Parameters pTαgDictionαry [in] The primary interface pomter to a Tag Dictionary object The caller is responsible for instantiating a COM object that supports this interface, pFilter [in] The client may specify an array of attnbute filter pairs with associated wildcard characters that will act as a base filter for displaying tags. Tag selection will be limited to those tags matching the filter specification descnbed by pFilter. This argument may be NULL indicating no base filter should be applied.

tA Return Values

S OK Initialization successrullv completed

E ^"UNEXPECTED Initialization tailed

Ξ F AIL Indicates an exception Additional descπocive nformatton can be obtained by accessing the COM error obiect if avanaole ι see ISupportEσorlnfo and Eσor

Objects)

Notes to Callers

The Init method is used to set the set of tags that will be used by the browser To facilitate faster displav time when DoTagPickerUI is called, tags may be loaded mto memory at time of the call to Init Be aware that this can be a very time consummg operation (10 seconds ' 32k tags for InTouch). and mav use a significant amount of memory 06MB / 32k tags for InTouch) so this method should only be called -.hen necessary (tag browser will eventually be displayed).

Notes to Implementers

N/A

Examples

The followmg example will initialize the tag browser with a base filter that will only mclude tags stanmg with the 'S" character.

ITagDictionary * pDictionary; ITagBrowserOig • pDlg; fcreace dialog and dicczoπary, open dictionary)

vwFιlterSpecι-.ιcacιon CilterSpβc; wWFileerElement filter; filter. UruquβlD • ATTRiaiD_HIERARCHICAI._NAM-t; fliter.pF ltβrStnng - L"$*"; liter. MultiChar « ' * ' ; filter. SinglβChar • '-',- filter bCaiβSβnsitive - false; filter. Placeholder - 'A' ; filtβrSpβcpExprβasion. > -."&"; filtβrSpβc. Count • I; filtβrSpβc.pFlltβrElβmβncs ■ ..filter;

HREStJLT hr ■ p01g->Imt (pDict, s-JilterSpβc) ;

ITagBrowserOig:: SetAecessNames Method

HRESULT SetAecessNames (long count, LPOLESTR αccessNαmes{ ] )

Descnption

lλ λ IO S :.".e nent of the browser dialog Ό specify an array of access name s_trings. It is jected aι :r..s method snould be called pπor to call g DoTagP'ckerL I.

^Bar₃meters

- :unt [in] Number access name strings held m the array ccess [in] An array of access name s mgs

Return Values

S OK Upon successful completion.

E UNEXPECTED^{^} Failure to initialize the access name array.

E~FA1L Indicates an exception. Additional descriptive information can be obtained by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

The access names provided with this call will be used to identify tag sources when the user creates them from withm the tag browser. If no access names are supplied, the user is not allowed to create tag sources.

Notes to Implβmβntβrs

Examples

The followmg example with set two access names, "Access I" and "Access2":

LPOLESTR accβssNamβs[2] ;

3STR accβsa.1 « SysAllocStrmg ^"Access-." ) ;

3STR access2 • SysAllocStrιng(L"Accβss2") ; accessNamβs.O] • accβssl; accessNamβs.l] * access..

HRESU T hr • pDlg->SβCAccβssNamβs (2,accessNamβs) ;

SysFreβStrmg (accβssl) ;

SysFreeScrιng(access2) ;

ITagBrowserOlg::DoTagPickerUI Method

HRESULT DoTagPickerUI (ITagDefinition" ppSelectedTag, IDotField" ppSelectedDotField, LPOLESTR* pSelectedTagAccessName, LPCOLESTR mttiaiAccessNa e, LPCOLESTR imttaiTagName, LPCOLESTR imuaiDotFieid, boolean bAUowDicttonarySelecuon, boolean bAllowDoiFietdSelecttom, boolean bAllowExpandableTagSelection, boolean bAllowTreeNavtganon, boolean bAllowNoneTagSelection, LPCOLESTR title. HWND parentHWND)

Descnption

Invokes the tag browser user interface dialog and provides output.

Parameters ppSelectedTag [out] interface pointer to the selected tag

^<Z3 :sSe_ιec.eaDotF eld [out) interface pointer to the selected dot field Selec:eaTjgAccess^,Vame [out| name sσ g of '.he selected access name

.n_tr.al.Access ame [&\ used :o .nitianze the dialog oo (to select ,nιtιal access name i

"1/ld.f gJJ'"* [m| used to initialize the dialog box i to select .nitial tag namei inaiDotF-eld [in] used to initialize the dialog box (to select ,nιtιal dot field)

: Ailo DιciionarySelectιon [in] TRUE to enaole Tag Dictionary selection UI. FALSE otherwise

_? A!! s_*. DotF:eijSelecttoιn (in I TRUE to enable dot field selection UI. FALSE otherwise

_T All_ύss .-.s nj ce ^S cuo [in] TRUE to allow selection of expandable tags (tags with cnildren)

? Allow re *_' \ . :o [in] TRUE to allow user to navigate tree.

^•> AllosvNoneTjgSetection [in] TRUE to allow user to select <none> tag. title [m) title string for the dialog box (optional and may be NULL) parent H WD [in] parent HW D (option and may be NULL, if NULL then oarent indow should be the desktop)

Return Values

S OK Upon successful completion. S FALSE The user has press cancel, and all return values are NULL -€ POINTER Upon detection of an invalid parameter (pomter) E UNEXPECTED Failure to invoke the picker user interface E FAIL Indicates an exception. Additional descriptive information can be obtained by accessmg the COM error object if available (see ISuppoπErrorlnfo and Error

Objects)

Notes to Callers

The mput parameters may be NULL except if the imtialDotF e is non-NULL. then the imtialTagName must be non-NULL.

If the user has canceled the dialog, then the returned interface pointers (ppSelectedTag, ppSelectedDotField) and selected tag access name (pSeleciedTagAccessName) could be NULL and still return a success code (S_FALSE).

Notes to Impiementers

Examples

The followmg is a minimal example of displaying the tag browser dialog:

HRESϋtT τestTag»icJcβr ( iτagBrov.sβrDlg* pDlg)

{

ITagDe inition* pTag « 0 ;

IDotFiβld* pDot « 0;

WCHAR* pACCessNamβ • 0;

HHSSU T hr » pDlg->0oTagPic!«erUI(4pTag

, ipDot

, ipAccessNamβ ,0 ,0 ,0

, true , true

lit -ΞEDED(hr)

P.elaasβAndNull IpTag) ; if (pDoc)

Re eaaβAndNull (pDot) ;

CoTaskMemFrββ (pAccessNamβ)

return hr;

15 ISpecifyTagAttributes Interface

Defined in TiglDL h (T3giDL IDL)

Description

Prov jes a method Ό rerreve an arrav of all tag attributes that a tag dictionary has knowledge of Based On iL - cnown

When to Implement

This is a required interface for the tag dictionary COM object.

When to Use

Methods in Vtable Or- βr

Query Interface Standard [Unknown method AddRef Standard (Unknown method Release Standard (Unknown method GetAttπbutes Retrieves an array of structures provides the set of attributes (by unique identifiers and, if appropriate, display strings).

SetLCID Allows setting the local identifier and. optionally, retrieve the old local identifiers for a tag dictionary. GetLCID Retneves the currently installed local identifier for the tag dictionary.

ISpβc.fyTagAttrib-utβa::GetAttr.butβs Method

HRESULT GetAttπbutes (WWExtendedArtπbutes" pArr y, DWORD* pCount)

Oescnption

Retneves the entire set of attnbutes understood by the tag dictionary.

Parameters pArrαy [out] upon success, will return a callee allocated array of structures. Refer to

WWExteodedAπnbutes pCount [out] the number of string elements (this value might be zero)

Return Values

S OK Indicates success (with at one or more returned stnicts, ι.e.. 'pCount > 0).

S FALSE Indicates success (with no returned structs, i.e., 'pCount — 0)

E UNEXPECTED A data source m not open. You must first call the Open method.

E FAIL Indicates an exception. Additional descπptive informanon can be obtained by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

E OUTOFMEMORY Implementation cannot allocate enough memory for the array of strings.

IG Notes to Callers

The attnbute scructs obtained from this method represent the set ot^" filterable values.

Each .tπng tn the array is allocated withm the dictionary ia CoTaskMemAlloc (or IMalloc: Alloc). It ,s τ.e responsibility of the caller to deallocate :nιs memory usmg CoTasmMemFree (or IMalloc..Free).

The outbound array is allocated withm the dictionary via CoTaskMemAlloc (or IMallo Alloc). It is the -espoπs.omr of the caller to deallocate this memory using CoTaskMemFree (or IMalloc: Free). Refer to :he oll w m examples.

Notes to Implementers

The InTouch Tag Dictionary currently implements the followmg access names:

Fully Qualified Name''

"Hierarchical Name" >pe"

'Comment"

Alarm Group"

'DDE Access Name"

The first two attnbutes are required. It is suggested (but not required) that you provide the rest of these displayable attnbutes.

In addition to these displayable attnbutes, there are some non-displayable attnbutes:

• LOGGED

• NESTED

• EXPANDABLE

These non-displayable attnbutes represent Boolean values. T e value strings associated with these are " I" for true and "0" for false. The NESTED and EXPANDABLE attnbutes are required. The LOGGED attnbute is optional.

Tag Dictionary implemepters may add additional attnbutes, but the existing filtering mechanism will not provide a means to filter them.

Examples

ISpβcifyTagAttributβ*::SetLCID Method

HRESULT SetLCID (LCID locallD, LCID* pOldlocallD)

Description

Allows the caller to specify a new local identifier so that returned display strings from the tag dictionary (via lTagDefinition::GetAttnbuteValue and the GetAttnbutes methods) will return localized strings. The default local ID is US English (LCID — 0x409).

Parameters locallD [in] specifies a new local identifier. pOldlocallD [out] the previous local identifier. This parameter is optional and may be NULL

Vt Return Values

5_OK Indicates success i the new local has oeen accepted)

5~F λL5E indicates failure to accept (tne tag dictionary Joes not juoport this local d)

=^"r L Indicates an exception. Additional descriptive information can be obtained a accessing the COM error object if available ⁽see ISupportErrorlnfo and Error

Objects)

Notes to Callers

Notes to Implementβrs Ml string resources must be convened to the local specified if S_OK is returned.

Examples

ISpecifyTagAttr.butββ::GetLCID Method

HRESULT GetLCID (LCID" plocallD)

Description

Allows the caller to retneve the currently msulled local identifer. The default local is US English (LCID

=- 0x409).

Parameters plocallD [out] the currently installed LCID for the tag dictionary

Return Values S OK Indicates success (the new local has been accepted).

E~ POINTER Invalid pomter parameter. E FAIL Indicates an exception. Additional descriptive information can be obtained by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers Notes to Implβmβntβrs

Examples

ITagDictionary Interface

Defined in: TaglDL.h (TaglDL.IDL) Description

This .s the default tag dictionary interface Λll -ag dictionares τιust support this, though thev mav -ler- e Tcm :nιs 'nterface m support of custom metnods

3ased On ⁽Unknown

When to Implement

This is a required interface for all tag dictionaries.

When to Use

Methods in Vtable Order

Query Interface Standard [Unknown method AddRef Standard (Unknown method Release Standard lUnknown method Open Initializes the dictionary COM object by giving it a data source stnng

Close Requests that the dictionary close connections to its data source GetDisplayName Called by a UI component to get a stnng that will be displayed to the user of this tag dictionary implementation.

GetDataSourceConrrolClsid Called by a UI component to get the CLSID of an ActiveX control that can be used to find one of the dictionary's dau sources. GetlmageList Called by a UI component to retneve an ImageList conσol. This image list should comain bitmaps or icons that will be displayed to the user. These images are used for the dictionary object itself and all of the tags that this dictionary implementation supports.

Getlmagelndex Called by the UI component to retneve the default index (mto the

ImageList, see GetlmageList method), and the optional selected dex for the bitmap or icon for this dictionary implementation. To find the image index for a tag, refer to ITagType: .Getlmagelndex.

GetTagFromID Given a unique tag identifier, will answer with an ITagDef tion pomter.

GetTagT>peEnum Supplies a pomter to an enumerator that can enumerate the dictionary tag types

GetTaglDs Retneves an array of unique ug identifiers. The returned set of identifiers may be effected by the filter parameter.

ITagDictionary..Open Method

HRESULT Open (LPCOLESTR pDataSource)

Description

Initializes the dictionary COM object by giving it a dau source stnng

Parameters p DataSource [in] a NULL termmated Unicode character stnng specifymg the location of the dictionary's dau source. The format and/or structure of this stnng may be unique for each dictionary implementation

v\ Return Values s OK Indicates success.

E^" UN EXPECTED A dau source is already open, you must first call Close. E^'FAIL Indicates failure to locate or open the dau source. Additional descriptive ntormation can be obtamed by accessmg the COM error object if available ι see

ISupportErrorlnfo and Error Objects)

Notes to Callers-.

This method must be called prior to calling the following methods: GetTagFromlD. GetTagT peEnum. GetAtrrtbutes. ITagDictionaryDeltaiGetChangedTags. ITagDictionary Delu:GetNe Tags. ITagDictionary Delu:GeιDeletedTags. and GetTagiDs .

Notes to Implementers

Examples

STDMETHODIMP CTD::Open( LPCOLESTR name)

{

AFX_MANAGE_STATT_( AfxGetSttticModuleSute() )

USES_CONVERSION; if(m hFile !- INVALID HANDLE VALUE) ^", return E JNEXPECTED; ^" hFile - CreateF ile 2T(name), GENERIC READ.

0.0.OPEN_ALWAYS.FILE_ATTRIBUTE.NORMAL.0); return (m JiFile — INVALID_HANDLE_VALUΕ) ? E_FAIL : S_OK;

ITagDictionary.:Clo«e Method

HRESULT Close O

Description

Request that the tag dictionary close the connection to its dau source.

Parameters None

Return Values

S_OK Indicates success.

S_FALSE Indicates that there is no opened dau source

10 ^:AlL Indicates an exception Additional descriptive informa_tion can 3β obtained . accessmg the COM error object if available (see ISupportErrorlnfo and Error Objects)

Notes to Callers Notes to implementers

Examples

STDMETHODIMP CTD:: Close ()

{

AFX_MANAGE_STATE( AfxGetSuticModuleStateQ ) if (m_hFile !- (NVALID.HANDLEJVALUE) return S_FALSE;

CloseHandle(m_hFile); m iFilβ - INVALID_HANDLE "VALUE; retum S OK;

ITagOictlonaryv.GetOisplayName Method

HRESULT GetDisplayName (LPOLESTR* pp Display Name)

Description

User mterface clients will call this to obtain a string that is descriptive of this ug dictionary COM object.

This string is displayed to the user.

Parameters ppDisplayNamø [out] address of a valid LPOLESTR to retrieve the display name for this ug dictionary. This name will be shown to the user.

Return Values s oκ Indicates success.

E POINTER Invalid pointer parameter

E OUTOFMEMORY The dictionary is unable to allocate memory for the display string

E FAIL Indicates an exception. Additional descriptive information can be obuined by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

%\ Notes to Caiiers

The dictionary, via the shared memory allocator CoTasm.MemAiloc l or IMalloc Alloc). allocates --rie .rr.ng. It is the responsibility of the caller to ceailocate this memory using CoTask.MemFree ior ;Maιloc. Free ).

Notes to implementers

Examples

Caller:

LPOLESTR pname ^» 0:

HRESULT hr ^» pTagDictionary- GetDispalyName( &pname );

.f (SUCCEEDED{hr))

{ use the name here

CoTaskMemFree(pname); / make sure to free the memory }

Implementor

STDMETHODIMP CTD:: GetDispalyName ( LPOLESTR* ppName)

{

AFX_MANAGE_STATE( A-xGetSuticModuleSuieO ) if( 'ppName ) return E_POINTER; allocate memory for output string ^•ppName - static cast<LPOLESTR>( CoTaskMemAlloc(

(wcslen(m_pName) f I) ^• sizeofTWCHAR) ) ); if ( ! "ppName ) return E.OUTOFMEMORY; wcscpy( 'ppName, m_pName); retum S OK; >

ITagDictlonary::GetOataSourceControlCisid Method

HRESULT GetDat SourceControlClsid(GUID^• pClsid)

Description

User interface clients will request the dictionary's UI component through this method. The dictionary will provide the CLSID of an ActiveX control that knows how to find one of the dictionary's dau sources. Refer to the topic " Writing a Dictionary ActiveX Control " for more details. Parameters pClsid (out] a valid pomter to a CLSID

Return Values

5_CK Indicates success.

E P f T Invalid pomter parameter

E _FλlL Indicates an exception Additional descriptive information can oe obuined by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

Use the provided CLSID to mstantiate the dictionary^'s UI control to allow the user to navigate to one of the dictionary^'s data sources.

Notes to Implβmeπtβrs

You may use the OLE library API CLSIDFromProglD to convert a PROGID to CLSID if you wish, but do not return the HRESULT of this API call. Only return the HRESULTs defined above.

Examples

Two methods are presented. One uses a PROGID and the other uses the CLSID:

STDMETHODIMP CTD:: GetDataSourceControlClsid(GUID^« pClsid)

{

AFX_MANAGE_STATE( A-xGetSuticModuleSute<) )

USES^CONVERSION; ιf( l pClsιd ) retum E_PO[NTER;

^•pClsid - CLSID_NULL; //init outbound param

CString str. sff.LoadStnng(IDS_CONTROL.PROGID);

HRESULT hr - CLSlDFromProgID< T2W(str) . pClsid); return SUCCEEDED(hr) ? S OK : E FAIL; )

STDMETHODIMP CTD:: GetDauSourceControlCIsiα GUID'* pClsid)

{

AFX_MANAGE_STATE( AfxGetSuneModuleStateO ) if ( . pClsid ) return E_POtNTER;

^•pClsid » CLSID_MySpecιalControl; return S OK;

y>> ITagOictionary::Getimageϋst Method

HRESULT GetlmageList (W lmageType

[Scream* oStream)

Description

Lser interface clients will call this method to obu an IMAGELIST control from the tag dictionary ooiect This IMAGELIST will conuin bitmaps or icons that can be used to display to the user

Parameters [in] requested image sue.

[in) caller supplied ISσeam pomter (used to stream the IMAGELIST conσol)

Return Values

S OK Indicates success (returns the specified image size). S FALSE Indicates success (returns the default image s e. not the one requested)

E POΓNTER Invalid pomter parameter

E FAIL Indicates an exception. Additional descriptive information can be obtamed by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

You are responsible to creating an (Stream. This may be done m-memory (see the examples below). Be sure to use [Stream:. Seelk to reset the stream pomter to the beginning of the stream pnor to reading it's output (via lmageLιst_Read). Ownership of this stream mterface is not given to the ug dictionary by this call.

Notes to Implemented

You may use the IMAGELIST common control macros to create and manage the IMAGELIST via calls to !mageLιst_LoadBιtmap<) or ImageList_Create<). If usmg ImageLιst_LoadBιtmap, then you must specify the color used to mdicate transparency. Use lmageLιst_Wπte to stream out the results to the caller. You are free to destroy the IMAGELIST control after the call to lmageLιst_Wπte.

Examples

Caller

[Stream* pStream • 0;

HRESULT hr » CreateStreamOnHGIobal(O.TRUE,«S-pStream); if lSUCCEEDEDOir)) hr - pTagDictionary->GetImageList(IMGTYPE_SMALL.pStream); if(SUCCEEDEDfhr))

{

"make sure to seek the stream to the beginning LARGE INTEGER Lint;

m ZeroMemory<_<S.L.nt.5izeo., L.nt)); pStream->Seek(Lu.t.0.0);

HIMAGELIST hlmg = [mageLιst_Read(pStream); now you can attach the imagelist to ClmageList....

! pStream->Release(); I tmplementor.

STDMETHODIMP CTD:: GetlmageList (WWImageType LmgType, IScream* pStream)

{

AFX_MANAGE_STATE( AfxGetSuticModuleSuteO ) if ( ! pStream) retum E_PO INTER;

HIMAGELIST hlmg; if( imgType — IMGTYPE SMALL)

{ ^• hlmg * ImageList LoadBitmap( Module.GetResourcelnstanceO,

MAKEINTRESOURCE(IDB TAGSMALL).

IMGTYPE SMALL,0.RGB(255,255.255));

} else {

{

//similar loading of large images

> . if (hlmg)

{ hr - lmageL.sι_Write(hImg,pStream) ? S_O : E_FAIL;

ImageList Destroy(hlmg);

} return hr.

}

ITagOictionary::Getl agelndex Method

HRESULT Getlmagelndex (long* pDeflmgindx, long* pSellmglndx)

Description

This will allow the caller to find the index into the IMAGELIST control (returned from the call to

GetlmageList) that identifies the imag ) for this tag dictionary.

Parameters -De/Imgtndx [out] the index m^to the IMAGELIST control provided through the GetlmageList

-nethod This is ^the default image for use in the user mtertace for this tag dictionary sSellm lndx [out| the optional selected image index (caller may pass a \LLL)

Return Values

5 OK Indicates success

E POINTER

pDe/lmglndx pomter passed to the method.

E_F AIL Indicates an exception Additional descriptive information can be obtamed by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

Notes to Implementers

Make sure that you test pSellmglndx for NULL prior to use. It is an optional parameter

Examples

STDMETHODIMP CTD Getlmagelndex (long* pDeflmglndx, long* pSellmglndx)

{

AFX_MANAGE_STATE( AfxGetSuticModuleSuteO ) if ( ' pDeflmglndx) retum E_POINTER;

^•pDefrmglndx » 22; '/index for the bitmap representation of this object this param is optional and might be NULL if (pSellmglndx)

•pSellmglndx - I ; retum S OK,

ITagOictJonary::GetTagFromlD Method

HRESULT GetTagFromlD (DWORD id, ITagDefmition* * ppTag)

Descπption

Used to retneve an mterface pomter to an object that implements an ITagDefmition mterface given the tags unique identifier

Parameters id [in] unique ug definition identifier. ppTag [out] upon success will return a ITagDefmition mterface pomter

2>6 Return Values

S OK Indicates success

E~ UNEXPECTED A data source in not open You must first call the Open method

E ^'FλlL Indicates an exception Additional descriptive information can be obtained by accessing the COM error object if available (see ISupportE orlnfo and Error

Objects) ^"WTD_E_T AGID The unique tag identifier is invalid

Notes to Callers

You are responsible for calling Release on the provided ITagDefmtion pointer

Notes to Implementers

Filtering (if any) should not effect this method. Retum any ITagDefmition for a valid ID irrespective of an msulled filter

Examples

Caller

ITagDefmition* pTag ^■ 0;

HRESULT hr » pTagDtctιonary->GetTagFromID( untquelD, <S.pTag); ιf(SUCCEEDED(hr))

{ use the pTag pomter to manipulate the Tag COM object e sure to call Release when done pTag->Release();

Implementor

ITagDictionary..GetTagTypeEnum Method

HRESULT GetTagTypeEnum (IEnumTagTypes** ppEnum)

Description

Parameters ppEnum [out) upon success, will retum a lEnumTagType mterface pomter.

Return Values

S_OK Indicates success.

E~UNEXPECTED A dau source m not open You must first call the Open method.

Vr ^'AIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see [SupportErrorlnfo and Error Objects)

Notes to Callers

The enumerator should be considered a snapshot of the collection. You are responsible for calling Release on the provided I Enum TagType pointer.

Notes to Implementers

Examples

ITagOictionary::GetTaglDs Method

HRESULT GβtTaςlOs(WWFil.βrSpβc.f.cation* pFilter , DWORD" pplDs. DWORD 'pdwCount);

Description

Retrieves the set of unique ug identifiers. The pFilter parameter can limit the resultant set

Parameters pFilter (in] a filter specification used to limit the resulting ug identifiers. pplDs (out) upon success, will retum a callee allocated array of unique ug identifiers. pdwCount [out) the number of ug identifiers.

Return Values s OK Indicates success (with at one or more returned IDs, i.e., 'pCount > 0). S FALSE Indicates success (but no renimed IDs: 'pCount ^» 0)

E UNEXPECTED A dau source is not open. You must first call the Open method. E ΓNVALIDARG Indicates that invalid arguments were used.

E~FAIL Indicates an exception. Additional descriptive information can be obuined by accessing the COM error object if available (see (SupportErrorlnfo and Error

Objects)

E OUTOFMEMORY Implementation cannot allocate enough memory for the array of DWORDs. E POINTER Invalid pointer passed to method

Notes to Callers

The outbound array of DWORDs is allocated within the dictionary via CoTaskMemAlloc (or lMalloc::AUoc). It is the responsibility of the caller to deallocate this memory using CoTaskMemFree.

Notes to Implementers

2 ITagDictionaryDelto Interface

Defined m: TaglDL.h (TaglDL.lDL)

Description

This is an optional tag dictionary interface. Tag dictionaries that wish to provide a client with a means to rrack incremenul changes to tags should implement this mterface.

Based On: lUnknown

When to Implement

When the tag dictionary manages a large collection of ugs then unplementing this mterface allows a client to optimally query the dictionary for delu changes.

When to Use

When any change is made to a ug dictionary ug collection, the client (say, the ug browser) is expected to refresh the entire collection of ugs via a call to ITagDictionary :.GetTagIDs followed by repeated calls to ITagDictionary: :GetTagFromID to query the ug for changed information to display to the user. If the size of the ug collection were large, then it would be more efficient to query only for the delu ug changes by usmg this (ITagDictionaryDelu) interface.

Methods in Vtable Order

Querylnterface Standard (Unknown method

AddRef Standard lUnknown method

Release Standard lUnknown method

ResetDelta Allows the caller to clear out any or all of the delu collections independent of retrieving the collection elements.

GetChangedlDs Retrieves an array of unique ug identifiers that represent ugs that have changed since the last GetTaglDs has been called.

G etNew IDs Retrieves an array of unique ug identifiers that represent tags that have been created since the last GetTaglDs has been called. The filter parameter will effect the returned set of ids.

GetDeletedlDs Retrieves an array of unique ug identifiers that represent ugs that have been deleted since the last GetTaglDs has been called The filter parameter will not effect the returned set of ids.

!TagD.ct-onaryDe.ta::Re»etDβlta Method

HRESULT ResetDelU(WWResetDelU enumReset);

Descπption

Provides a method to allow the caller to clear out any or all of the delu collections without retrieving the collection elements. This is an optional method and my return E_NOTIMPL;

Parameters enumReset [in] specifies which delu collection (or all collections) should be cleared (see w WResetDelu)

Return Values

S OK Indicates success.

E^'NOTIMPL Indicates that this method has not been implemented by the tag dictionary

Notes to Callers

Notes to Implementers

Examples

ITagDictionary Delta: -.GetChangedlDs Method

HRESULT GetChangedlDsdong IFύterCount , WWFilterEIement filten(] ,

WWFilterL gical enumLogical. boolean b Reset, DWORD "pplDs. \on% 'plCaunt)

Descnptton

Retrieves the set of unique ug identifiers that have changed since the last call to GetTaglDs or

GetChangedlDs when called with bReset — TRUE.

Parameters

IFilterCount [in] the number of WWFilterElements in the filter array filters [in] a-rray of filters (see WWFilterEIement) enumLogical [in] if FILTER_LOGICAL_NULL, then no filter is specified and ICount should be 0. if FILTER_LOGICAL_AND then all filter elements are ANDed together for the query. if FILTER_LOGICAL_OR then all filter elements are ORed together for the query. bReset TRUE if the collection is to be cleared, FALSE otherwise pplDs [out] upon success, will retum a callee allocated array of unique tag identifiers. plCount [out) the number of ids. This value might be zero.

Return Values s OK Indicates success (with at one or more returned IDs, i.e., 'pCount > 0). S FALSE Indicates success (with no re imed IDs. i.e., 'pCount ^■• 0)

E ΓNVALIDARG Indicates that invalid arguments were pasted. This will occur if enumLogical is set to FILTER LOGICAL NULL and IFilterCount \i non-zero or if enumLogical is FILTER_LOGICAL_AND or FILTER_LOGICAL_OR and

IFilterCount is zero.

E UNEXPECTED A dau source in not open. You must first call the Open method. E FAIL Indicates an exception. Additional descnpuve information can be obuined by accessmg the COM error object if available (see ISuppottErrorlnfo and Error

Objects)

E OUTOFMEMORY Implementation cannot allocate enough memory for the array of DWORDs. E POINTER Invalid pomter passed to method.

Notes to Callers

CC The outoound array ot D ORDs is allocated wnhin the dictionary via CoTaskMemAlloc ι or

IMalloc: Alloc⁾. I^t is the responsibility of the caller to deallocate this memorv usmg CoTaskMemFree i or

IMalloc. Free).

Notes to Implementers

^'.Vhen the clients call this method, you are then required to "flush" the corresponding collection so that subsequent calls ill not hand out the same IDs if the caller has specified bReset =» TRUE.

Examples

ITagDictionary Delta: .GetNewlDs Method

HRESULT GetNew(Ds(long IFilterCount . WWFilterEIement filters{) , WWFilterLogical enumLogical, boolean bReset, DWORD" pplDs, long 'plCount);

Description

Retneves the set of unique tag identifiers that have been created since the last call to GetTaglDs or GetNewlDs when called with bReset — TRUE. The filters array effects the TaglDs returned by this method.

Parameters

IFilterCount [in] the number of WWFilterElements in the filter array filters [in] array of filters (see WWFilterEIement) enumLogical [in] if FILTER_LOGICAL_NULL, then no filter is specified and IFilterCount should be 0. J if FILTER_LOGICAL_AND then all filter elements are ANDed together for the query. if FILTER_LOGICAL_OR then all filter elements are ORed together for the query. bReset [in] TRUE if the collection is to be cleared. FALSE otherwise pplDs [out] upon success, will return a cailee allocated array of unique ug identifiers. plCount [out] the number of ids.

Return Values

S OK Indicates success (with at one or more returned IDs, i.e., 'pCount > 0). S FALSE Indicates success (with no returned IDs, i.e., 'pCount — 0)

E ΓNVALIDARG Indicates that invalid arguments were pasted. This will occur if enumLogical is set to FILTER LOGICAL NULL and IFilterCount is non-zero or if enumLogical is FILTER_LOGICAL_AND or FILTER.LOGICAL_OR and

IFilterCount is zero.

E U EXPECTED A dau source in not open. You must first call the Open method. E FAIL Indicates an exception. Additional descriptive information can be obuined by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

E OUTOFMEMORY Implementation cannot allocate enough memory for the array of DWORDs. E POINTER Invalid pointer passed to method

Notes to Callers

<λ The outbound array of DWORDs is allocated withm the dictionary via CoTaskMemAlloc (or

IMalloc:: Alloc). It is the responsibility of the caller to deallocate this memory usmg CoTaskMemFree i or iMalloc::Free).

Notes to Implementers

You are responsible to "flush" your collection of IDs so that subsequent calls to this method do not retum the same ID set if the caller has specified bReset ^«■ TRUE.

Examples

ITagDictionary Delta: :GetOeletedTags Method

HRESULT GetDeletedlDs (boolean bReset, DWORD" pplDs, long* pCount);

Description

Retrieves the set of unique ug identifiers that have been deleted since the last call to GetTaglDs or

GetDeletedlDs when called with bReset — TRUE.

Parameters bReset [in] TRUE if the collection is to be cleared. FALSE otherwise pplDs [out] upon success, will return a callee allocated array of unique ug identifiers. pCount [out] the number of ids.

Return Values

S OK Indicates success (with at one or more returned IDs, i.e., 'pCount > 0).

S_FALSE Indicates success (with no returned IDs, i.e., 'pCount — 0)

E UNEXPECTED A data source in not open. You must first call the Open method

E FAIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

E OUTOFMEMORY Implementation cannot allocate enough memory for the array of DWORDs. E~PO INTER Invalid pointer passed to method

Notes to Callers

The renimed tag identifiers are not necessarily filtered (see ITagDictionary Filter). This means that the caller may be returned ug identifiers that may not be allowed by the filter criteria.

The outbound array of DWORDs is allocated within the dictionary via CoTaskMemAlloc (or IMalloc::Alloc). It is the responsibility of the caller to deallocate this memory using CoTaskMemFree.

Notes to Implementers

You are responsible to "flush" your collection of IDs so that subsequent calls to this method do not retum the same ID set if the caller has specified bReset — TRUE.

Examples

m ITagDefmiϋon Interface

Defined in: TagΙDL.h (TagΙDL.IDL)

Description

The primary interface on a tag object. Allows retrieval of attributes (such as the required attributes: hierarchical and the fully qualified name), tag type mterface. unique identifier, and member tags it^" the given tag implementation is a group tag (AKA gang or User Defined Tag).

Based On: [Unknown

When to Implement

When to Use

Methods in Vtable Order

Querylnterface Standard lUnknown method AddRef Standard lUnknown method Release Standard (Unknown method GetMemberTags Retrieves an array of unique identifiers if this ug object is a collection ug.

GetTagType Returns an ITagType interface for this g GetID Renims a unique identifier for this ug (unique within the context of a specific ug dictionary)

GetAttributeValue Returns the value string for a given attribute (see

ITagDictionary: .GetAttrirubes)

ITagDβfinition:: GetMemberTaglDs Method

HRESULT GetMemberTagIDs(WWFtlterSpecification* pFilter , DWORD" pplDs, long* plCount);

Description

Returns a callee allocated array of unique tag identifiers if this ug object is a gang ug (i.e.. has member tags).

Parameters pFilter [in] A filter specification used to limit the set of ug identifiers returned pplDs [out] callee allocated array of DWORD (unique tag identifiers) if retum is S_OK plCount [out] the number of elements in the array (0 if retum is S_FALSE).

Return Values S OK The array of DWORD has been successfully allocated and filled ith it east one entry ( 'pCount > 0)

5 FALSE This tag is not a group tag and has no members (the array is empty and 'pCount

=^» 0)

E INVALIDARG Indicates that invalid arguments were pasted. This will occur if enumLogical is set to FILTER LOGICAL NULL and ICount is non-zero or if enumLogical is

FILTER_LOGTCAL_AND~or FILTER_ OGICAL_OR and ICount is zero

E OUTOFMEMORY The array could not be allocated E^'POINTER An invalid pomter parameter was passed mto the method

E FAIL Indicates an exception. Additional descriptive information can be obuined by accessmg the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

The outbound array of DWORDs is allocated withm the implementation of this method via

CoTaskMemAlloc (or lMalloc::Alloc). It is the responsibility of the caller to deallocate this memory usmg

CoTaskMemFree.

Notes to Implementers

Examples

ITagDefinition:: GetTagType Method

HRESULT GetTagType (ITagType" ppTagType)

Description

Retneves the ITagType interface pointer descπbing the type of this tag.

Parameters ppTagType [out] on success, will retum an interface pointer to ITagType

Return Values s oκ Successful retum of an ITagType interface pointer

E POINTER An invalid pomter parameter was passed mto the method. E FAIL Indicates an exception. Additional descnptive information can be obumed by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

You are responsible for calling Release on the returned interface pointer

Notes to Implementers

M Examples

ITagDefmition:: GβtID Method

HRESULT GetlD (DWORD* pID)

Descnption

Parameters plD [out] on success, will retum a unique identifier for this Tag (unique in the context of this tag dictionary)

Return Value .

S OK Successful retum of a unique ug identifier

E POINTER An invalid pointer parameter was passed into the method

E FAIL Indicates an exception. Additional descriptive information can be obuined by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

Notes to Callers

Notes to Implementers

Examples

ITagDefmition:: GetAttributeValue Method

HRESULT GetAttributeValue (DWORD AttriblD, LPOLESTR* ppAttribValue)

Description

Returns the value string for a given attribute (see ITagDictionary: :GetAttritubes). There are a set of standard attributes (some are optional and some required). Refer to [Specify TagAttributes and the definition of WWExtendedAttribute structure. If the AttriblD is not known or implemented by a particular ug object implementation, then the ppAttribValue pointer should point to a null string ("")•

Parameters

AttriblD [in] the unique attribute identifier (see ISpecify TagAttributes: :GetAttributes) ppAttribValue [out] on success, the value string for the given attribute. If the AttriblD is not known or implemented by this ug object, then an empty string should be renimed ('ppAttribValue *- "")

5 Return Values

S OK Successful retum of a non empty value string S~FAL.SE The AttriblD was not recognized. An empty string is returned. E POΓNTER An invalid pomter parameter was passed into the method. E^'FAIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objects)

E OUTOFMEMORY unable to allocate enough memory for the output stnng

Notes to Callers

You are responsible for deallocating the memory for the returned string (ppAttribValue) using CoTaskMemFree (or lMalloc::free).

Notes to Implementers

Do not retum a NULL pointer for ppAttribValue if the AttriblD is not recognized Instead, retum an empty string.

Examples

lEnumTagTypes Interface

Defined in: TaglDL.h (TagiDL.lDL)

Description

Allows you to enumerate the TagTypes provided by a given Tag Dictionary implemenution.

Based On: lUnknown

When to Implement

When to Use

Methods in Vtable Order

Querylnterface Standard lUnknown method AddRef Standard lUnknown method Release Standard lUnknown method Next Retrieves a specified number of ITagType interfaces in the enumeration sequence.

Skip Skips over a specified number of items in the enumeration sequence.

Reset Resets the enumeration sequence to the beginning

Clone Creates another enumerator that contains the same enumeration

k€ state as the current one.

!EnumTagTypes::Next Method

HRESULT Next (ULONG celt. ITagType" r_?e r, ULONG* pceltFetched)

Description

Retrieves the next celt items in the enumeration sequence. If there are less than the requested number of elements left in the sequence, it returns the remammg elements. The number of elements actually retrieved is returned through pceltFetched (unless the caller passed in NULL).

Parameters celt [in] Number of elements requested rgelt [out] Array of size celt (or larger) of the elements of interest pceltFetched [out] Pointer to the number of elements actually returned in rgelt. Caller may pass

NULL if and only if celt is one.

Return Values s OK Indicates the celt elements have been found and renimed. S.FALSE Indicates the not all celt elemenu have been returned Either the caller determines the number of elements from pceltFetched (if NULL was not passed) or if pceltFetched was set to NULL, then this indicates that no elemenu were renimed.

E FAIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see [SupportErrorlnfo and Error Objects)

Notes to Callers

The caller is responsible for calling Release on all returned ITagType interface pointers.

Note: the SUCCEEDED macro cannot be used to determine if you have reached the end of the enumeration sequence. S_FALSE is a success code!

Notes to Implementers

Be sure to AddRef all ITagType interface pointers handed out by this method call.

Examples

IEnumTagType*::Skip Method

HRESULT Skip (ULONG celt)

Description

Skips over the next specified number of elements in the enumeration sequence.

Parameters celt [in] Number of elements to be skipped

tf- Return Values

S_OK Indicates that celt elements have been skipped.

S _F LSE Indicates that the number of elements skipped is less than celt

E_F ML Indicates an exception. Additional descriptive information can be obumed by accessmg the COM error object if available (see ISupportErrorlnfo and Error Objects)

Notes to Callers

If S_FALSE is retumed. then this mdicates that you have skipped to the end of the enumeration.

Notes to Implementers Examples

IEnumTagTypβs::Rβset Method

HRESULT Reset ()

Descnption

Resets the enumeration sequence to the beginning.

Parameters none

Return Values

S OK The enumeration has been reset

E~FAIL Indicates an exception. Additional descriptive information can be obumed by accessmg the COM error object if available (see ISupportErrorlnfo and Error Objects)

Notes to Callers Notes to Implementers Examples

IEnumTagTypes::Clone Method

HRESULT Clone (IEnumTagTypes** ppEnum)

Descnption Creates another enum-erator that conums the same enumeration state as the current one. The new enumerator supports the same mterface as the original one.

Parameters- ppEnum [out] if successful, an mterface pomter to a new enumerator with the same state as the current one.

Return Values

NOERROR if succeeded in producing the clone

E POINTER if an invalid pomter is passed in as a parameter

E OUTOFMEMORY if unable to allocate enough memory for the clone

E FAIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see ISupportEσorlnfo and Error

Objects)

Notes to Callers

Using this method allows clients to record a cursor (with one enumerator) and continue to iterate through a collection (using another enumerator).

Note that you are responsible for calling Release on the retumed lEnum TagTypes interface pointer.

Notes to Implementers

You are responsible for calling AddRef on the [EnumTagTypes interface pointer you hand out

Examples

t ITagType Interface

Defined in: TaglDL h (TagiDL.IDL)

Description

This is the primary mterface on the Tag Type object. It provides the type name, a means to enumerate the dot fields, and indices into the IMAGELIST control retumed by the [TagDictionary mtertace ( see ITagDictionary:. GetlmageList).

Based On: [Unknown

When to Implement

When to Use

Methods in Vtable Order

Query Interface Standard lUnknown method

AddRef Standard lUnknown method

Release Standard lUnknown method

GetTypeName Retrieves the name string of the type instance

GetDotFieldEnum Retrieves a dot field enumerator allowing the caller to iterate over the dot fields

Getlmagelndex Retrieves the default and optional selected index into the

IMAGELIST control provided by the ITagDictionary interface.

ITagType:: GetTypeName Method

HRESULT GetTypeName (LPOLESTR* name)

Description

Returns the name of the ug type.

Parameters name [out] callee allocated name string

Return Values s oκ Successful return of name string

E OUTOFMEMORY The array could not be allocated E POINTER An invalid pointer parameter was passed into the method E~FAIL Indicates an exception. Additional descriptive information can be obuined by accessmg the COM error object if available (see ISupportEσorlnfo and Error

SO Objects)

Notes to Callers

The name stnng is allocated via the shared memory allocator CoTasm.MemAlloc (or IMalloc. Alloc). It .s :he responsibility of the caller to deallocate this memory using CoTaskMemFree (or IMailoc::Free ).

Notes to Implementers

Examples

ITagType:: GetDotFieldEnum Method

HRESULT GetDotFieldEnum ( lEnumDotFields* ^• ppEnum)

Description

Returns the dot field enumerator interface.

Parameters ppEnum [out] interface pointer to a dot field enumerator.

Return Values s OK Successful retum of enumerator interface pointer

E POINTER An invalid pointer parameter was passed into the method.

E FAIL Indicates an exception. Additional descriptive information can be obuined by accessing the COM error object if available (see (SupportErrorlnfo and Error

Objects)

Notes to Callers

You are responsible for calling Release on the provided lEnumDotFields pointer.

Notes to Implementers

Examples

ITagType:: Getlmagelndex Method

HRESULT Getlmagelndex (long" pDeflmglndx, long* pSellmglndx)

Description trom ^the call :o

Parameters pDefim lndx [out] the index into the '^GELIST control ^^→^ _{use ιn tne} ,_jser ITagDictionary: :GetlmageLιst method. This is the αerauu ⁱn. *

•.menace for this n$ type. .

[ou_t| the optional selected image mdex (may be NULL⁾. pSellmglndx

Return Values

Indicates success. s OK

E^" POINTER E^"FAIL

Objects)

Notes to Callers

Notes to Implementers

Examples

S lEnumDotFields Interface

Defined in: TaglDL.h (TaglDL.IDL)

Description llows you to enumerate the Dot Fields provided by a given Tag Dictionary unplementation or Tag Definition.

Based On: lUnknown

When to Implement When to Use

Methods in Vtable Order

Querylnterface Standard lUnknown method AddRef Standard [Unknown method Release Standard [Unknown method Next Retneves a specified number of IDotField interfaces m the enumeration sequence.

Skip Skips over a specified number of items in the enumeration sequence.

Reset Resets the enumeration sequence to the beginning Clone Creates another enumerator that conums the same enumeration state as the current one.

IEnumDotFields::Next Method

HRESULT Next (ULONG celt, IDotField" rgelt, ULONG* pceltFetched)

Description

Retrieves the next celt items in the enumeration sequence. If there are less than the requested number of elemenu left in the sequence, it returns the remaining elemenu. The number of elements actually retneved is returned through pceltFetched (unless the caller passed in NULL).

Parameters celt [in] Number of elemenu requested rgelt [out] Array of size celt (or larger) of the elements of interest pCeltFetched [out] Pointer to the number of elemenu actually retumed in rgelt. Caller may pass

NULL if and only if celt is one.

Return Values

S OK Indicates the celt elemenu have been found and retumed.

S~F ALSE Indicates the not ail celt elemenu have been returned. Either the caller determines the number of elements from pceltFetched (if NULL was not passed) or if pceltFetched was

s?> -e^t to NULL, then this mdicates that no elements were returned. E_FAIL Indicates an exception. Additional descriptive information can be obtamed by accessing the COM error object if available (see ISuppoπEσorlnfo and Error Objects)

Notes to Callers

The cailer ;s responsible for calling Release on all returned IDotField interface pointers.

Note: the SUCCEEDED macro cannot be used to determine if you have reached the end of the enumeration sequence. S_FALSE is a success code!

Notes to Implementers

Be sure to AddRef all IDotField interface pointers handed out by this method call.

Examples

IEnumDot-Flβlds::Skip Method

HRESULT Skip (ULONG celt)

Description

Skips over the next specified number of elemenu in the enumeration sequence.

Parameters celt [in] Number of elemenu to be skipped

Return Values

S_OK Indicates that celt elemenu have been skipped.

S_F ALSE Indicates that the number of elemenu skipped is less than celt

E_FAIL Indicates an exception. Additional descriptive information can be obtained by accessing the COM error object if available (see ISupportErrorlnfo and Error Objects)

Notes to Callers

If S_FALSE is returned, then this indicates that you have skipped to the end of the enumeration.

Notes to Implementers Examples

IEnumDot ields::Reset Method

HRESULT Reset ()

*<1 Descnption

Resets the enumeration sequence to the beginning

Parameters none

Return Values

S_OK The enumeration has been reset.

E_FAIL Indicates an exception. Additional descriptive information can be obtamed by accessmg the COM error object if available (see ISupportErrorlnfo and Error Objects)

Notes to Callers Notes to Implementers Examples

lEnumDotFields .CIone Method

HRESULT Clone (IEnumDotFields^»* ppEnum)

Descnption

Creates another enumerator that conums the same enumeration state as the current one. The new enumerator supports the same mterface as the oπgmal one.

Parameters ppEnum [out] if successful, an mterface pomter to a new enumerator with the same state as the current one.

Return Values NOERROR if succeeded in producing the clone

E_POΓNTER if an invalid pomter is passed in as a parameter

E OUTOFMEMORY if unable to allocate enough memory for the clone

E FAIL Indicates an exception. Additional descnptive information can be obumed by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objecu)

Notes to Callers

Usmg this method allows clienu to record a cursor (with one enumerator) and continue to iterate through a collection (usmg another enumerator).

Note that you are responsible for calling Release on the retumed lEnumDotFields mterface pomter. Notes to implementers

You « respons_ible for calling AddRef on the lEnumDotFields mterface poⁱn^ter you hand ou^t.

Examples

IDotField Interface

Def_ined : TaglDL.h (TaglDLIDL⁾

Description

Prov_ides the dot field name along with the name ot ⁱts type.

Based On: lUnknown

When to Implement

When to Use

Methods in Vtable Order

Standard (Unknown method

Query Interface

Standard lUnknown method

AddRef Standard lUnknown method

Release Retrieves the name string of the dot field instance

GetName Retrieves the type name.

GetTypeName

IDotField:: GetName Method

HRESULT GetName (LPOLESTR* name)

Description

Returns the name of the dot field.

Parameters name [out] callee aUocated name stnng

Return Values

Successful return of name string s oκ

E~OUTOFMEMORY The array could not be allocated _m„_hrtd

E O INTER E FAIL

Objecu)

Notes to Callers

5 T e name string is allocated via the shared memory allocator CoTasm.MemAlloc (or IMalloc \lloc i It the responsibility of the caller to deallocate this memory using CoTaskMemFree (or IMalloc Free )

Notes to Implementers

Examples

IDotField:: GetTypeName Method

HRESULT GetTypeName (LPOLESTR' name)

Descnption

Returns the name of the dot field type.

Parameters name [out] callee allocated name stnng

Return Values s OK Successful return of name soring

E OUTOFMEMORY The array could not be allocated

E~PO INTER An invalid pointer parameter was passed into the method

E FAIL Indicates an exception. Additional descnptive information can be obuined by accessing the COM error object if available (see ISupportErrorlnfo and Error

Objecα)

Notes to Callers

The name stnng is allocated via the shared memory allocator CoTasmMemAlloc (or IMalloc:: Alloc). It is the responsibility of the caller to deallocate this memory usmg CoTaskMemFree (or IMalloc:: Free ).

5S APPENDIX B

S^<\ *include 'stdafx.h"

•include "TestDlg.-t" •include "TestDlgDlg.h" •include " tester. h" void CTescDlgDlg: :SetupDlgBox()

{

//setup initial value off CLSID or PROGID edit box

//note .-stead of the PROGID, you could enter the CLSID in the following format

// pWnd- >SetWindowText("{3EC11294-ABB4-11D0-9370-030009039144}") ;

CWnd* pWnd - GetDlgItem(IDC_EDIT_PROGIDCLSID) ; p nd->Set ιndo Tβxt ( "Wonderware. InTouc TagDictionary.l") ,• //<-- put your PROGID here

//setup initial value of tag dictionary data source directory pWnd - GetDlgItem(IDC_EDIT_SOURCEDIR) ; pWnd- >SetWmdowText (" .. /ITTagSource") ; //<-- put your source dir here

//setup initial value of persistent file pat.. pWnd ■ GetDlgItem(IDC_EDIT_PERSIST->ATH) ; pWnd->SetWιndowTex (" .. /ITTagSource/persistTes . tmp") ; //<-- put any path to a t p file here

void CTestDlgDlg: :GetDlgBoxData( CLSID& clsid, CStrings, tagdxctSourcβ, CStrmgs. persistF lePath)

{

USES_CONVERSION;

//read the contents of the progid or clsid edit box CStπng tmpID;

CWnd* pWnd - GetDlgItera(IDC_SDIT_PROGIDCI.SID) ; pWnd- >GetWιndo Text (tm ID) ;

//attempt to convert thi* string to CLSID assuming it is a PROGID, //if fails, than assume it is a stnngized CLSID HRESULT hr - CLSIDFromProglD (T2W(tmpID) , ..clsid) if (FAILED(hr))

{

CLSIDFromString(T2W(tmpID) - -.clsid) ;

)

//setup initial value of tag dictionary data source directory pWnd _* GetDlgItem(IDC_EDIT_SOURCEDIR) ; pWnd- >GetWmdo Text (tagdictSource) ;

//setup initial value of persistent file path pWnd =- GetDlgItem(IDC_EDIT_PERSISTPATH) ;

GO pWnd- >GetW ndowText (persistF lePath) ,• } void CTestDlgDlg : :OnButtonTest { )

(

CWaitCursor cursor;

CLSID clsid _* CLSID_MULL;

CString ragdictSource;

CString persistFilePath;

GetDlgBoxData( clsid, tagdictSource, persistFilePath) ;

CWnd* pWnd « GetDlgItem(IDC_EDIT_OUTPUT) ; pWnd- >SetWindowText (TEXT ( "Begining tes ... lease wait ....")); pWnd->UpdateWιndow() ;

{ //NOTE: this really should be spun off to a separate apartment thread (so UI 13 not kept busy)

USES_CONVERSION; strstream sout;

//Start the testing

RunTest (clsid, CLSCTX_INPROC_SERVER,T2W( agdictSource) ,T2 (persistFilePath!, sout) ; sout < ends; pWnd->SetWindowText(A2T(sout.str() ) ) ; sout.rdbuf 0 ->frdezβ(0) ; }

//Request that COM enumerate all InProc servers and call DllCanUnloadNow on each

CoFreeUnusedLibrariesO ;

Gλ •include 'stdafx.h" •include "TestDlg.h" •include "TestDlgDlg.h" •include " ester. " void CTestDlgDlg: :SetupDlgBox()

{

//setup initial value of CLSID or PROGID edit box

//note: instead : the PROGID, you could enter the CLSID in the following format

// pWnd->SetWindθwText(" (3EC11294-AaB4-llDO-9B70-080009C39144}") ;

CWnd* pWnd - GetDlgItem(IDC_EDIT_PROGIDCLSID) ; pWnd->SetWindowText( "Wonderware. InTouchTagDictionary.1") ,- //<-- put your PROGID here

//setup initial value of tag dictionary data source directory pWnd - GetDlgItem(IDC_EDIT_SOURCSDΣR) ; pWnd->SetWindowTex C ../ITTagSource") ; //<-- put your source dir here

//setup initial value of persistent file path pWnd - 3etDlgItem(IDC_EDIT_PERSISTPATH) ; pWnd- >SetWindowTex (" .. /ITTagSourcβ/pβrsistTest. tmp") ; //<-- put any path to a tmp file here

//setup initial value of output edit box pWnd - GetDlgItem(IDC_EDIT_OUTPUT) ; pWnd- >SetWindowText ("Notβ tthis test program is provided\r\n"

"\tfor your conviencβ. It is not\r\n

"\tintended to be a comprehensive\r\n"

"\ttest.") ; } ' void CTestDlgDlg : :GetDlgSoxData ( CLSID 6 clsid, CString* tagdictSource, CS rings. persistFilePath)

{

USES_CONVERSION;

//read the contents of the progid or clsid edit box CString tm ID;

CWnd* pWnd - GetDlgItem(IDC_EDIT_PROGIDCLSID) ; pWnd->GetWindowText(tmpID) ;

//attempt to convert this string to CLSID assuming it is a PROGID, //if fails, then assume it is a stringized CLSID HRESULT hr • CLSIDFromProglD (T2 (tm ID) , ϋclsid) ; if (FAILED(hr))

{

CLSIDFromString(T2W(tmpID) , s-clsid) ;

}

//setup initial value of tag dictionary data source directory pWnd » GetDlgItem(IDC_EDIT_SOURCEDIR) ; pWnd- >GetWindowText (tagdictSource) ;

//setup initial value of persistent file path pWnd - GetDlgItem(IDC_EDIT_PERSISTPATH) ;

GI pWnd- »GetWindowText (persistFilePath) ; } void CTestDlgDlg : :OnButtonTest ( ) i cwaitCursor cursor;

CLSID clsid =» CLSID_MULL;

CString tagdictSource;

CString persistFilePath;

GetDlgBoxData( clsid, tagdictSource, persistFilePath);

CWnd* pWnd - GetDlgItem(IDC_EDIT_OUTPUT) ; pWnd- >SetWindowText (TEXT ( "Begining tes ... lease wait ....")); pWnd->UpdateWindow() ;

{ //NOTE: thiβ really should be 3pun off to a separate apartment thread (so UI is not kept busy)

USES_CONVERSION; strstream sout;

//Start the testing

RunTest (clsid, CLSCTX_INPROC_SERVER,T2W(tagdictSource) ,T2W(persistFilePath)-, sout) ; sout << ends; pWnd->SetWindowText(A2T(sout.str 0 ) ) ; sou . rdbuf ()->fr«*βzβ(0); }

//Request that COM enumerate all InProc servers and call DllCanUnloadNow on each

CoFreeUnusedLibrariesO ;

0> D / TestClient . cpp : Implementation of TestClient •include "stdafx. h" •include "Tester. h" •include < ιostrβam. h> •include <strstrea . h> •include <tdm. h> const char* canst CRL * " \r\n" ; t i 111111 ii i ii i IIII urn III IIII i mil in III III in/mm ii

I I test entry point

HRESULT RunTes ⁽CLSID clsid, DWORD clsctx, LPCOLESTR datasource, LPCOLESTR filename, strscream& sout)

USES_CONVERSIO ; sout << "Begining test run" << CRL;

HRESULT hr - Tes (clβid, clsctx, datasource, 2A( ilename) , sout) ; sout << "End test run with hr- " << hex << hr <: dec << CRL; return hr;

} i i 111111111111111111111111111111111111111111111111111 III 1111111111111111111 III I HRESULT Test (const CLSID& rclsid, DWORD clsctx, PCOLESTR datasource, const char* filename, strstream& sout)

ITagDictionary* pDict » 0;

HRESULT hr

CoCreatelnstance (rclsid, 0, clsctx, IID_ITagDict onary, (void**) ipDict) ; sout << "CoCreatelnstance tag dictionary with hr»" << hex << hr << dec << CRL; if (SUCCEEDED (hr) )

{

USES _CONVERS ION ; hr ■ pDict->Open (datasource) ; sout << "dictionary: : Open ( " << W2A( datasource) << ") with hr« " << hex << hr << dec << CRL;

Test01eLo»d(pDict, ilename, sout) ; hr « pDict«>Cloβe() ; sout << "dictionary: :Close () with hr« " << hex << hr << dec << CRL^;

ReleaseAndNull (pDict) ;

} return hr; }

G ι void TastOleLoadt ITagDictionary* pDict, const char* filename, _3trstreami sou* ;

{ WWFilterEIement LogDataFilter; wwF lterSpecification FilterSpec ;

:Tag3rowserDlg* pDlg • 0;

HRESULT hr » LoadTagBrowsβ (filename, ipDlg, sout) ; if '.SUCCEEDED (hr) )

( WCHAR* accessNames.} • { L'ΑccessO",

L'Αccessl", L"Access2", L"Access3" }; const count » sizeof (accessNames) /sizeof (accessNames (0] ) ; pDlg->Init( pDict.NULL ); ρDlg->SetAccessNamβs (count, accessNames) ;

TestTagPicker (pDlg,sout) ;

// Test Tag Picker with Filter

LogDataFilter.UniquβΣD » ATT IBID_LOGGED;

LogDataFilter.pFilterString « L"l" ;

LogDataFilte .MultiChar • * •

LogDataFilter . SinglβChar

LogDataFilter.bCaseSβnsitivβ - FALSE;

LogDataFilter. Placeholder » 'A';

FilterSpec.pExpression « L"A";

FilterSpec. Count - 1;

FilterSpec. FiltdrElements » iLogDataFilter;

DWORD* pIDs » 0; long cnt ■ 0; hr » pDict->GetTagIDs(&FilterSpec, &pIDs, &cnt) ;

TestTagPicker (pDlg, sout) ; hr « SaveTagBrowsβr (filename, pDlg.sout);

TestDictionary(pDict.sout) ;

ReleaseAndNull (pDlg) ;

}

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiimiiimiiiiiiiiiiiiiiiiimniiiiiiii

HRESULT TestTagPicker (ITagBrowserDlg* pDlg, strstreamt sout)

{

ITagDefinition* pTag ■ 0; IDotField* pDot - 0; WCHAR* pAccessName « 0;

HRESULT hr - pDlg-

>DoTagPickerUI (ipTag, &ρDot, ipAccessName, 0 ,0,0, tiruβ, true, true, true, true, 0, 0^{) ;}

G5 i f : SUCCEEDED ( hr) )

{ f (pTag⁾

ReleaseAndNull (pTag) ; if (pDot)

RelaaseAndNull (pDot) ;

CoTaskMemFree ipAccessName)

return hr;

}

ii i ii iiiiimii miimiiii mil mimmiiimimiimiiiiiimiiiim III III

HRESULT TestDictionary( ITagDictionary* pDict, str3treami sout)

{

HRESULT hr * NOERROR;

/ II 1111111111111 / 11111111

IIget the display name

WCHAR* pNamβ - 0; hr » pDict->GetDisplayNamβ (ipNamβ) ; if (SUCCEEDED (hr) )

{

USES_CONVERSION; sout << "Display Name - \"" << W2T(pNamβ) << "\"" << CRL;

CoTaskMemFree (pNafme) ; }

///////////////////////////////

//get tag ids

DWORD* ids - 0; long count • 0 ; hr a pDict->GetTagIDs (NULL, &ids, icount) ; if (FAILED (hr))

{ ids « 0;

} if (ids) for (int i«0 ; i<count ; i++)

{ sout << "id[" << i <<"! * 0x" << hex << ids(il << dec << CRL;

TestGetTagFromlD (pDict, ids Ci] , sout) ; }

I U 1111 ! 111111111111 II I II 111 II I //test tag type enumerator IEnumTagTypβs* pEnum ■ 0; hr pDict->GetTagType--num( ipEnum ) ;

GG if ( SUCCEEDED (hr) )

{

//get as many tag types as I can stand const UINT max « 100; ITagType* pTags (max) ,- ULCNG fetched » 0; 2ercMemory⁽pTags,3izeo (pTags) ) ; hr » pEnun- >Mext ;max, pTags, ifetched) ; if (SUCCEEDED (hr) )

{ sout < < "Obtained " << fetched << " tags" << CRL; for (UINT i_*0 ,^• i<fetched ; i-t-t-)

TestTagType(pTags [il ,sout) ; ReleaseAndNull (pTags Ci] ) ;

} }

ReleaseAndNull (pEnum) ; }

II I I III 1111111111111111 //Test the ISpecifyTagAttributes TestAttributes ( pDict , sout) ; if (ids)

CoTaskMemFree ( ids) ; return hr; }

HRESULT TestTagType(ITagType* pTag, strstreamd sout)

{

HRESULT hr « NOERROR; i / 1111 ii π 11111111 I ill m 111

/ /get the type name

WCHAR* pName. - 0; hr 3 pTag->GatTypeName(6pName) ; if (SUCCEEDED (hr) )

{

USES_CONVERSIO ; sout << "TypeNamβ • \"" << W2T(pName) << "\"" << CRL;

CoTaskMemFree (pName) ; } iiiiiimiiimiimiiiiiiiiiii

//test dotfiled enumerator lEnumDotFields* pEnum « 0; hr _* pTag->GetDotFieldEnum( tpEnum ) ; if (SUCCEEDED (hr) )

GI //get as many tag types as I can stand const UINT max » 100 ;

IDotField* pDotFiel Cmaxl ;

ULONG fetched « 0 ;

ZeroMemory (pDotField, sizeof (pDotField) ) ; hr » ?Enum- >Next ⁽max, pDotField, if etched) ; if (SUCCEEDED (hr) )

{ sout << "Obtained " << fetched << " dot fields" << CRL; for (UINT i«0 ; i<fetched ; i++) {

TestDotFields (pDotFieldCi] , sout) ReleaseAndNull (pDotFieldCi) ) ;

} }

ReleaseAndNull (pEnum) ; } ii n ; π 111111111111 / ! 1111111111

//test dotfiled enumerator long selIndex ■ 0; long dβfIndex ■ 0; hr 3 pTag->Gβ ImageIndex( idβfIndex , isβlIndex ); if (SUCCEEDED (hr))

{ sout << "Image Iiidex default- " << defIndex << " selected_* " << sellndex <<

CRL;

} return hr; }

HRESULT TestDotFields (IDotField* pDotField, strstreams. sout)

{

HRESULT hr - NOERROR; return hr; }

HRESULT TestGetTagFromlD (ITagDictionary* pDict, DWORD id, strstream& sout⁾

{

ITagDefinition* pTag ■ 0;

HRESULT hr « pDict->GβtTagFromID(id, spTag) ; if (SUCCEEDED (hr) )

{ i ! 1111111111111111111111111111 //check for member tags DWORD* pIDs - 0; long count _* 0;

G% hr 3 pTag- >GetMemberTagIDs ⁽ NULL . iplDs , icount ) ; if ( SUCCEEDED ( hr) )

[ if (count)

( for (int i O ; i<count ; +_*)

{

TestGetTagFromlD ⁽pDict, IDs [i] , sout) ;

}

CoTaskMemFree (pIDs) ;

)

DumpAttribValue ( "Tag FullyQualified Name", ATTRIBID_FULLYQUALIFIED_NAME, pTag, sout) ;

DumpAttribValue ("Tag Hierarchical Name", ATTRIBID_HIERARCHICAL_NAME, pTag, sout) ;

DumpAttribValue ("Tag Type Name", ATTRIBID_TYPE, pTag.sout);

DumpAttribValue ( "Tag Comment" ,ATTRIBID_COMMENT,pTag, sout) ;

DumpAttribValue ("Tag Alarm Group Name", ATTRIBID_ALARM_GROUP, pTag.sout); •

DumpAttribValue < "Tag DDE Access Name", ATTRIBID_DDB_ACCESS_NAME, pTag.sout);

DumpAttribValue ("Logged" , ATTRIBID_LOGGED, pTag.sout);

DumpAttribValue ( "Nested" , ATTRIBID_NESTI-D, pTag.sout);

DumpAttribValue ("Expandable", ATTRIBID_EXPANDABLE, pTag.sout) ; miiniiiiiiiiimmmiii

//get TagTypβ

ITagType* pTagTypβ « 0; hr _* pTag->GetTagTypβ(ipTagTypβ) ; if (SUCCEEDED (hr) )

{ TestTagTypβ(pTagTypβ,sout) ;

ReleaseAndNull (pTagTypβ) ;

}

ReleaseAndNul (pTag) ; } return hr; } void DumpAttribValue (const char* label, DWORD id, ITagDefinition* pTag, strstream& sout)

{

WCHAR* pName 0;

HRESULT hr 3 pTag- ..GetAttributeValue ( id, ipName) ;

®\ if ! SUCCEEDED (hr) )

(

USES CO VE SION ; sout < < label << " . \ " " << W2T (pName) << " \ ^{,, M} < < CRL;

CoTaskMemFree (pName) ; } else ( sout < < " >> >> AILED : GetAttπbutValue : " << label << CRL;

}

III IIII III miiiiimmimiiiiiiiiiiiiimiiiiiimiiiimiiiniiiiii 11

HRESULT TestAttributes ( ITagDictionary* pDict , strstreami sout)

[ ISpecifyTagAttributes* pTagAttrib » 0;

HRESULT hr « pDiCt-

>QueryInterfacβ(IID_ISpβcifyTagAttributes, (void**) ipTagAttrib) ; if (SUCCEEDED (hr) )

{

LCID locallD - 0; pTagAttrib->GetLCID(ilocalID) ; wwExtendedAttribute* pAttrib - 0;

DWORD count - 0; hr - pTagAttrib- >GetAttributes ( ipAttrib, icount); if (SUCCEEDED (hr))

{ f sout << "LCID - " << hex << locallD << dec << CRL; for (DWORD i « 0 ; i<count ; i+-f)

{ if ( pAttrib l .pAttributβ )

{

USES ZONVERSION; sout << W2A(pAttrib[i] .pAttribute) << ":"; CoTaskMemFree (pAttribCi] .pAttribute) ;

} sout << "uniquβlD ■ " << pAttribtil .uniquelD << CRL; }

CoTaskMemFree (pAttrib) ; }

ReleaseAndNull (pTagAttrib) ; } return hr;

^rO : 1 1 ■ : l . ; I , , , m 1 11 11 111 1 1 111 I I I 1 11111 1 1 m I I I I m 1 1 11 I I I 1 1111111111 : ! i ' : HRESULT LoadTagBrowser ⁽const char* pFilaName, ITagBrowserOig* pDlg . strstreami sout) ( sout << '3egιn attempt to load dictionary from persistant store usir.g :?ersιstStream: :Load" << CRL;

IStream* pStream 3 0 ;

HRESULT hr _* CreateStreamOnHGlobal (0 , TRUE, pStrea ) ; if (SUCCEEDED (hr) )

{ bool bFillStream 3 false;

HANDLE hFile CreateFile (pFileName,GENERIC_READ|GENERIC_WRΣTE, 0,0, OPEN_ALWAYS , FILE_ATTRIBUTE_NORMA , 0) ; if (hFile !- INVALID HANDLE_VALU )

(

DWORD fsize 3 GetFileSize (hFile, 0) ; if (fsize) bFillStream 3 true; sout << "file \"" << pFileNamβ << "\" was opened with size- " << fsize << " bytes" << CRL; const maxBuff 1024; BYTE buff [maxBuff] ; DWORD byteCnt • 0; bool bContinue _;" true; do {

ReadFile (hFile, buff, maxBuff, ibyteCnt, 0) ; if (by eCnt < maxBuff) bContinue _* false; if (byteCnt)

{ pStream- >Writβ (buff, byteCnt, 0) ;

} } while (bContinue) ;

CloseHandle (hFile) ;

} sout _<< "attempted to construct IStream with file contents" << CRL^;

LARGE_INTEGER lint;

ZeroMemory (illnt, sizeof (lint) ) ; pStream- >Seek(lint, 0, 0) ; IPersistStream* pPersist 3 0 ,^•

^1 HRESULT hr ■ pDlg- >QueryInterf ace ( IID_IPersistStream, (void_{* *} ) ipPersist ) ,• sout << "QI dictionary for IPersistStream with hr 3 " < < hex < < hr << dec _{< <}

CRL; f ; SUCCEEDED (hr) )

{

CLSID clsid;

.^' see if there is a clsid there, if so then bypass it hr = eadClassStm (pStream, iclsid) ; if (FAILED (hr))

{

LARGE_INTEGER lint; 2eroMemory(ilInt, sizeof (lint) ) ,^• pStream- >Seek (lin ,0,0) ,-

hr pPersist->Load(pStream) ,- sout << " IPersistStream: : Load 0 called with hr 3 ^•• << hex << hr << dec <<

CRL;

ReleaseAndNull (pPersist) ; }

ReleaseAndNull (pStream) ; } return hr; }

///// 1 III 11111111 III 111111111111111111 III 111111 III 1111111 II III 1111111 ! 11 n I HI : HRESULT LoadTagBrowββr (const char* pFileNamβ, ITagBrowβerDlg** ppDlg strstreami sout)

{ sout << "Begin attempt to load dictionary from persistant store using

OleLoadFromStream" << CRL; *ppDlg 3 0; IStream* pStream » 0; HRESULT hr * CreatestrβamOnHGlobal (0, TRUE, ipStream) ; if (SUCCEEDED (hr))

{ bool bFillStream > false;

HANDt-E hFile « CreateFile (pFileName,GENERIC_READ|G--NERIC_WRITE, 0,0, OPEN_ALWAYS, FILE_ATTRIBUTS_NORMAL, 0) ; if (hFile !- INVALID HANDLE VALUE)

{

DWORD fsize * GetFileSize (hFile, ) ; if (fsize) bFillStream a true;

2 sout < < " f ile \ " " < < pFileName < < " \ " was opened with size« _{" < <} f s . ze _{< <} " bytes" << CRL;

const maxBuff 1024 , ^• BYTE bu f [maxBuff] ; 3 WORD byteCnt 3 0 _; bool -.Continue » ue ; do {

ReadFile (hFile, buff, maxBuff, ibyteCnt, 0) ; if (byteCnt < maxBuff) bContinue a false; if (byteCnt)

{ pStream- >Write (buff , byteCn , 0) ;

} } while (bContinue) ;

CloseHandle (hFile) ; } sout << "attempted to construct IStream with file contents" << CRL;

LARGE_INTEGER lint;

ZeroMemorγ (&llnt, sizeof (lint) ) ; pStream- >Sββ (lint, 0,0) ;

IPersistStream* pPersist a 0; hr a OleLoadFromStream(pStream, IID_ITagBrowsβrDlg, (void**)ppDlg) ; sout << "OleLoadFromStream0 called with hr » " « hex << hr << dec << CRL; if (FAILED (hr))

{

//don't have a valid stream, so need to CoCreatelnstance it hr CoCreatelnstance (CLSΣD_TagBrowsβrDlg, 0,CLSCTX_S--RVER, IΣD_ITagBrowsβrDlg, (void**) PpDlg) ; sout << "Since OleLoadFromStream failed, call CoCreatelnstance with hr 3 " << hex << hr << dec << CRL; }

ReleaseAndNull (pStream) ;

} return hr; } iiiiiiiiiiiiiiiiiiiiiimiimmiimiimiiimiiiiiiiiiiiiiiiiiiiiiiiii¹¹'^!1

HRESULT SaveTagBrowser (const char* pFileName, ITagBrowsβrDlg* pDlg, strstreamⁱ sout )

{

IPersistStream* pPersist 3 o_;

^• HRESULT hr pDlg- >QueryInterf ace ( IID_IPersιstStream, ( oid_** ) ipPers ist) ,• f ( SUCCEEDED (hr) ) i

IStream* pStream a 0;

HRESULT hr 3 CreatestreamOnHGlobal (O.TRUE, ipStream) ; if (SUCCEEDED (hr) )

{

HANDLE hFile - CreateFile (pFileName, GENERIC_READ | GENERIC_WRITE, 0,0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0) ; if (hFile !- INVALID HANDLE VALUE)

{ hr 3 oleSaveToStream(pPersist, pStream) ;

LARGE_INTEGER lint; ZeroMemory(ilInt, sizeof (lint) ) ; pStream->Seek(lInt, 0,0) ; const maxBuff a 1024 ; BYTE buff [maxBuff] ; DWORD byteCnt a 0; bool bContinue a true; do { pStream->Read(buff, maxBuff, ibyteCnt) ,- if (byteCnh < maxBuff) bContinue a false; if (byteCnt)

{ DWORD bytesWritten a 0; WriteFilβ (hFile, buff, byteCnt, ibytβsWrittβn,0) ;

} } while (bContinue) ;

CloseHandlβ (hFile) ; }

ReleaseAndNull (pStream) ; }

ReleaseAndNul (pPersist) ;

} return hr; } / / TestDlgDlg . h : header f ile / /

• if : defined ⁽AFX_TESTDLGDLG_H_EAA2967⁷_A8F7_i:Dl_3S6A_000000000000__INCLUCED ! •def ine AFX_TESTDLGDLG_H EAA29677_A8F7_11D1_356A~000000000000 INCLUDED_,.

•if _MSC_VER >a 1000

•pragma once

•endif // _MSC_7SR »" 10OO 11 IIII urn iimiiiiimiiii ill mmiiiiiiiiiiiimiimi

I I CTestDlgDlg dialog class CTestDlgDlg : public CDialog

{

II Construction public:

CTestDlgDlg (CWnd* pParent a NULL) ; // standard constructor

// Dialog Data

//{{AFX DATA (CTestDlgDlg) enum { ΪDD IDD_TESTDLG_DIALOG };

// NOTE: the ClassWizard will add data members here //}}AFX_DATA

// ClassWizard generated virtual function overrides

// { {AFX_VIRTUAL(CTestDlgDlg) protected: virtual void DoDataExchangβ (CDataExchangβ* pDX) ; // DDX/DDV support

//}}AFX_VIRTUAL

// Implementation j protected:

HICON m ilcon; void SetupDlgBoxO ; void GetDlgBoκData ( CI-SID6 , CString.- , CStringi ) ;

LPARAM lParam) ;

//{{AFX_INSERT LOCATION}}

// Microsoft Developer Studio will insert additional declarations immediately before the previous line. ftendif ^{f /} i. defined (AFX TESTDLGDLGJ- EAA29677_A8F7_11D1_B56A_000000000000 INCLUDED

1-5 • Microsoft Developer Studio Proj ect File - Namea "TestDlg" - Package 0wner» < 4 >

* Microsoft Developer Studio Generated Build File , Format Version S . OO

• « * DO NOT EDIT •*

* TARGTYPE "Win32 ⁽x8S) Application" 0x0101

CFGaTestDlg - Win32 Debug MESSAGE This is not a valid makefile. To build this project using NMAKE, MESSAGE use t e Export Makefile command and run MESSAGE

MESSAGE NMAKE /f "TestDlg .mak" . MESSAGE

MESSAGE You can specify a configuration when running NMAKE MESSAGE by defining the macro CFG on the command line. For example: MESSAGE

MESSAGE NMAKE It "TestDlg.mak" CFGa"TestDlg - Win32 Debug" MESSAGE

MESSAGE Possible choices for configuration are: MESSAGE

MESSAGE "TestDlg - Win32 Release" (based on "Win32 (x8S) Application") MESSAGE "TestDlg - Win32 Debug" (based on "Win32 (x86) Application") MESSAGE

* Begin Project

* PROP Scc_ProjNamβ ""

• PROP Scc_LocalPath "" CPPacl.exe

MTLamidl . exe RSCarc.exe

.IF "$(CFG)" a. "TestDlg - Win32 Release"

/D "_WINDOWS" /D /D "_WINDOWS" /D

BSC32abscmake.exe

• ADD BASE BSC32 /nologo

* ADD BSC32 /nologo LINK32alink.exe

* ADD BASE LINK32 /nologo /subsystem: indows /machine: Σ386

• ADD LIN 32 /nologo /subsystem:windows /machine :I38^β

KS :EL5EIF S(CFG⁾" « "TestDlg - Win32 Debug"

• PROP BASE Use_MFC 6

• PROP BASE Use_Debug_Libraries 1

• PROP 3ASE Output_Dir "Debug"

• PROP BASE Intermediate_Dir "Debug"

• PROP BASE Target_Dir ""

• PROP Use_MFC 6

• PROP Use_Oebug_Lιbrar es 1

• PROP Output_Dιr "Debug"

• PROP Intermediate_Dir "Debug"

• PROP Ignore_Export_Lib 0

• PROP Targβt~Dir ""^" tt ADD BASE CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D

"_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /c tt~ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS"

/D "_AFXDLL" /Yu"stdafx.h" /FD /c tt ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32 tt ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32 tt ADD BASE RSC /l 0x409 /d "_DEBUG" /d "_AFXDLL" tt ADD RSC /l 0x409 /d "_DEBUG" /d "_AFXDLL"

BSC32abscmake . exe tt ADD BASE BSC 2 /nologo tt ADD BSC32 /nologo

LINK32alink.exe tt ADD BASE LINK32 /nologo /subsystem: indows /debug /machine: 1386 /pdbtype : sept tt ADD LΣNK32 WWtdm.lib /nologo /subsys em:windows /debug /machinβ:I386

/pdbtype : sept

1ENDIF tt Begin Target tt Name "TestDlg - Win32 Release" tt Name "TestDlg - Win32 Debug" tt Begin Group "Source Files" tt PROP Default_Filter "cpp;c;cxx;rc;de ; r;odl; idl;h j ;bat" tt Begin Source File

SOURCE- . \StdAfX. cpp tt ADD CPP /Yc"stdafx.h" tt End Source File tt Begin Source File

SOURCE- . \TestDlg.cpp tt End Source File tt Begin Source File

SOURCEa . \TestDlg . re

'.IF "$(CFG)" a. "TestDlg - Win32 Release" lELSEIF "$(CFG)" aa "TestDlg - Win32 Debug"

1ENDIF

ϊ • End Source File

• 3egm Source File

SOURCE- . \TestDlgCaller . cpp

• End Source File

• Begin Source File

SOURCE- . \TestDlgDlg . cpp tt End Source File tt Begin Source File

SOURCE- . \tester. cpp tt End Source File tt End Group tt Begin Group "Header Files" tt PROP Dβfault_Filter " ; hpp; hx ; hm; inl" tt Begin Source File

SOURCE- . \Resource .h tt End Source File tt Begin Source File

SOURCE.. \StdAfx.h tt End Source File tt Begin Source File

SOURCE- . \TestDlg.h tt End Source File tt Begin Source File

SOURCE- . \TestDlgDlg. i) tt End Source File tt End Group

• Begin Group "Resource Files" tt PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif; jpg; jpeg; jpe" tt Begin Source File

SOURCE- . \res\TestDlg. ico tt End Source File tt Begin Source File

SOURCE- . \rββ\TestDlg. rc2 tt End Source File tt End Group tt Begin Source File

SOURCE- . \ReadMe. txt tt End Source File tt End Target tt End Project

I / / TestOlgOlg - pP : implementation f ile / /

•include " stdafx . h" •include "TestDlg . " •include "TestDlgDlg . h" •include " tester . "

•i f ef _2Ξ3UG •def ine new E3UG_NEW •undef THIS_FILE static char~THIS_FILE [] - FILE ;

•endif lllll II II III , // CAboutDlg dialog used for App About class CAboutDlg : public CDialog

{ public:

CAboutDlg ( ) ;

// Dialog Data

//{{AFX_DATA(CAboutDlg) enum { ΪDD - IDD_ABOUTBOX } ; //}}AFX_DATA

// ClassWizard generated virtual function overrides

// { {AFXJ/IRTUA (CAboutDlg) protected: virtual void DoDataExchange (CDataExchange* pDX) ; // DDX/DDV support

// HAFX /IRTUAI,

// Implementation protected:

//{ {AFX_MSG (CAboutDlg)

//}}AFX~MSG

DΞCLARE^'MESSAGE MA O

CAboutDlg: :CAboutDlg 0 : CDialog (CAboutDlg:: IDD)

//{{AFX DATA INIT(CAboutDlg) //}}AFX_DATA~INIT

void CAboutDlg: :DoDataExchange (CDataExchange* pDX)

CDialog: :DoDataExchange (pDX) ; //{{AFX DATA_MAP (CAboutDlg)

//}}AFX~DATA~MAP

BEGIN_MESSAGE_MA (CAboutDlg, CDialog) // { {AFX~MSG_MAP (CAboutDlg) ll No message handlers

//}}AFX_MSG_MAP

^ // s_tdafx.cpp _: source file _that includes just the standard ⁱncludes

_{// T}. _rDlg.pch w ll be the pre-compiled header

// stdafx obj will contain the pre-compiled type informatⁱon

•include " stdafx. " •_include <atlconv.cpp>

SO /' stdafx. : include file for standard system include files,

// or project specific include files that are used frequently, ut

// are changed infrequently

//

• if : def ined (AFX_STDAFX_H EAA29679_A8F7_UD1_356A_000000000000 INCLUDED_

•def ine ArX_STDAFX_H EAA29679_A8F7_11D1_3S6A~000000000000 INCL^* DED_

•if _MSC_YΪR >" 1000

•pragma once

•endiff // _MSC_VER >- 1000

•define VC EXTRALEAN // Exclude rarely-used stuff from indows headers

•include <afxwin.h> // MFC core and standard components

^••include <afxext.h> // MFC extensions

•include <afxdisp.h> // MFC OLE automation classes ttifndef _AFX_NO_AFXCMN_SU PORT ttinclude <afxcmn.h> // MFC support for Windows Common Controls ttendif // _AFX_NO_AFXCMN_SUPPORT

•include <atlbasβ.h> •include <atlconv.h>

// { {AFX_INSERT_LOCATION} }

// Microsoft Developer Studio will insert additional declarations immediately before the previous line. ttendif //

[defined (AFX STDAFX H EAA29679 A8F7 11D1 BS6A 000000000000 INCLUDED )

W ' Tast--lg . pp Cef nes the class behaviors for the applicat ion . / /

• include " stdafx. " • incl ude ' TestDlg . h" •include "TestDlgDlg. h"

•i fdef CEBUG •def ine^' e CE3UG_NΞW •undef THIS_FILE static char~THI5_FILE (] - FILE ;

•endif i n III i in iiimimm immiiimi iimimmmmiiiiiimiiii 11 n i i

II CTestDlgApp

BEGIN MESSAGE_MA (CTestDlgApp, CWinApp) ^"// { {AFX_MSG_MA (CTestDlgApp)

// NOTE - the ClassWizard w ll add and remove mapping macros here. // DO NOT EDIT what you see in these blocks of generated code! //}}AFX_MSG

ON_COMMAND (IDJ-ELP, CWinAp : :OnHelp) END_MESSAGE_MAP ()

11 ! 1111111111111111111111 II 1111111111 i 111111111111111111 ! 111111111 II 111 II 1111 • // CTestDlgApp construction

CTestDlgApp: :CTestDlgApp()

{

// TODO: add construction code here,

// Place all significant initialization in Init∑nstance

}

I i I ¹11 i 111 ! 11111 II II 11111 II 111111111111111111111111 II I II II 11111111111 ! I i 1 1111

II The one and only CTestDlgApp object

CTestDlgApp theApp; iiiiniiiiiniiimiiiiiiiitiiiiiiiiiiimiimmiiiiimmmiiiiiiiinm

II CTestDlgApp initialization

BOOL CTestDlgApp : : Initlnatancβ ( )

{ if (.AfxOlβlni O) return FALSE;

// Standard initialization

// If you are not using these features and wish to reduce the size // of your final executable, you should remove from the following // the specific initialization routines you do not need.

•ifdef _AFXDLL

Enable3dControls(); // Call this when using MFC in a shared DLL •else

Enable3d_Con_trolsStat c() ; // Call this when linking to MFC statically ttendif

z CTestDlgDlg dig; m_pMaιnWnd - idlg; int nResponse 3 dig . DoModal ( ) ,- f (nResponse - IDOK)

{

// TODO: Place code here to handle when the dialog s

'/ dismissed with OK \ else if (nResponse -« IDCANCΞL)

{

// TODO: Place code here to handle when the dialog is // dismissed with Cancel

}

// Since the dialog has been closed, return FALSE so that we exit the // application, rather than start the application's message pump. return FALSE;

S3 / / TestDlg . : am header file for the TESTDLG application / /

• if : ef ined ⁽AFX_TESTDLG_H EAA29675_A3F7_HD1 356A_000000000000 INCLUDED )

•def ine AFX_TESTDLG_H EAA29675_A8F7~11D1_3S6A~000000000000 INCLUDED_

•if _MSC_VΞR >- 1000

•pragma once

•endif // _MSC_VΞR -- lOOO

•ifndef AFXWIN_H

•error include ' stdafx. h' before including this file for PCH •endif

•include "resource.h" // main symbols IIII IIII III miiiiimmmiimmmiimmmimiiiiiiiiimii i ii

II CTestDlgApp:

// See TestDlg. cpp for the implementation of this class

// class CTestDlgApp : public CWinApp

{ public:

CTestDlgApp () ;

// Overrides

// ClassWizard generated virtual function overrides

// { {AFX_VIRTUA (CTestDlgApp) public: virtual BOOL Initlnstancβ () ;

//}}AFX_VΣRTUAI»

// Implementation

// { {AFX_MSG (CTestDlgApp)

// NOTE - the ClassWizard will add and remove member functions here.

// DO NOT EDIT what you see in these blocks of generated code '. //}}AFX MSG DECLARE~MESSAGE MAPO

};

iiiiiiiiiiiiiiiiiiiiiiiiniiiiiiimmimimmiiiiiiiiiiiiiiiiiiiiiiiiiu

//{{AFX_INSERT LOCATION}}

// Microsoft Developer Studio will insert additional declarations immediately before the previous line. ttendif ^π

'. defined (AFX TESTDLG_H EAA29675_A8F7_11D1_B56A_000000000000 INCLUDEDJ

% Tester. Cβc aration oi the CTestClient

•if def __TESTER_H__ •define _TESTER_H__

•include <ιostream.h> •include <strstrea.h>

' forward declares interface ITagBrowserDlg; interface ITagDictionary; interface ITagType; interface IDotField; interface ITagDe ini on;

HRESULT RunTes (CLSID clsid, DWORD clsctx, LPCOLESTR datasource, LPCOLESTR filename, 3trstreami) ;

HRESULT TestTagPicker (ITagBrowserDlg* pDlg, strstreami sout);

HRESULT TestOict onaryf ITagDictionary* pDict, strstreami sout) ;

HRESULT Tes (const CLSIDi rclsid, DWORD clsctx, LPCOLESTR datasource, const char* ilename, strstreami sout) ,-

HRESULT TestTagTypβ( ITagType* pTag, strstreami sout);

HRESULT TestDotFields (IDotField* pDotField, strstreami sout);

HRESULT TestGetTagFromlD (ITagDictionary* pDict,DWORD id, strstreami sout);

HRESULT LoadTagBrowser (const char* pFileName, ITagBrowserDlg* pDlg , strstreami sout) ;

HRESULT LoadTagBrowser (const char* pFileName, ITagBrowserDlg** pDlg , strstreami sout) ,-

HRESULT SaveTagBrowsβr (const char* pFileName, ΣTagBrowserDlg* pDlg , strstreami sout) ,- void TestStandardFile(ITagDictionary* pDict, strstreami sout⁾ ; void TestOleLoad(ITagDictionary* pDict, const char* filename, strstreami⁾;

HRESULT TestAttributes ( ITagDictionary* pDict, strstreami sout ⁾ ; void DumpAttribValue (const char* label, DWORD id, ITagDefinition* pTag, strstreami sout) ;

template <class U> void ReleaseAndNull ( U*i pUnk )

{ if ( pUnk )

{ pUnk->Rβlβasβ() ; pUnk - 0; } } ttendif // TESTER H

MS this ALWAYS GENERATED file contains the definitions for _the interfaces

/• F le created by MIDL compiler version 3.01.75 ^»/ /* at on 3ec 22 15:10:41 1997

*/ /♦ Compiler settings for ITTDI.idl:

Oicf CptLav3 2) , Wl, Zp3, env-Win32, ms_ext, c_ext error checks ^■. -one */

//30MIDL_FILE_HEADING( ) •include "rpc.h" •include "rpcndr.h" •ifndef COM_NO_WΣNDOWSJΪ •include "windows. h" ^••include "ole2.h" •endif /*COM_NO_WΣNDOWS_H*/

•ifndef ITTDI_h

•define ITTDIJ. ttifdef cplusplus extern "C"{ ttendif

/* Forward Declarations */ ttifndef IΣnTouchTagDictionary_FWD_DEFINED •

•define IInTouchTagDictionary_FWD_DEFINED typedef interface ΣlnTouchTagDictionary IlnTouchTagDictionary; ttendif /* IInTouchTagDictionary_FWD_DEFINED */

} ttifndef ΣnTouchTagDictionaryObj_FWD_DEFΣNED

•define InTouchTagDictionaryObj_FWD_DEFINED ttifdef cplusplus typedef class InTouchTagDictionaryObj InTouchTagDictionaryOb ;

•else typedef struct InTouchTagDictionaryObj InTouchTagDictionaryObj ; ttendif /* cplusplus */

•endif /* InTouchTagDictionaryObj_FWD_DEFINED */

/* header files for imported files */ •include "TagΣDL.h" void RPC_FAR • RPCJJSER MIDL_user_allocatβ (sizβ_t) ; void RPCJJSER MIDL_usβr_free ( void __RPC_FAR * ); ttifndef IInTouchTagDictionary_INTERFACE_DEFINED ttdefine IInTouchTagDictionary_INTERFACE_DEFINED

/ *•*••••*♦•* •*♦.* ..

* Generated header for interface: IlnTouchTagDictionary

* at Mon Dec 22 15:10:41 1997

2£> • using MIDL 3.01.75

..^♦.••^♦«•••«*** * ^♦••.^♦/

/« [unique] [helpstring] [uuid] [object! •/

typedef /* [vl_enum] */ enum tag WIDChanged

{ WWTAG_CHANGE_ADDED » 1,

WWTAG_CHANGE_MCDIFIED * WWTAG_CHANGE_ADDED * 1, WWTAG~CHANGE~DELETED » WWTAG~CHANGE~MODIFIED + 1 } wwiDChangβd;

EXTERN_C const IID IID_IInTouchTagDictionary;

■•if defined ( cplusplus) ii ! defined (CINTERFACE) interface DECLSPECJJUID ("C7192S00-C5A5-lld0-302F-00A0248FE0BA^H) IlnTouchTagDictionary : public ITagDictionary

{ public: virtual HRESULT STDMETHODCALLTYPE TagHasChanged (

/* [in] */ DWORD ID,

/* [in] */ WWΣDChanged enumChanged) - 0;

}; •else /* C style interface */ typedef struct IlnTouchTagDictionaryVtbl

{

BEGIN_INTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QueryIntβrface ) (

IlnTouchTagDictionary RPC FAR * This,

/* [in] */ REFIID riid,

/* [iid_is] [out] ^♦/ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRef ) (

IlnTouchTagDictionary RPC_FAR * This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Releasβ ) (

IlnTouchTagDictionary RPC~FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Open ) (

IlnTouchTagDictionary RPC_FAR * This,

/* tin] */ LPCOLESTR dacaSource) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Close ) (

IlnTouchTagDictionary RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetDisplayNam^{β ) (}

IlnTouchTagDictionary RPC_FAR * This,

/* [outl */ LPOLESTR RPC_FAR *ppDisplayNamβ⁾ ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetDataSourcaControlClsid ^{) (}

IlnTouchTagDictionary RPC AR * This,

%-τ- , • [out] ^»/ GUID RPC_?AR *pClsid) ;

HRESULT ⁽ STDMETHODCALLTYPE RPC_FAR *Get:mageLιst ) (

IlnTouchTagDictionary RPC_?AR * This,

/* [in] */ WWImageType lmgType,

/* [in] ^•/ IStream __RPC_FAR 'pStream) ;

HRESULT ! STDMETHODCALLTYPE RPC_FAR *GetImageIndex ) (

IlnTouchTagDictionary RPC_FAR * This,

/* [out] •/ long RPC_FAR *pDefImglndex,

/* [optional] [out] */ long RPC_FAR *pSelImglndex) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetTagFromID ) (

IlnTouchTagDictionary RPC_FAR * This,

/* [in] */ DWORD ID,

/* [out] */ ITagDefinition RPC_FAR * RPC_FAR *ppTag) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'GetTagTypeEnum ) (

IlnTouchTagDictionary RPC_FAR * This,

/* [out] */ IEnumTagTypes RPC_FAR * RPC_FAR *ppEnumTagType) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetTagΣDs ) (

IlnTouchTagDictionary RPC_FAR * This,

/* [in] */ wWFilterSpecification RPC_FAR *pFilters,

/* [size_is] [sizβ_is] [out] */ DWORD RPC_FAR * RPC_FAR *ppIDs,

/* [out]^"*/ long __RPC_FAR *pCount) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *TagHasChanged ) (

IlnTouchTagDictionary RPC_FAR • This,

/* [in] */ DWORD ID,

/* [in] */ WWIDChanged enumChanged) ;

END NTERFACB } IlnTouchTagDictionaryVtbl; interface IlnTouchTagDictionary

{

CONST VTBL struct IlnTouchTagDictionaryVtbl RPC FAR *lpvtbl;

}^;

•ifdef COBJMACROS

•define IInTouchTagDictionary_QuβryInterface (This, riid.ppvObject) \ (This) ->lpVtbl -> Quβrylnterfacβ(This,riid,ppvObject)

•define HnTouchTagDictionary_AddRef (This) \ (This) ->lpVtbl -> AddRef(This⁾ ttdefine IInTouchTagDictionary_Release (This) \ (This) ->lpvtbl -> Release~This)

•define IInTouchTagDictionary_Open(This,dataSource) \ (This) ->lpvtbl -> Open (This, datasource)

22 •define IlnTouchTagDictionary_Close ⁽This) \ (This) ->lpVtbl -> Close(Thιs)

•def ne IlnTouchTagDictionary_GetDιsplayName (This.ppDisplayNa e) \ ;Thιs) ->lpVtbl -> GetDisplayName (This. ppDisplayName)

•define "nTouchTagDictionaryJ-etDataSourceControlClsid (This, Clsid) \ (This) -- pvtbl - » GetDataSourceControlCls (This, pClsid)

•define IlnTouchTagDictionaryJ-JetlmageList (This, imgType, pStream) \ (This) ->lpVtbl -> GetlmageList (This, imgType, pStream)

•define IlnTouchTagDictionary -etlmagelndex (This, pDe Imglndex, pSell glndex) (Thi3) ->lpVtbl -> Getlmagelndex (This, pDefImglndex, pSellmglndex)

•define IInTouchTagDictionary_GetTagFromID(This, ID.ppTag) \ (This) ->lpVtbl -> GetTagFromlD (This, ΣD.ppTag)

•define IlnTouchTagDictionary_GetTagTypeEnum ⁽This, ppEnumTagTypβ) \ (This) -ϊlpVtbl -> GetTagTypeEnum (This, ppEnumTagTypβ)

•define IInTouchTagDictionary_GetTagIDs (This, pFilters.ppΣDs,pCount) \ (This) ->lpVtbl -> GetTaglDs (This, pFilters,ppIDs, pCount)

ttdefine IInTouchTagDictionary_TagHasChanged(This, ID.enumChanged) \ (This) ->lpVtbl •> TagHasChangedtThis, ID, enu Changβd)

•endif /* COBJMACROS */ i ttendif /* C style interface */

HRESULT STDMETHODCALLTYPE ΣΣnTouchTagDictionary_TagHasChangβd_Proxy (

IlnTouchTagDictionary RPC_FAR * This,

/* [in] */ DWORD ΣD,

/* [in] */ wwiDChangβd βnumChangβd) ;

void RPC_STOB IlnTouchTagDictionary_TagHasChangβd_Stub(

IRpcStubBuffer *This, IRpcChannβlBuffβr *j?RpcChannelBuffer, ?RPC_MESSAGB _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

ttendif /* HnTouchTagDictionary_INT--RFACB_DEFΣNED_

ttifndef InTouchTagDictionaryLib_LIBRARY_DEFINED

•define InTouchTagDictionaryLib_LIBRARYJ-EFINED

s

-.""ihelpstringl [version] [uuid] */

EXTΞRN..C const IID LIBID nTouchTagDictionaryLib^;

EXTE^ C-co-lsfcϊsiD CLSID.InTouchTagOictionaryObj^;

_Class DECLSPEC_UUID₍"3EC11294-ABB4-UD0-9B70-030009C39144",

InTouchTagDictionaryObj ;

•endif /_• _InTouchTagDi=tionaryLib_LIBRARY_DEFINED__ */

/* Additional Prototypes for ALL interfaces */ /* end of Additional Prototypes */

•ifdef cplusplus

}

•endif ttendif

^<v> /• this f le contains the actual definitions of ♦/ /• the IIDs and CLSIDs ^«/

/* link this file in with the server and any clients */

/* File created by MIDL compiler version 3.01.75 */ /* at Men Dec 22 15:10:41 1997

•/ /* Compiler settings for ITTDI.idl:

Oicf (OptLev-i2) , Wl, Zp8, env3Win32, ms_ext, c_ext error checks: none */ //30MIDL_FILE_HEADING( ) ttifdef cplusplus extern "C"{ ttendif

ttifndef IID_DEFINED ttdefine IIDJ3EFINED typedef struct IID

{ unsigned long x; unsigned short si; unsigned short s2; unsigned char c[3]; } IID; ttendif // IIDJ3EFINED ttifndef CLSΣDJ3EFΣNED ttdefine CLSID_DEFINED typedef IΣD CLSID; ttendif // CLSIDJ3EFINED const IID IID_IInTouchTagDictionary

{0XC7192600. OxCSAS , OxlldO, {0x80 , 0x2F, 0x00 ,^"OxA0 , 0x2 , OxβP, OxEO , OxBA} } ;

const IID LIBΣD_ΣnTouchTagDictionaryLib

{0X3EC11293 , 0XABB4, O llDO, {0x9B, 0x70, OxOβToxOO, 0x09, 0xC3, 0x91, 0x44} } ;

const CLSID CLSID_InTouchTagDictionaryObj

{0X3EC11294, 0XABB4 , OxllDO, {0x9B, 0x70 , 0x08 ,^"θXθO , 0x09, 0xC3 , 0x91, 0x44} } ;

ttifdef cplusplus

} ttendif

^< t '^• this ALWAYS GENERATED file contains the definitions for the in_terfaces _*■

/» File created by MIDL compiler version 3.31.75 */ ^■« at on Dec 22 IS: 10: 33 1997 _* / '* Compiler settings for TDM.idl:

3ιcf ;ptlev 2) , Wl, Zp8, env-Wιn32, ms_ext, c_ext error o.-.ecxs : none */

//3<SMIDL_FILE_HEADING( ⁾ •include "rpc.h" •include "rpcndr.h"

•ifndef TDM_h

•define TDMJα

•ifdef cplusplus extern "C"{ •endif

/* Forward Declarations */

•ifndef TagDictionaryManager_FWD_DEFINED

•define TagDictionaryManager_FWD_DEFINED

•ifdef cplusplus typedef class TagDictionaryManagβr TagDictionaryManagβr;

•else typedef struct TagDictionaryManager TagDictionaryManagβr;

•endif /* cplusplus */

•endif /* TagDictionaryManager_FWD_DEFINED */

•ifndef TagBrowserDlg_FWD_DEFΣNED

•define TagBrowserDlg_FWD_DEFΣNED

•ifdef cplusplus typedef class TagBrowsβrDlg TagBrowserDlg;

•else typedef struct TagBrowserDlg TagBrowserDlg;

•endif /* cplusplus */

•endif /* TagBrowβerDlg_FWD_DEFINED */

/* .leader files for imported files */ •include "TaglDL.h" void RPC_FAR * RPCJJSER MIDL_user_allocate (sizβ_t) ; void RPC USER MIDL user free( void ~ RPC FAR * ) ;

•ifndef TAGDICTIONARYMANAGERLibJ-IBRARY_DEFINED_

•define TAGDICTIONARYMANAGERLib~LIBRARY DEFINED^*

<te

."[helps_trmgl [version] [uuidl ^*/

EXTERN_C cons_t IID LIBID_TAGDΣCTIONARYMANAGERLib^;

_CLSID_TagDic_tionaryManager;

_class DECLSPEC_UJID₍"₀4F₃₀12F-96F₆-_llD₀-34_0S-₄₀D1₀1C10000")

TagD c_tionaryManager;

•endi

-„S» r --ϊf-ϊ-.π c-S-D.T.- ro_U-.-ol₃, cl.„ DEC S.-C-.-U-DC_7irBAS₄--₅«E-LlDO-B7--.₀₃000₃«8₁08.»

TagBrowserDlg; ttendif /* _TAGDICTIONARYMANAGERLib_LΣBRARY_DEFINBD_ */

/* Additional Prototypes for ALL interface. */ /* end of Additional Prototypes */

•ifdef cplusplus

} •endif

•endif

<*3 ,'• this file contains the actual definitions of */ i » the IIDs and CLSIDs */

/* link th 3 file in with the server and any clients •/

/* File created by MIDL compiler version 3.01.75 */ /• at Mon .-ec 22 15:10:33 1997

*/ /• Compiler settmge for TDM. dl:

Oicf (OptLev-ι2) , Wl, Zp8, env-Win32, ms_ext, c_ext error checks: none */ //3®MIDL_FILE_HEADING( )

•ifdef cplusplus extern "C"{ •endif

ttifndef IIDJ3EFINED ttdefine IIDJ3EFINED typedef struct IID

{ unsigned long x; unsigned short si; unsigned short s2; unsigned char c[3l; } IID; ttendif // IIDJ3EFINED ttifndef CLSΣD_DEFINED ttdefine CLSΣDJ3EFINED typedef IID CLSID; •endif // CLSID_DEFINED const IID LΣBID rAGDICTIONARYMANAGERLib

{ OX04F30122 , 0X96F6 , OxllDO, {0x8 , 0x06 , Ox4θ7θxDl, 0x01, OxCl.0x00 , 0x00} } ;

const CLSID CLSID_TagDictionaryManager

{0x04F3012F,0x96F6, OxllDO, {0x84, 0x06, 0x40, OxDl, 0x01, OxCl, 0x00, 0x00} };

const CLSID CLSID TagBrowserDlg

{0x71FBAS42,0x9ASB, OxllDO, {0xB7, 0x23 , 0x08, 0x00, 0x09, 0xC3.0x81, 0x08} } ;

ttifdef lusplus

} ttendif

% /^• this ALWAYS GENERATED file contains the definitions for the in_terfaces

/* File created by MIDL compiler version 3.01.75 */ /• at Mon Dec 22 15:10:33 1997

*/ /* Compiler settings for TaglDL.idl:

Oicf ^'CptLev»ι2) , W , Zp3, env-Wιn32, ms_ext, c_axt error checks: one */

/ /3<3>MIDL_FILEJΪEADING ( ) •include "rpc.h" •include "rpcndr.h" •ifndef COM_NO_WINDOWS_H •include "windows. h" •include "ole2.h" •endif /*COM_NO_WINDOWS_H*/ ttifndef TaglDLJi ttdefine TaglDLJi ttifdef cplusplus extern "C"{ •endif

/* Forward Declarations */ ttifndef IEnumTagTypβs_FWD_DEFINED

•define IEnumTagTypβs_FWD_DEFINED typedef interface IΞnumTagTypes IEnumTagTypβs ; •endif /* IEnumTagTypes_FWD_DEFINED */

•ifndef IEnumDotFields_FWD_OEFINED

•define IEnumDotFields_FWD_DEFINED typedef interface lEnumDotFields lEnumDotFields; •endif /* lEnumDotFields FWD DEFINED */

•ifndef ITagDictionaryJWDJΪEFINED

•define ITagDictionary_FWD_DEFINED typedef interface ITagDictionary ITagDictionary; •endif /* ITagDictionary_FWD_DEFINED */

•ifndef ISpβcifyTagAttributes_FWD_DEFINED

•define ISp*cifyTagAttributes_FWD_DEFINED typedef interface ISpecifyTagAttributes ISpecifyTagAttributes; •endif /* ISpecifyTagAttributes_FWD_DEFΣNED ^♦/

•ifndef ITagDictionaryDβlta_FWD_DEFINED

•define ΣTagDictionaryDβlta_FWD_DEFINED typedef interface ITagDictionaryDelta ITagDictionaryDelta; •endif /* ITagDictionaryDelta FWD DEFINED */

5 •ifndef __:TagBrowserDlg_FWD_DEFINED

•def ne ITagBrowserDlg_FWD_3EFINED typedef interface ITagBrowserDlg ITagBrowserDlg,- •endif /* lTagBrowserDlg_FWD_DEFINΞD */

•ifndef _ITagDefinition_F D_DEFINED

•define ITagDefιnιt on_FWD_DEFINED typedef interface ITagDe inition ITagDefinition; •endif /* ITagDefinitιon_FWD_DEFINED ^»/

•ifndef ITagDictionaryManager_FWD_DEFINED

•define ITagDictionaryManager_FWD_DEFINED typedef interface ITagDictionaryManager ITagDictionaryManager; •endif /* ITagDictionaryManager_FWD_DEFINED */

•ifndef ITagTypβ_FWD_DEFINED

•define ITagTvp«.~F D~DEFINED__ typedef interface ITagType ITagType; ttendif /* ITagTypβ_FWD_DEFINED */

ttifndef IDotField_FWD_DEFINED ttdefine IDotField~FWDJ3EFINED typedef interface IDotField IDotField; ttendif /* IDotField FWD DEFINED

ttifndef IEnumTagTypes_FWD_DEFINED ttdefine IEnumTagTypes_FWD_DEFINED typedef interface ΣEnumTagTypβs ΣEnumTagTypes ; •endif /* ΣEnumTagTypes_FWD_DEFINED */

ttifndef IEnumDotFields_FWD_DEFINED

•define ΣEnumDotFiβlds_FWD_DEFINED typedef interface lEnumDotFields lEnumDotFields; ttendif /* lEnumDotFields FWD DEFINED */

ttifndef ITagDictionary_F D_DEFINED

•define ITagDictionary_FWD_DEFINED typedef interface ITagDictionary ITagDictionary; •endif /• ITagDictionary_FWD_DEFINED */

ttifndef ISpecifyTagAttributes_FWD_DEFINED ttdefine ISpecifyTagAttributes_FWD~DEFINED typedef interface ISpecifyTagAttributes ISpecifyTagAttributes; ttendif /* ISpecifyTagAttributes_FWD_DEFINED */

ttifndef IDotField_FWD_DEFINED

•define IDotField_FWD_DEFINED typedef interface IDotField IDotField;

°.£ • endi f - * IDotField FWD DEFINED

•ifndef _ITagType_FWD_DEFINED__

•define ITagType_FWD_DEFINED typedef interface ITagType ITagType; •endif /* __ITagType_FWD_DEFINED__ ^♦/

•ifndef ITagDef inition_FWD_DEFINED

•define ITagDefinition_FWD_DEFINED typedef interface ITagDefinition ITagDefinition; •endif /* ITagDe initιon_FWD_DEFINED */

*ifndef ITagDic ionaryManager_FWDJ-EFINED

•define ITagDιctionaryManager_FWD_DEFINED typedef interface ITagDictionaryManager ITagDictionaryManager; •endif /* ITagDictionaryManagβr_FWD_DEFINED */

ttifndef ITagBrowsβrDlg_FWD_DEFINED ttdefine ΣTagBrowserDlg_FWD_DEFΣNED typedef interface ITagBrowserDlg ITagBrowserDlg; ttendif /* ITagBrowserDlg._FWD_DEFINED */

/* header files for imported files */ ttmclude "oaidl.h" void RPC_FAR ^« RPCJJSER MIDL_usβr_allocate (sizβ_t) ; void RPCJJSER MIDL_user_free ( void __RPC_FAR * ) ;~^"

/**** * *^♦•••••*•••*•*••••*•#*•#

* Generated header for interface: MIDL_itf_TagIDL_0000

* at Mon Dec 22 IS: 10: 33 1997

* using MIDL 3.01.75 * * * * ^♦*/

/* [local] */

////////////////////////////////////// // onderware Tag Dictionary IDL // //////////////////////////////////////

extern RPC_IF_HANDLE MIDL_itf_TagΣDL_0000_v0_0 -_if3pec; extern RPC~IF_HANDLE MIDL_itf_TagIDLJ.OO0~vOJ-_3_i spec; tti ndef IEnumTagTypes_INTERFACE_DEFINED

•define IEnumTagTypes~INTERFACE_DEFINED

/ •♦•••** *.***..*.#*#•**.•..*...

* Generated header for interface: IEnumTagTypes

^<W- • at Mon Dec 22 15:13:33 1997

* using MIDL 3.01.75 /

/* ['unique] [helpstring] [uuid] [object] */

EXTERNJ. const IID IID_IEnumTagTypes;

•if defined! cplusplus) 4i :defined(CINTERFACE) interface DECLSPEC_UUID ( "39cacdaO-cS6a-lldO-302f -00a0248 e0ba" ) ISnumTagTypes : public lUnknown

( public: virtual /* [local] */ HRESULT STDMETHODCALLTYPE Next ( /* [in] */ ULONG celt,

/* [out] */ ITagType RPC_FAR * RPC_FAR *rgelt,

/* [out] */ ULONG RPC_FAR *pceltFetched) - 0; virtual HRESULT STDMETHODCALLTYPE Skip ( /* [in] */ ULONG celt) - 0 ; virtual HRESULT STDMETHODCALLTYPE Rese ( void) - 0; virtual HRESULT STDMETHODCALLTYPE Clone (

/* [out] */ IEnumTagTypes RPC_FAR * RPC_FAR *ppenum) - 0;

}; •else /* C style interface */ typedef struct I-.numTagTypβsVtbl

{

BEGIN_INTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QueryInterface ) (

ΣEnumTagTypβs RPC_FAR * This,

/* [in] */ REFIID rϊid,

/* [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRβf ) (

IEnumTagTypes RPC_FAR * This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Release ) (

IEnumTagTypes RPC_FAR * This) ;

/* [local] */ HRESULT ( STDMETHODCALLTYPE RPC_FAR *Next ^{) (}

IEnumTagTypes RPC_FAR * This,

/* [in] */ ULONG celt,

/* [out] ^■*/ ITagType RPC_FAR * RPC_FAR *rgelt,

/* [out] */ ULONG RPC_FAR *pceltFetched) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Skip ) ⁽

IEnumTagTypes RPC_FAR * This,

/* [in] */ ULONG celt) ;

<\^<2 HRESULT ( STDMETHODCALLTYPE RPC_FAR 'Reset ) (

IEnumTagTypes RPC_FAR * This) ;

HRESULT ⁽ STDMETHODCALLTYPE __RPC_FAR 'Clone ) (

IEnumTagTypes RPC_FAR * This,

/* [out] */ IEnumTagTypes RPC_FAR *_RPC_FAR *ppenum) r.NDJ.MTERFACE } IΞnumTagTypesVtbl; interface IEnumTagTypes

(

CONST VTBL struct IEnumTagTypesVtbl RPC FAR *lpVtbl;

}^;

ttifdef COBJMACROS

•define ΣEnumTagTypes_QuβryInterfacβ (This, riid.ppvObject) \ (This) ->lpVtbl -> Querylnterface (This, riid.ppvObject) ttdefine IEnumTagTypes_AddRef (This) \ (This) - lpvtbl -> AddRβf(This) ttdefine IEnumTagTypes_Releasβ(This) \ (This) ->lpVtbl ->~Relβasβ(This)

ttdefine IEnumTagTypβs_Nβxt (This, celt, rgelt,pceltFetched) \ (This) ->lpVtbl ->~Next (This, celt, rgelt, celtFetched)

•define IEnumTagTypes_Skip (This, celt) \ (This) ->lpVtbl ->~Ski (This, celt)

•define IEnumTagTypes_Rβsβt (This) \ (This) ->lpvtbl ->~Rβββt(This) ttdefine IEnumTagTypβs_Clonβ (This, ppenum) \ (This) ->lpVtbl ->~Clon*(This,ppenura) ttendif /* COBJMACROS */

•endif /• C style interface */

/* [call_as] */ HRESULT STDMETHODCALLTYPE lEnumTagTypea_RemoteNext_Proxy⁽

IEnumTagTypes RPC_FAR * This,

/* [in] */ ULONG ceϊt,

/* [length_is] [sizβ_is] [out] */ ITagType _RPC_FAR *__RPC_FAR *rgelt,

/* [out] */ ULONG __RPC_FAR "pceltFetched) ;

void RPC_STUB IEnumTagTypes_RemoteNext_Stub( IRpcStubBuffer *Thιs, RpcChannelBu fer *_pRpcChanr.ei3u fer.

?RPC_MESSAGE _pRpcMessage,

DWORD ^»_ρdwStubPhase) ,^•

HRESULT STDMETHODCALLTYPE IEnumTagTypes_3kιp ³roxy (

IEnumTagTypes RPCJΑR * This,

/* [m] ^•/ ULONG celt) ;

void RPC_STUB IEnumTagTypes_Skιp_Stub (

IRpcStubBu fer *This,

IRpcChannelBuf er *_pRpcChannelBuf er, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE IEnumTagTypes_Reset_Proxy( IEnumTagTypes RPC_FAR * This) ;

void RPC_STUB IEnumTagTypes_Reset_Stub (

IRpcStubBuffer *This. IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE IEnumTagTypes_Clonβ_Proxy(

IEnumTagTypes RPC_FAR * This,

/* [out] */ IEnurtTagTypes RPC_FAR * RPC_FAR *ppβnum) ;

void RPC_STUB IEnumTagTypes_Clone_Stub (

IRpcStubBu fer *This,

IRpcChannelBuffer *_pRpcChannβlBuffer, PRPC_MESSAGE _pRpcMβssagβ, DWORD *_pdwStubPhase) ;

ttendif /* IEnuπrTagTypeβ_ΣNTERFACE_DEFINED_,

•ifndef IEnumDotFields_lNTERFACE_DEFINED ttdefine IEnumDotFields~INTERFACE~DEFINED__

/ *.•#•#*•*•#♦•##♦•#••••#*^♦ **

* Generated header for interface: lEnumDotFields

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.7S

********* ***** *^♦#•^♦*•*•*.*^♦*/

/* [unique] [helpstring] [uuid] [object] */

•λco ΞXTSRN_C const IID IID_IEnumDotFields ;

•if defined( cplusplus) && : defined (CINTERFACE) interface DECLSPEC JUID("39cacdal-c66a-lld0 -902f -00a0243fe0ba") lEnumDotFields : public lUnknown

{ public : virtual /* ^'.local] */ HRESULT STDMETHODCALLTYPE Next ( /• [in] */ ULONG celt,

/* [out] ^♦/ IDotField RPC_FAR * RPC FAR *rgelt,

/* [out] ^♦/ ULONG RPC_FAR~*pceltFetched) - 0; virtual HRESULT STDMETHODCALLTYPE Skip ( /* [in] */ ULONG celt) - 0; virtual HRESULT STDMETHODCALLTYPE Reset! void) - 0; virtual HRESULT STDMETHODCALLTYPE Clone (

/^« [out] */ lEnumDotFields RPC_FAR * RPC_FAR *ppβnum) - 0;

•else /* C style interface */ typedef struct IEnumDotFieldsVtbl

{

BEGIN_ΣNTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QuβryInterfacβ ) ( lEnumDotFields RPC_FAR * This,

/* [in] ♦/ REFIΣD riϊd,

/* [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRef ) ( lEnumDotFields RPC_FAR * This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Releaaβ ) ( lEnumDotFields RPC_FAR * This) ;

/* [local] */ HRESULT ( STDMETHODCALLTYPE RPC_FAR *Next ^{) (} lEnumDotFields RPC_FAR * This,

/* [in] */ ULONO celt,

/* [out] */ IDotField RPC_FAR * RPC_FAR *rg^βlt,

/* [out] */ ULONG RPC_FAR~*pceltFetched) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'Skip ) ( lEnumDotFields RPC_FAR * This,

/* [in] */ ULONO celt) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Reset ^{) (} lEnumDotFields RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Clonβ ^{) (} lEnumDotFields RPC FAR * This,

/* [outl */ lEnumDotFields RPC_FAR * RPC_FAR *ppenum^{) ;} ΞNDJ.NTERFACS } IEnumDotFieldsVtbl ; interface lEnumDotFields {

CONST JTTBL struct IEnumDotFieldsVtbl RPC_FAR *lpVtbl ;

•ifdef COBJMACROS

•define IEnumDotFields_QueιryInterface (This, riid.ppvObject) \ (This) ->lpvtbl -> Querylnterface (Thiβ, riid.ppvObject)

•define IEnumDotFields_AddRe (This) \ (This) ->lpVtbl -> AddRef(This) ttdefine lEnumDotFields .eleasβ (This) \ (This) ->lpVtbl -> Release(This)

•define IEnumDotFields_Next (This, celt, rgelt, pceltFetched) \ (This) ->lpvtbl -> Next (This-, celt, rgelt, pceltFetched)

•define IEnumDotFields_Ski (This, celt) \ (This) ->lpVtbl -> Skip (This, celt)

•define IEnumDotFields_Rese (This) \ (This) ->lpVtbl -> Reset (This)

•define lEnumDotFields -lonβ (This, ppenum) \ (This) ->lpVtbl -> Clone (This, ppenum)

•endif /* COBJMACROS */

•endif /* C style interface */

/* [call_as] ♦/ HRESULT STDMETHODCALLTYPE IEnumDotFields_RemoteNext_Proxy⁽ lEnumDotFields RPC_FAR * This,

/* [in] */ ULONO celt,

/* [length is] [size_is] [out] */ IDotField RPC_FAR *_RPC_FAR *rgelt,

/* [out] *7 ULONO __RFCJ*AR *pceltFetched) ;

void RPC_STUB IEnumDotFiβlds_RemoteNext_Stub (

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE jpRpcMessagβ, DWORD *_pdwStubPhase) ;

HRESULT STDMETHODCALLTYPE IEnumDotFields_Skip_Proxy (

o?, lEnumDotFields RPC FAR • This,

/• [ n] */ ULONG celt) ;

void __R?C_STUB IΞnumDotFields_Skip_3tub( IRpcStubBu er ^»Thi3, IRpcChannelBuffer *_pRpcChannelBuffer, PRPCJ'.ESSAGE _?RpcMessage, DWORD * odwStuoPhase) ;

HRESULT STDMETHODCALLTYPE IEnumDotFields_Reset_Proxy ( lEnumDotFields RPC FAR * This) ,•

void RPC_STUB IEnumDo Fields_Resβt_S ub (

IRpcStubBuffer *This,

IRpcChannelBuffer *_pRpcChannβlBuffer,

PRPC_MESSAGE _pRpcMessagβ,

DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE IEnumDotFiβlds_Clone_Proxy( lEnumDotFields RPC_FAR * This,

/* [out] */ lEnumDotFields RPC_FAR * RPC_FAR *ppenum)

void RPC_STUB ΣEnumDotFields_Clone_Stub(

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE jpRpcMβssagβ, DWORD *_pdwStubPhase) ;

•endif /* lEnumDotFields INTERFACE DEFΣNED

•ifndef ITagDictionary_INTERFACE_DEFINED ttdefine ITagDictionary_INTERFACE_DEFINED

/******* **** *^•##•^♦*#^##*•*^#•••*••

* Generated header for interface: ITagDictionary

* at Mon Dec 22 13:10:33 1997

* using MIDL 3.01.75

* * *••.--•.«*.**^#.•***.^#♦.../

/* [unique] [hβlpstring] [uuid] [object] */

typedef /* [vl_enum] */ enum tagWWImageType

{ IMGTYPE_SMALL - 16, IMGTYPE_BIG - 32

} WWImageType; typedef struct tagWWFilterElement {

0 DWORD Un quelD; LPOLESTR pFilterString; OLECHAA MultiChar;

OLECHAR SingleChar; boolean bCas^βSensitive; CLECHAR Placeholder; DWORD Reserved; } WWFilterEIement; typedef struct tagWWFilterSpecification

{

LPOLESTR pExpression;

DWORD Count;

/* [size_is] */ WWFilterEIement RPC_FAR *pFilterElements;

} WWFilterSpecification;

EXTERN_C const IΣD IID_ITagDictionary; ttif dβfin*d( cplusplus) && !defined(CINTERFACE) interface DECLSPEC_UUID(^,,39cacda2-c66a-lld0-8O2f-00aO248fβOba") ITagDictionary : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE Open( /* [in] */ LPCOLESTR dataSourcβ) - 0; virtual HRESULT STDMETHODCALLTYPE Close ( void) - 0; virtual HRESULT STDMETHODCALLTYPE GatDisplayNamβ (

/* [outl <*/ LPOLESTR RPC_FAR *ppDisplayNam#) - 0; virtual HRESULT STDMETHODCALLTYPE GetDataSourceControlClsid( /* [out] */ GUID RPC_FAR ^»pClsid) - 0; virtual HRESULT STDMETHODCALLTYPE GetlmageList ( /* [in] */ wwiraagβTyp* imgType, /* [in] */ IStream RPC_FAR 'pStream) - 0; virtual HRESULT STDMETHODCALLTYPE Getlmagelndex(

/* [out] */ long RPC_FAR *pDβfImgΣndβx,

/* [optional! [outl */ long RPC_FAR *pSβllmgΣndex) - 0; virtual HRESULT STDMETHODCALLTYPE GβtTagFroraΣD( /* [in] */ DWORD ΣD. /* [outl */ ITagDefinition RPC_FAR * RPC_FAR *ppTag⁾ - 0; virtual HRESULT STDMETHODCALLTYPE GetTagTypeEnum⁽

/* [out] */ IEnumTagTypes RPC_FAR * RPC_FAR *ppEnumTagType⁾ - virtual HRESULT STDMETHODCALLTYPE GetTaglDs (

/* [in] */ WWFilterSpecification RPC_FAR *pFilters,

/* [size_is] [size_is] [out] */ DWORD _RPC_FAR *__RPC_FAR *ppIDs, /* [outl^"*/ long __RPC_FAR *pCount) ■ 0;

}; •else /* C style interface */ typedef struct ITagDictionaryVtbl

(

3EGIN_INTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QueryInterf ce ) (

ITagDictionary RPC_FAR ^• This,

/* [in] */ REFIID riϊd,

/* [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRef ) (

ITagDictionary RPC_FAR ^♦ This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Release ) (

ITagDictionary RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Opβn ) (

ITagDicrionary RPC_FAR * This,

/* [in] */ LPCOLESTR dataSource) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Closβ ) (

ITagDictionary RPC_FAR • This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetDisplayNamβ ) (

ITagDictionary RPC_FAR * This,

/* [out] */ LPOLESTR- RPC_FAR *ppDisplayNamβ) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtDataSourcβControlCl3id ) (

ITagDictionary RPC_FAR * This,

/* [out] i*/ GUID RPC_FAR *pClsid) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtImageList ) (

ITagDictionary RPC_FAR * This,

/* [in] */ WWImageType imgType,

/* [in] */ IStream RPC_FAR *pStream) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetΣmagβΣndex ) (

ITagDictionary RPC_FAR * This,

/* [out] */ long RPC_FAR *pDβfImglndex,

/* [optional] [out] */ long RPC_FAR *pSβlΣmgIndβx) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtTagFromΣD ) (

ITagDictionary RPC FAR * This,

/* [in] */ DWORD ID,^"

/* [out] */ ITagDefinition RPC_FAR * RPC_FAR *ppTag) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetTagTypβBnum ⁾ (

ITagDictionary RPC_FAR * This,

/* [out] */ IEnumTagTypes RPC_FAR * RPC_FAR *ppEnumTagType⁾ ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtTagID^{β )} (

ITagDictionary RPC_FAR * This,

/* [in] */ WWFilterSpecification RPC_FAR *pFilt^βrs,

/* [size_is] [size_is] [out] */ DWORD __RPC_FAR * RPC_FAR *ppIDs,

/ * [out] ^"*/ long RPC_FAR * pCount) ;

Λ£>5 END_INTERFACE } ITagDictionaryVtbl; interface ITagDictionary

{

CONST VTBL struct ITagDictionaryVtbl RPC FAR ^»lpVtbl;

}^;

•ifdef COBJMACROS

•define ITagDictionary_QuβryΣnterface (This, riid.ppvObject) \ (This) ->lpVtbl -> Querylnterface (This, riid.ppvObject)

•define ITagDictionary_AddRef (This) \ (This) ->lpVtbl -> AddRβf(This) ttdefine ITagDictionary_Rβleasβ(This) \ (This) ->lpVtbl -> Rβlβasβ(This)

ttdefine ITagDictionary_Opβn (This, datasource) \ (This) ->lpVtbl -> Ope (This, datasource) ttdefine ITagDictionary -losβ (This) \ (This) ->lpvtbl -> c osβ(This) ttdefine ITagDictionary_GβtDisplayName (This, ppDisplayNamβ) \ (This) - >lpVtbl - * GβtDisplayNamβ (This, ppDisplayNamβ) ttdefine ITagDictionary_GβtDataSourceControlClsid(This, Clsid) \ (This) ->lpVtbl -> GetDataSourceControlClsid(This,pClsid) ttdefine ITagDictionary_GetImageLis (This, imgTypβ,pStream) \ (This) ->lpvtbl -> GetlmageLis (This, imgTypβ,pStream) ttdefine ΣTagDictionary 3βtImageIndex (This, pDefImglndex, pSβllmgΣndex⁾ (This) ->lpVtbl -> Getlmagelndex(This,pDefImglndex, pSellmglndex) ttdefine ITagDictionary_GβtTagFromID (This, ID, ppTag) \ (This) ->lpVtbl -> GetTagFromlD (This , ID, ppTag)

•define ΣTagDictioriaryJSβtTagTypeEnum (This, ppEnumTagTypβ) \ (This) ->lpVtbl -> GetTagTypeEnum(This. ppEnumTagTypβ⁾ ttdefine ITagDictionary_GβtTagIDs (This, Filters.ppΣDs,pCount) \ (This) ->lpVtbl -> GetTaglDs (This, pFiltars.ppIDs,pCount) ttendif /* COBJMACROS */

ttendif /* C style interface */

ΛΩ6 HRESULT STDMETHODCALLTYPE ITagDιctιonary_Open_?roxy (

ITagDictionary RPC_FAR * This,

/» [in] ^•/ LPCOLESTR~dataSource) ;

void RPC_5TUB ITagDictionary_Open_Stub(

IRpcStubBuffer *This,

IRpcChannelBuffer *_pRpcChannelBu fer, ?RPC_MESSAGE _pRpcMessage , DWORD *_pdwStubPhase) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_Close_Proxy ( ITagDictionary RPC_FAR * This) ;

void RPC_STUB ITagDictionary_Close_Stub(

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannβlBuf*er, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GβtDisplayNamβ_Proxy(

ITagDictionary RPC_FAR * This,

/* [out] */ LPOLESTR- RPC_FAR *ppDisplayNamβ) ;

void RPC_STUB ITagDictionary_GβtDiaplayName_Stub(

IRpcStubBuf er *This,

IRpcChannelBuffe» *_pRpcChannelBuffer, PRPC_MESSAGE jpRpcMessagβ. DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GβtDataSourceControlClsid_Proxy(

ITagDictionary RPC_FAR * This,

/* [out] */ GUID __RPC_FAR *pClsid) ;

void RPC_STUB ITagDictionaryJ3βtDataSourceControlClsid_Stub (

IRpcStubBuffer *Thiβ, IRpcChannβlBuffβr *_pRpcChannelBuffer, PRPC_MESSAGB _pRpcMβasagβ, DWORD *_pdwStubPhaββ) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GetImageList_Proxy⁽

ITagDictionary RPC_FAR * This,

/* [in] */ WWImageType imgType,

/* [in] */ IStream RPC_FAR *pStream) ;

void RPC_STUB ITagDictionary_GetImageList_Stub(

IRpcStubBuf er *This,

IRpcChannelBuf er *_pRpcChannelBuffer, ?RPC_ME55AGE _?RpcMessage, DWORD *_pdwStubPhase) ,^•

HRESULT STDMETHODCALLTYPE ITagDictionary_Ge mageIndex_Proxy(

ITagDictionary RPCJ*AR * This,

/* [outl •/ long RPC_FAR *pDefImglndex,

/* ^".optional] [out] */ long RPC_FAR *pSelImglndex) ,-

void RPC_STUB ITagDictionary_GetImageIndex_Stub(

IRpcStubBuffer *This, IRpcChannelBu fer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GetTagFromID_Proxy(

ITagDictionary RPC_FAR * This,

/* [in] */ DWORD ID,^"

/* [out] */ ITagDefinition RPC_FAR * RPC_FAR *ppTag) ;

void RPC_STUB ITagDictionary_GetTagFromID_Stub(

IRpcStubBuffer *This,

IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessagβ, DWORD *_pdwStubPhasβ)^' ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GβtTagTypeEnum_Proxy( ITagDictionary __RPC_FAR * This, /* [outl */ IEnumTagTypes RPC_FAR * RPC_FAR *ppEnumTagTypβ)

void RPC_STUB ITagDictionary_GβtTagTypeEnum_Stub(

IRpcStubBuffer *This, IRpcChannelBuffβr *_pRpcChannβlBu fer, PRPC_MESSAGE _pRpcMββsagβ, DWORD *_pdwStubPhaaβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionary_GetTagIDs_Proxy(

ITagDictionary RPC_FAR * This,

/* [in] */ WWFilterSpecification RPC_FAR *pFilters,

/* [sizβ .β] [sizβ_is] [out] */ DWORD RPC_FAR * RPC_FAR *ppIDs,

/* [out]-*/ long __RPC_FAR *pCount) ;

void RPC_STUB ITagDictionary_GetTagIDs_Stub(

IRpcStubBu fer *This, IRpcChannelBuffer *_pRpcChannelBu fer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhasβ) ;

θ •endif ^» ITagDιctιonary_INTERFACE DEFINED

• ifndef :SpecifyTagAttributes_INTSRFACSJ-EFINED

•def ine __:3pecifyTagAttr butes_INTERFACE_DEFINED

/****•******"" *"""***"""*"***

* Generated header for interface: ISpecifyTagAttributes

* at Mon ec 22 15:13:33 1997

* using MIDL 3.31.75 ********************.../

/ * (unique] [helpstring] [uuid] [obj ect] */

typedef / * [vl_enum] */ enum tagWWAttributβΣD

{ ATTRIBID_FULLYQUALIFIED_NAME - 0 ,

ATTRIBID_HIERARCHICAL_NAME « ATTR∑aiD_FULLYQUALIFIED_NAME * 1.

ATTRIBID_TYPE - ATTRIBID_HIERARCHICAL_NAME + 1 ,

ATTRIBIDJ OMMENT « ATTRIBID JTYPE + 1,

AττRIBΣD_AI-ARM_GROUP - ATTRIBID JIOMMENT * 1 ,

ATTRΣBΣD_DDE_ACCESS_NAME - ATTRIBID_ALARM_GROUP * 1 ,

ATTRIBΣDJ-OGGED --ATTRΣBΣD_DDE_ACCESS_NAME J~l,

ATTRΣBΣD rESTED - ATTRΣBΣD~LOGGED + l7

ATTRIBIDJSXPANDABLE « ATTRIBIDJTESTED * 1 ,

ATT IB D-UDT_INSTANCE - ATTRIBID_EXPANDABLB * 1,

ATTRIBΣD IAX- - ATτRΣBΣD_UDτ_INSTANCE + 1

} WWAttributβΣD; typedef struct tagWWExtendedAttribute

{

LPOLESTR pAttribute;

DWORD uniqueΣD;

} WWExtendβdAttributβ;

EXTERN_C const IID IΣD_ΣSpβcifyTagAttributes;

•if defined( cplusplus) &6 !defined(CINTERFACE) interface DECLSPEC_UUID("07F432AO-DC66-lldO-803B-OOA0248FEOBA") ISpecifyTagAttributes : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE GβtAttributes (

/* [sizβ_is] [sizβ_is] [out] */ WWExtendβdAttribute RPC_FAR

* RPC_FAR *attrib,

/* [out] */ DWORD RPC_FAR *pCount) - 0; virtual HRESULT STDMETHODCALLTYPE SetLCID( /* [in] */ LCID locallD, /* [out] */ LCΣD RPC_FAR *p01dlocallD) - 0; virtual HRESULT STDMETHODCALLTYPE GetLCID(

/* [out] */ LCID RPC_FAR *plocalID) » 0;

&\ •else /* 0 style interface */ typedef struct ISpecifyTagAttributesvtbl

{

3EGIN_INTERFACS

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QueryInterface ) (

ISpecifyTagAttributes RPC_FAR ♦ This,

/* [in] */ REFIID riid,

/• [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRef ) (

ISpecifyTagAttributes RPC~FAR » This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Releasβ ) (

ISpecifyTagAttributes RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtAttributβS ) (

ISpecifyTagAttributes RPC_FAR * This,

/* [sizβ_is] [sizβ_is] [out] */ wwExtβndedAttributβ RPC_FA

* RPC FAR *attrib,

/* [out] */ DWORD RPC_FAR *pCount) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *SetLCID ) (

ISpecifyTagAttributes RPC_FAR * This,

/* [in] */ LCID locallD,

/» [out] •/ LCID RPC_FAR *pOldlocalID) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtLCΣD ) ( SpecifyTagAttributes RPC_FAR * This,

/* [out] !*/ LCID RPC_FAR *plocalID) ;

END_INTERFACB } ISpecifyTagAttributesvtbl; interface ISpecifyTagAttributes

{

CONST VTBL struct ISpecifyTagAttributesvtbl RPC FAR *lpvtbl;

}^;

•ifdef COBJMACROS

•define ISpβcifyTagAttributβs_QueryInterfacβ (This, riid.ppvObject) \ (This) ->lpVtbl -> Querylnterface (This, riid.ppvObject)

•define iSpecifyTagAttributes_AddRef (This) \ (This) ->lpvtbl -> AddRβf(This)

•define ISpecifyTagAttributes_Release(This) \ (This) ->lpvtbl -> Releasβ(This)

•define ISpecifyTagAttributes_GetAttributes (This, attrib, pCount⁾ \ (This) - >lpvebi -> SetAttπbutes ⁽This , attrib. pCount)

•define ISpecifyTagAttrιbutes_SetLCID ⁽This, locallD, pOldlocallD) (This) ->lρVtbl -> SetLCID (This. ocallD, OldlocallD)

•define ISpecifyTagAttrιbutes_GetLC:D (This, locallD) \ (This) ->lpVtbl -> GetLCID~Thιs, locallD)

•endif /* C3 MACROS */

•endif /* C style interface */

HRESULT STDMETHODCALLTYPE ΣSpecifyTagAttributes_GetAttributes_Prαxy (

ISpecifyTagAttributes RPC_FAR * This,

/* [sizβ_is] [size_is] [out] */ wwExtendedAttribute RPC_FAR * RPC_?AR

•attrib,

/* [out] ^♦/ DWORD RPC_FAR *pCount) ;

void RPC_STUB ISpβcifyTagAttributes_GβtAttributes_Stub(

IRpcStubBu fer *This, IRpcChannelBuf er *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMβssagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ISpecifyTagAttributes_SβtLCID_Proxy(

ISpecifyTagAttributes RPC_FAR * This,

/* [in] */ LCID locallD.

/* [out] */ LCID RPC_FAR *pOldlocalID) ;

void RPC_STUB ISpecifyTagAttributes 3etLCΣD_Stub(

IRpcStubBuffer *This,

IRpcChannelBuffer *_pRpcChannβlBu fer, PRPC_MESSAGE _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ISpβcifyTagAttributes_GβtLCID_Proxy(

ISpecifyTagAttributes RPC FAR * This,

/* [out] •/ LCID RPC_FAR *plocalID) ;

void RPC_STUB ISpecifyTagAttributes_GetLCΣD_Stub(

IRpcStubBuffer *This, ΣRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessagβ, DWORD *_pdwStubPhase) ;

ttendif /♦ ISpecifyTagAttributes_INTERFACE_DEFΣNED

⁽MA •ifndef ITagO ctιonaryD^βlta_INTERFACE_DEFΣNED

•define ITagDict onaryOelta_INTERFACE_DEFINED

* Generated header for interface: ITagDictionaryDelta

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.75 /

/* [unique] helpscπng] [uuid] [object] */

typedef /* [vl_enum] */ enum tagWWResetDelta

{ RESETJΪEW_IDS - 1,

RESET 3ELITED_IDS - RESET_NEW_ΣDS +• 1, RESET~ALL_IDS~ - RESET_DELETED_IDS * 1 } wwResetDelta;

EXTERNjC cc.st 1ΣD IΣD_ITagDictionaryDelta; ttif defined( cplusplus) ->& ! defined (CINTERFACE) interface DECLSPECJJUID⁽"C9--FAA60-D88E-Hd0-803A-OOA0248FEOBA") ITagDictionaryDelta ; public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE ResetDelta ( /* [in] */ WWResetDelta enumReset) - 0; virtual HRESULT STDMETHODCALLTYPE GetNewlDs (

/* [in] *7 WWFilterSpecification RPC_FAR *pFilter,

/* [in] */ boolean bReset,

/* [size_is] [sizβ_isl [out] */ DWORD RPC_FAR * RPC_FAR *ppΣDs,

/* [out]^"*/ long RPC_FAR *pCount) - 0; virtual HRESULT STDMETHODCALLTYPE GetDeletedlDs ( /* [in] */ boolean bReset,

/* [sizβ_is] [sizβ_isl [out] */ DWORD RPC_FAR * RPC_FAR *ppΣDs,

/* [out]^"**/ long __RPC_FAR *pCount) - 0;

}; •else /* C style interface */ typedef struct ITagDictionaryDeltaVtbl

{

8EGIN_ΣNTERFACB

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QuβryΣnterfacβ ) (

ITagDictionaryDelta RPC_FAR * This,

/* [in] */ REFIID riid,

/* [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject⁾ ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRβf ) (

ITagDictionaryDelta RPC_FAR * This) ;

ΛAZ ULONG ⁽ STDMETHODCALLTYPE __R?C_FAR *Release ) ( ITagDictionaryDelta R?C_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE _RPC_FAR 'ResetDelta ) (

ITagDictionaryDelta RPC ^AR-* This,

/^♦ [in] */ wwResetDelta enumReset) ;

HR-.SULT ( STDMETHODCALLTYPE RPC_FAR *GetNewIDs ) (

ITagDictionaryDelta RPC_FAR * This,

/* [in] ^•/ WWFi^'- -^Specification RPC_FAR 'pFilter,

/* [in] */ bool.--.n bReset,

/* [sizβ_is] [3ize_is] [out] */ DWORD RPC_FAR * RPC_FAR 'pplDs,

/* [out] */ long RPC_FAR *pCount) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'GetDeletedlDs ) (

ITagDictionaryDelta RPC_FAR * This,

/* [in] */ boolean bReset?

/* [size_is] [size_is] [out] */ DWORD RPC_FAR * RPC_FAR 'pplDs,

/* [out]-*/ long __RPC_FAR *pCount) ;

END_INTERFACE } ITagDictionaryDβltaVtbl; interface ITagDictionaryDelta

{

CONSTJ/TBL struct ITagDictionaryDβltaVtbl RPC_FAR *lpVtbl;

•ifdef COBJMACROS

•define ITagDictionaryDelta_QueryInterface (This, riid,ppvObject) \ (This) ->lpvtbl -> Querylnterface (This, riid.ppvObject)

•define ITagDictionaryDβlta_AddRβf (This) \ (This) ->lpVtbl -> AddRβf(This)

•define ITagDictionaryDβlta_Releasβ (This) \ (This) ->lpVtbl -> Rβleasβ(This)

•define ITagDictionaryDβlta_ResetDelta (This, enumReset) \ (This) ->lpVtbl -> ResetDelta (This, enumReset)

•define ITagDictionaryDelta_GβtNβwΣDs (This, pFilter, Aesβt,pplDs, pCount⁾ \ (This) ->lpVtbl -> GetNewlDs (This, pFilter, bReset, pplDs,pCount)

•define ITagOictionaryDelta_GetDeletedIDs (This, bReset, ppΣDs,pCount⁾ \ (This) ->lpvtbl -> GetDeletedlDs (This, bReset, ppΣDs, pCount⁾ ttendif /* COBJMACROS */

•endif /* C style interface */

Λ HRESULT STDMETHODCALLTYPE ITagDιctιonaryDelta_ResetDelta_Proxy (

ITagDictionaryDelta RPC_FAR * This,

/* [in] */ wWResetDelta enumReset);

vo d RPC_STU3 ITagD ctionaryDelta_ResetDelta_Stub(

IRpcStubBuffer *This, IRpcChannelBu fer *_pRpcChannelBuffer, ?R?C_MESSAGE _?RpcMessage, DWORD ^«_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionaryDelta_GetNewIDs_Proxy(

ITagDictionaryDelta RPC_FAR * This,

/^» [in] */ WWFilterSpecification RPC_FAR *pFilter,

/* [in] */ boolean bReset,

/* [3ize_is] [size_is] [out] -/ DWORD RPC_FAR * RPC_FAR *ppIDs,

/* [out]-*/ long __RPC_FAR *pCount) ;

void RPC_STUB ITagDictionarγDelta_GβtNewIDs_Stub(

IRpcStubBuffer *This,

IRpcChannelBuffer *_pRpcChannelBuffer, PRPCJfESSAGE _jpRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDictionaryDβlta_GβtDeletedlDβ_Proxy(

ITagDictionaryDelta RPC_FAR * This,

/* [in] */ boolean bReset,

/* [size_is] [size_is] [out] */ DWORD RPC_FAR * RPC_FAR *ppIDs,

/* [out]-*/ long __RPC_FAR *pCount) ;

void RPC_STUB ITagDictionaryDβlta_GβtDβletedlDs_Stub(

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannβlBuffer, PRPC_MESSAGE jpRpcMβsβagβ, DWORD *_pdwStubPhasβ) ;

ttendif /* ITagDictionaryDelta_INTERFACE_DEFINED_

•ifndef ITagBrowsβrDlg_INTERFACE_DEFINED ttdefine lTagBrowsβrDlg-INTERFACE-DEFΣNED

/**************** •**•***.*••**•*•^#«•

* Generated header for interface: ITagBrowserDlg

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.75 ******.*** **** */

/* [unique] [helpstring] [uuid] [object] */

ML, EXTERN C const IID IID_ITagBrowserDlg ;

• if ^■ .f ined ! cplusplus) -.-. : defined (CINTERFACE) interf ace CECL3PECJ UID ( " 39cacda3 -c66a- lld0 - 302 f - 00a0248f eOba" ) ITagBrowserDlg : public lUnknown

{ . public : virtual HRESULT STDMETHODCALLTYPE Init (

/* [in] */ ITagDictionary RPC_FAR 'pTagDictionary,

/* [in] */ WWFilterSpecification RPC_FAR 'pFilter) » 0 ,• virtual HRESULT STDMETHODCALLTYPE SetAecessNames ( /* [in] */ long nameCount, /* [size_is] [in] */ LPOLESTR RPC_FAR *accessNames) - 0; virtual HRESULT STDMETHODCALLTYPE DoTagPickerUI (

/* [out] */ ITagDefinition RPC_FAR * RPC_FAR 'ppSelectedTag,

/* [out] */ IDotField RPC_FAR * RPC_FAR 'ppSelectedDotField,

/* [out] */ LPOLESTR RPCJFAR 'pSelectedTagAccessName,

/* [in] */ LPCOLESTR initialAccessNamβ,

/* [in] */ LPCOLESTR initialTagNamβ,

/* [in] */ LPCOLESTR initialDotFiβld,

/* [in] */ boolean bAllowDictionarySelection,

/* [in] */ boolean bAllowDotFieldSelection,

/* [in] */ boolean bAllowExpandableTagSelection,

/* [in] */ boolean bAllowTreeNaviga ion,

/* [in] */ boolean bAllowNoneTagSeleccion,

/* (inl •/ LPCOLESTR title,

/* [in] */ HWND parenttHwnd) - 0;

}; •else /* C style interface */ typedef struct ITagBrowserDlgVtbl

{

3EGIN_1NTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QuβryΣnterface ^{) (}

ITagBrowserDlg RPC_FAR * This,

/* [in] */ REFIID rild,

/• [iid_isl [out] */ void RPC_FAR *_RPC_FAR *ppvObject⁾ ;

ULONO ( STDMETHODCALLTYPE RPC_FAR 'AddRef ^{) (}

ITagBrowserDlg RPCJFAR * This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *Rβlease ^{) (}

ITagBrowserDlg RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *Init ^{) (}

ITagBrowserDlg RPC FAR * This,

/* [inl */ ITagDictionary RPC_FAR *pTagDictionary,

/* [in] */ WWFilterSpecification RPC_FAR 'pFilter^{) ;} HRESULT ⁽ STDMETHODCALLTYPE ?.PC_FAR 'SetAecessNames ) (

ITagBrowserDlg RPC_FAR * This,

/• [in] •/ long nameCount,

/• [sιze_ s] [m] ^♦/ LPOLESTR R?c_?AR 'accessNames) ;

HRESULT ( STDMETHODCALLTYPE _RPC_FAR *DoTagPickerUI ) (

ITagBrowserDlg RPC_FAR • This, • [out] */ ITagDef ition R?C_FAR • RPC_FAR 'ppSelectedTag,

'/ IDotField RPC_FAR * RPC_?AR *ppSelectedDotFιeld,

/ * [out] * '/ LPOLESTR RPC_FAR *pSelectedTagAccessName,

/ ^» [ in] */ LPCOLESTR initialAccessName,

[ m] LPCOLESTR imtialTagName,

C m] */ LPCOLESTR i tialDotField,

/ • [in] boolean bAllowDictionarySelection,

/ * [ in] * / boolean bAllowDotFieldSelection,

/ * [ml boolean bAllowExpandableTagSelection,

/ * [ml */ boolean bAllowTreeNavigation,

/ ^• C m] * / boolean bAllowNoneTagSelection,

/ * [ml LPCOLESTR title,

/ * Cm] */ HWND parentHwnd) ;

END_INTERFACE } ITagBrowserDlgVtbl ; interface ITagBrowserDlg

{

CONST VTBL 3truct ITagBrowserDlgVtbl RPC FAR *lpVtbl;

•ifdef COBJMACROS

•define ITagBrowserDlg_QueryIntβrface (This, riid.ppvObject) \ i his) ->lpVtbl -> Querylnterface (This, md.ppvOb]ect)

•define ITagBrowsβrDlg_AddRβf (This) \ (This) -slpVtbl -> AddRβf(Thιs)

•define ITagBrowserDlg_Releasa(This) \ (This) ->lpVtbl -> Release (This)

•define ITagBrowsβrDlgJtni (Thιs.pTagDιct onary,pFιltβr) \ (This) ->lpVtbl -> Σnit(Thιs,pTagDιct onary,pFιltβr)

•define ITagBrowserDlg_SetAccessNames (Th s, nameCount, accessNames⁾ \ (This) ->lρVtbl -> letAccessNames (This, nameCount, accessNames⁾

•define

ITagBrowserDlg_DoTagPιckerUI (This , ppSelectedTag, ppSelectedDotField, pSelectedTagA ccessName, _in_it_ialAccessName, _imt_ialTagName, ιnιtιalDotFιeld,bAllowDιctιonarySelec tion, bAllowDotF_ieldSelection, bAllowExpandableTagSelection, bAllowTreeNavigation, b AllowNoneTagSelection, itle, parentHwnd) \

MG :τh s) - >lp'/tbl . _>

DoTagPickerUI ⁽This^, pSelectedTag, ppSelectedDotField, SelectedTagAccessName, ti alAccessName, imtialTagName, initialDotField, bAllowDictionar/Selection. bAliowDotF leldSelection, bAllowExpandableTagSelection, bAllowTreeNavigation, bAliowNoneTagSel ection, itle, arentHwnd)

•endif /♦ COBJMACROS */

•endif / * C style interface ^♦/

HRESULT STDMETHODCALLTYPE ITagBrowserDlg_Init_Proxy(

ITagBrowserDlg RPC_FAR * This,

/• [in] */ ITagDictionary RPC_FAR 'pTagDictionary,

/* [in] */ WWFilterSpecification RPC_FAR 'pFilter) ;

void RPC_STUB ITagBrowserDlg_Init_Stub(

IRpcStubBuffer 'This,

IRpcChannelBuffer *j?RpcChannelBu fer, PRPCJIESSAGE _pRpcMessagβ, DWORD *_pdwStubPhase) ;

HRESULT STDMETHODCALLTYPE ITagBrowserDlg_SetAccessNames_Proxy(

ITagBrowserDlg RPC_FAR * This,

/* [in] */ long nameCount,

/* [s ze is] [in] */ LPOLESTR RPC FAR *accessNames) ;

void RPC_STUB ITagBrowserDlg_SβtAccessNames_Stub(

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagBrowsβrDlg_DoTagPickerUI_Proxy(

ITagBrowserDlg RPC_FAR * This,

/ * [out] * '/ ITagDefinition RPC_FAR * RPC_FAR 'ppSelectedTag,

/ * [out] * I IDotField RPC_FAR * RPC_FAR 'ppSelectedDotField,

/ ♦ [out] * I LPOLESTR RPC_FAR *pSβlectedTagAccessNamβ,

/ ^♦ [ in] */ LPCOLESTR initialAccessName,

/ * [ in] * / LPCOLESTR initialTagName,

/ • [in] */ LPCOLESTR initialDotField,

/ * [in] */ boolean bAllowDictionarySelection,

/ * [in] * / boolean bAllowDotFieldSelection,

/ * [ ] */ boolean bAllowExpandableTagSelection,

/ * ( ml * / boolean bAllowTreeNavigation,

/ ^• [ in] * / boolean bAllowNoneTagSelection,

/ * [in] * / LPCOLESTR title,

/ * [in] * / HWND parentHwnd) ;

void R_PC_STUB ITagBrowserDlg_DoTagPickerUI_Stub( IRpcStubBu fer 'This, IRpcChannelBuffer '_pRpcChannel3uf er, ?RPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase) ;

•endif ^'* _ITagBrowserDlg_INTERFACE_DEFINED */

•ifndef ITagDefinition_INTERFACE_DEFINED

•def ne ITagDefinitιon_INTERFACE_DEFINED

/ * *^••

* Generated header for interface: ITagDefinition

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.75

****** *^#•.•••#*•^#••*••#•/

/* [unique] [helpstring] [uuid] (object] */

EXTERN_C const IID IID_ITagDefinition; ttif defined ( cplusplus) <.& ! defined (CINTERFACE) interface DECLSPEC_UUID("39cacda4-c66a-lldO-802f-O0a0248feOba") ITagDefinition : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE GetMembβrTaglDs (

/* [in] */ WWFilterSpecification RPC_FAR *pFilter,

/* [size_is] [sizβ_is] [out] */ DWORD RPC_FAR ♦ RPC_FAR *ppΣDs,

/* [out]^"*/ long __RPC_FAR *pCount) - 0; virtual HRESULT STDMETHODCALLTYPE GetTagType (

/* [out] */ ΣTagType RPC_FAR * RPC_FAR *ppTagType) - 0; virtual HRESULT STDMETHODCALLTYPE GβtlD( /* [out] */ DWORD RPC_FAR *pΣD) - 0; virtual HRESULT STDMETHODCALLTYPE GetAttributeValue ( /* tin] */ DWORD AttribΣD, /* [out] */ LPOLESTR RPC_FAR *ppAttribValuβ) - 0;

}; •else /* C style interface */ typedef struct ITagDe initionVtbl

{

BEGIN_INTERFACE

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QuβryInterfac^{β ) (}

ITagDe inition RPC_FAR * This,

/* [in] */ REFΣID rild,

/* [iid_is] [out] */ void RPC FAR * RPC_FAR 'ppvObject⁾ ;

Λλt ULONG ⁽ STDMETHODCALLTYPE __R?~ FAR 'AddRef ) ( ITagDefinition RPC_FAR ^• his) ,•

ULCNG ( STDMETHODCALLTYPE _RPC_FAR 'Release ) ( ITagDe inition RPC_FAR ^» This) ;

HRESULT ⁽ STDMETHODCALLTYPE _RPC_FAR 'GetMe berTaglDs ) (

ITagDef ition RPC_FAR ^« This,

/^'* [in] */ WWFilterSpecification RPC_FAR *pFilter,

/* [sizβ_is] [size_is] [out] */ DWORD RPC_FAR • RPC_FAR *ppIDs,

/^« [out] */ long RPC_FAR *pCount) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetTagType ) (

ITagDefinition RPC_FAR * This,

/* [out] */ ITagType- RPC_FAR * RPC_FAR *ppTagType) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GetID ) (

ITagDefinition RPC_FAR * This,

/* [out] */ DWORD RPC_FAR *pΣD) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'GetAttributeValue ) (

ITagDefinition RPC_FAR * This,

/* [in] */ DWORD AttriblD.

/* [out] */ LPOLESTR RPC_FAR *ppAttribValuβ) ;

END_ΣNTERFACE } ITagDefinitionVtbl; interface ITagDefinition

{

CONST VTBL st ruct ITagDef initionVtbl RPC_FAR *lpVtbl;

} ^;

ttifdef COBJMACROS

ttdefine ITagDefinition_QuβryInterface (This, riid.ppvObject) \ (This) ->lpvtbl -> Querylnterface (This, riid.ppvObject) ttdefine ITagDe inition_AddAβ (This) \ (This)->lpVtbl -> AddRef (This)

•define ITagDefinition_Rβleasβ (This) \ (This)->lpVtbl -> Release (This)

ttdefine ITagDefinition_GβtMβmbβrTagIDs (This, pFilter, pplDs.pCount⁾ \ (This) ->lpvtbi -> GetMemberTaglDs (This, pFilter,pplDs,pCount⁾ ttdefine ITagDefinition_GetTagType (This, ppTagType) \ (This) ->lpVtbl -> GetTagType (This,ppTagType)

•define ITagDefinitionJSetΣD (This, pID) (This) ->lpvtbl -> GetID(This,pΣD)

A •define ITagDefιnιtιon_GetAttrιbuteValue(Thιs, AttriblD, pAttribValue) iThis) ->lpvtbl -> GetAttributeValue (This, AttriblD, pAttribValue)

•endif /* COBJMACROS ^♦/

•endif /^• C style interface */

HRESULT STDMETHODCALLTYPE ITagDefinition_GetMemberTagIDs_Proxy(

ITagDefinition RPC_FAR * This,

/* [in] */ WWFilterSpecification RPC_FAR *pFilter,

/* [size_is] [sizβ_is] [out] */ DWORD RPC_FAR * RPC_FAR 'pplDs,

/* [out]-*/ long RPC_FAR *pCount) ;

void RPC_STUB ITagDefinition_GetMemberTagIDs_Stub(

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannβlBuffer, PRPC_MESSAGE jpRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDefinition_GetTagType_Proxy(

ITagDefinition RPC_FAR * This,

/* [out] */ ITagType- RPC_FAR * RPC_FAR *ppTagTypβ) ;

void RPC_STUB ΣTagDefinitionJ3etTagTypβ_Stub(

IRpcStubBuffer 'This, IRpcChannelBuffer *_pRpcChannelBu fer, PRPC_MESSAGB _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDefinition_GetΣD_Proxy(

ITagDefinition RPC_FAR • This,

/* [out] */ DWORD RPC_FAR *pID) ;

void RPC_STUB ITagDefinition_GβtID_stub (

IRpcStubBu er *Thiβ, IRpcChannelBu ar *_pRpcChannβlBu fer, PRPC_MESSAGB _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagDefinition_GetAttributeValuβ_Proxy⁽

ITagDefini ion RPC_FAR * This,

/* [in] */ DWORD AttriblD,

/* [out] */ LPOLESTR RPC_FAR 'ppAttribValue) ;

void RPC_STUB ITagDefinitionJ3etAttributeValue_Stub(

IRpcStubBuf er 'This,

2D IRpcChannel3u fer '_pRpcChannel3uf er, ?RPC_MESSAGE _pRpcMessage, DWORD '_pdwStubPhase) ;

•endif /* ITagDefinition_ΣNTERFACE_DEFINED_

•ifndef ITagDιctιonaryManager_INTERFACE_DEFINED

•define ITagDictιonaryManager_INTERFACE_DEFINED

/ ** *

* Generated header for interface: ITagDictionaryManager

* at Mon Dec 22 15:10:33 1997 ^{" ♦} u3ing MIDL 3.01.75 * *^#*^#•••*^♦**•/

/* (unique] [helpstring] [uuid] [object] */

typedef LPOLESTR RPC_FAR *OLESTRARRA ;

EXTERN_C const IID IΣD_ITagDictionaryManager;

•if defined! cplusplus) -.-. ! defined(CINTERFACE) interface DECLSPEC_UUID("39cacdaS-c66a-lld0-802f-00a0248fe0ba") ITagDictionaryManager : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE GetDictionaryNames)

/* [sizβ_is] [sizβ_is] [out] */ OLESTRARRAY RPC_FAR *pArray,

/* [out] */ long -_RPC FAR *pCount) - 0;

}^; ttelse /* C style interface */ typedef struct ITagDictionaryManagβrVtbl

{

BEGΣN_ΣNTERFACB

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QuβryInterface ^{) (}

ITagDictionaryManager RPC FAR * This,

/* [in] */ REFIID riid,

/* [iid_is] tout] */ void RPC_FAR * RPC_FAR *ppvObject⁾ ;

ULONG ( STDMETHODCALLTYPE RPC_FAR *AddRef ) (

ITagDictionaryManager RPC_FAR * This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR 'Release ^{) (}

ITagDictionaryManager RPC_FAR * This) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR *GβtDictionaryNames ^{) (}

ITagDictionaryManager RPC FAR * This,

/* [size_is] [sizβ_is] [out] */ OLESTRARRAY _RPC_FAR *pArray,

MA / ^• [out ] • / long RPC_FAR ^»pCount ) ;

END_INTERFACE } iτagDΪctionar ManagerVtbl ; interface ITagDictionaryManager

{

CONST VT3L struct ITagDictionaryManagerVtbl RPC FAR *lpVtbl,

. ;

•ifdef COBJMACROS ^"

•define ITagDictionaryManager_QueryInterface (This, riid, ppvObject) \ (This) ->lpVtbl -> Querylnterface (This, riid.ppvObject)

•define ITagDicttionaryManager_AddRef (This) \ (This) ->lpVtbl -> AddRef (This) ttdefine ITagDictionaryManager_Releasβ (This) \ (This) ->lpVtbl -> RβleaseTτhis)

ttdefine ITagDictionaryManager_GetDictionaryNames (This, pArray, pCount) \ (This) ->lpvtbl -> GetDictionaryNames (This, pArray, pCount) ttendif /* COBJMACROS */

ttendif /* C style interface */

HRESULT STDMETHODCALLTYPE ITagDictionaryManager_GetDictionaryNames_Proxy(

ITagDictionaryManager RPC_FAR * This,

/* [sizβ_is] [size_is] [out] */ OLESTRARRAY RPC_FAR *pArray,

/* [out]-*/ long __RPC_FAR *pCount) ;

void RPC_STUB ITagDietionaryManagerJ-etDictionaryNames_Stub(

IRpcScubBuffer *Thiβ, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGB _pRpcMessagβ, DWORD *_pdwStubPhasβ) ;

ttendif /* ιTagDictionaryManager_INTERFACE_DEFINED */

ttifndef ITagType_INTERFACE_DEFINED ttdefine ITagType_INTERFACE-DEFINED

/************** * ^•*^#.*^#

* Generated header for interface : ITagType

X2Z * at Mon Dec 22 IS : 10 : 33 1997

• using MIDL 3 . 01. 75 * * ^♦ • • ^♦ . . /

/* [uniquel [helpstnng] [uuid] [object] */

ΞXTSRN_C const IID ID_ITagType;

•if defined( cplusplus) && ldefined(CINTERFACE) interface DECLSPECJJUID("39cacda6-c66a-lldO-802f-00a0248feOba") ITagType : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPE GetTypeName (

/* [out] */ LPOLESTR RFCJTAR ^»newVal) - 0; virtual HRESULT STDMETHODCALLTYPE GetDotFieldEnum(

/» [out] */ lEnumDotFields RPC_FAR * RPC_FAR *ppEnumDotFields)

0; virtual HRESULT STDMETHODCALLTYPE Getlmagelnde (

/* [out] */ long RPC_FAR *pDef∑mg∑ndβx,

/* [optional] [out] */ long RPC_FAR *pSellmgΣndβx) - 0;

}; •else /* C style interface */ typedef struct ΣTagTypβVtbl

{

BEGINJNTERFACB

HRESULT ( STDMETHODCALLTYPE RPC_FAR *QueryΣnterfacβ ) (

ITagType RPC FAR * This,

/* [in] */ REFΪID riid,

/* [iid_is] [out] */ void RPC_FAR * RPC_FAR *ppvObject) ;

ULONG ( STDMETHODCALLTYPE RPCJFAR 'AddRef ) (

ΣTagType RPCJfAR * This) ;^"

ULONO ( STDMETHODCALLTYPB RPC_FAR 'Release ) (

ITagType RPC_FAR * This) ;~

HRESULT ( STDMETHODCALLTYPB RPC_FAR *GβtTypeNamβ ) (

ITagType RPC_FAR * This,

/* [out] */ LPOLESTR RPC_FAR *nβwVal) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'GetDotFieldEnum ) ⁽

ITagType RPC FAR * This,

/* [out] */ lEnumDotFields RPC_FAR * RPC_FAR *ppEnumDotFields^{) ;}

HRESULT ( STDMETHODCALLTYPE RPCJFAR *GetImagβΣndex ) ⁽

ΣTagTypβ RPC_FAR * This,

/_* [out] */ long RPC_FAR *pDef∑mg∑ndex,

/_* [optional] [out] •/ long RPC_FAR 'pSellmglndex⁾ ;

x& END_ INTERFACE } ITagTypeVtbl ; interface ITagType

(

CCNST_VTBL struct ITagTypeVtbl RPC_FAR 'lpVtbl;

•ifdef COBJMACROS

•define ITagType_QueryInterface (This, riid.ppvObject) \ (Thi3) ->lpVtbl -> Querylnterface (This, riid.ppvObject)

•define ITagType_AddRβf (This) \

(This) ->lpVtbl -> AddRef (This)

•define ITagTypβ_Rβleasβ(This) \ (This) ->lpVtbl -> Release(This)

ttdefine ITagType_GettypeName(This,newVal) \ (This) ->lpvtbl -> GetTypeName (This,nβwVal) ttdefine ITagType_GetDotFieldEnum(This, ppEnumDotFields) \ (This) ->lpVtbl -> GetDotFieldEnum(This, ppEnumDotFields)

•define ITagTypβ_GβtImagβIndβx (This, pDe Imglndex, pSellmglndex) \ (This) ->lpVtbl -* GβtImageIndex(This,pDβf∑mg∑ndex, pSellmglndex)

•endif /* COBJMACROS */

•endif /* C style interface */

HRESULT STDMETHODCALLTYPB ITagType_GβtTypβNamβ_Proxy(

ITagType RPC_FAR * This,

/* [out] */ LPOLESTR RPC FAR *nβwVal) ;

void RPC_STUB ITagTypβ_GβtTypeNamβ_Stub (

IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannβlBuffer, PRPC_MESSAGB _pRpcMβssagβ, DWORD *_pdwStubPhasβ) ;

HRESULT STDMETHODCALLTYPE ITagTγpβ_GetDθtFieldEnuπ_Proxy(

ITagType RPC FAR * This,

/* [out] */ lEnumDotFields RPC_FAR * RPC_FAR *ppEnumDotFields⁾ void RPC_STUB ITagTypeJ3βtDotFieldEnum_Stub(

IRpcStubBuffer 'ThiaT IRpcChannelBuffer *_pRpcChannel3uf er, ?RPC_MESSAGE _pRpcMβssagβ, DWORD '_pdwS ub hase) ;

HRESULT STDMETHODCALLTYPE ITagType_GetImageIndex_Proxy (

ITagType RPC_FAR ^• Th 3,

/^» [outl •/ long RPC_FAR 'pDe Imglndex,

/* [optional] [out] ^♦/ long RPC_FAR 'pSellmgΣndex) ;

void RPC_STUB ΣTagTypβ_GβtImageΣndβx_Stub (

IRpcStubBuffer *This7 IRpcChannelBuffer *_pRpcChannelBu fer, PRPC_MESSAGE jpRpcMessage, DWORD *_pdwStubPhasβ) ;

ttendif /* ITagTypβ_ΣNTERFACE_DEFINED */

ttifndef IDθtField_INTERFACE_DEFΣNED

•define IDotField_INTERFACEJ-EFINED

/ ♦••**#**♦*••••#^♦•*•#*••• **•*«

* Generated header for interface: IDotField

* at Mon Dec 22 IS: 10: 33 1997

* using MIDL 3.01.75 ****** /

/* [unique] [helpstring] [uuid] [object] */

EXTERNJC const IID ΣID_ΣDotFiβld; ttif defined} cplusplus) &fc ! defined (CINTERFACE) interface DECLSPEC_UUID ( "39cacda7-c6βa-lld0-802f -00a0248fβ0ba") IDotField : public lUnknown

{ public: virtual HRESULT STDMETHODCALLTYPB GetName (

/* [out] */ LPOLESTR RPCJfAR *ppNamβ) - 0; virtual HRESULT STDMETHODCALLTYPB GetTypeName (

/* [out] */ LPOLESTR RPC_FAR *ppTypβNamβ) - 0;

}; ttelsβ /* C style interface */ typedef struct ΣDotFieldVtbl

{

BEGIN INTERFACE

H5 HRESULT ⁽ STDMETHODCALLTYPE __RPC_FAR 'Querylnterface ) (

IDotField RPC_FAR • This,

/^♦ (in] */ REFIΪD riid,

/^• [iid_ιs] [out] •/ void RPC_FAR • RPC_FAR 'ppvObject)

ULONG ( STDMETHODCALLTYPE _RPC_FAR *AddRβf ) ( IDotField RPC_FAR • This) ;

ULONG ( STDMETHODCALLTYPE RPC_FAR 'Release ) (

IDotField RPC_FAR * This) 7

HRESULT ( STDMETHODCALLTYPE RPC FAR 'GetName ) (

IDotField RPC_FAR * This,

/* [out] */ LPOLESTR RPC_FAR *ppName) ;

HRESULT ( STDMETHODCALLTYPE RPC_FAR 'GetTypeName ) (

IDotField RPC ΑR * This,

/* [out] */ LPOLESTR RPC_FAR *ppTypeNamβ) ;

END_INTERFACE } IDotFieldVtbl; interface IDotField

{

CONST VTBL struct IDotFieldVtbl RPC FAR 'lpVtbl;

};

ttifdef COBJMACROS

•define IDotFieldJJuerylnterfacβ (This, riid.ppvObject) \ (This) ->lpVtbl -> Querylnterface (This, riid.ppvObject)

•define IDotField_AddRβf (This) \ (This)->lpVtbϊ -> AddRe (This)

•define IDotField_Rβlβasβ(This) \ (This) --.lpVtbϊ -> Rβlβasβ(This)

•define IDotFiβldJSetNaraβ (This,ppName) \ (This) ->lpVtbϊ -> GetName (This, ppName) ttdefine IDotPiβldJSetTypβNamβ (This, ppTypeName) \ (This) ->lpvtbϊ -> GetTypeName (This, ppTypeName) ttendif /* COBJMACROS */

ttendif /* C style interface */

HRESULT STDMETHODCALLTYPE IDotField_GetName_Proxy( IDotField R?C_FAR * This,

/• [out] */ LPOLESTR RPC_FAR *ppName) ;

void R?C_STUB IDotField_GetName_5 ub(

IRpcSt bBuffer *Thιs,^" IRpcChannelBuffer *_pRpcChannel3uffer, ?R?C_MESSAGE _pRpcMessage , DWORD ' pdwStubPhase) ;

HRESULT STDMETHODCALLTYPE IDotField -etTypeName Proxy(

IDotField RPC_FAR * This,

/* [out] •/ LPOLESTR RPC_FAR *ppTypeName) ;

void RPC_STUB IDotFieldJ-etTypeName_stub(

IRpcStubBuffer *This,

IRpcChannelBuf er *_pRpcChannβlBuf er, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhasβ) ;

ttendif /* IDotField INTERFACE DEFINED

ttifndef TagΣDLLib_LΣBRARY_DEFΣNED

•define TagΣDLLib_LIBRARY_DEFINED

/***^♦**** * •*••*•***•**•*

* Generated header for library: TagΣDLLib

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.75

'/

/* [helpstring] [version] [uuid] */

EXTERNJ- const IID LIBIDJTagΣDLLib; •endif /* TagIDLLib_LΣBRARY_DEFΣNED */

/ * •♦***#.**#•.^♦•^#•*^##•.^#••**

* Generated header for interface: MIDL_itf_TagIDL_0080

* at Mon Dec 22 15:10:33 1997

* using MIDL 3.01.75 *....**♦.*♦••♦ ****..*..**/

//^■' : III I III III 111111111 II II 111111111 /.- onderware Tag Dictionary Category//

^•'--'.' i n ! mini 1111 III i III III i ii 11111

DEFI EJ-UID(CATID_WonderwareTagDiccιonaryCategory,0x5A3027A0, 0x8S15, OxlldO, 0x94, 5x06. -X40, OxDl, 0x01, OxCl, 0x00, 0x00);

///'.^■/// ^■ '.' ^{' '} , i n ii ii 111111111111

//Wonderware Tag Dictionary HRESULT3// II III 11111 II IIII 1111 II I III 11 II 11 •define WWTD_E_TAGΣD 0x80040200

extern RPC FJΪANDLE MIDL_itf_TagΣDL_0080_vO_0_c_if spec- extern RPC_IF_HANDLE MIDL_itf_TagΣDLJ)OΘO_vO_0_s_i spec;

/• Additional Prototypes for ALL interfaces */ unsigned long RPCJJSER HWND_UserSize( unsigned long RPC_FAR

*, unsigned long , HWND RPC_FAR * ),- unsigned char RPC_FAR * RPCJJSER HWNDJJserMarshal ( unsigned long RPC_FAR

*, unsigned char RPC_FAR *, HWND RPC_FAR • ); unsigned char RPC_FAR * RPCJJSER HWNDJJserUnmarshal (unsigned long RPC_FAR

*, unsigned char RPC_FAR *, HWND RPC_FAR ^♦ ) ,• void RPCJJSER HWNDJJserFreβ ( unsigned long RPC_FAR

* , HWND RPC_FAR * ) ;

/* [local] */ HRESULT STDMETHODCALLTYPE ΣEnumTagTypes_Nβxt_Proxy(

IEnumTagTypes RPC_FAR * This,

/• [in] */ ULONG cβϊt,

/^♦ [out] */ ITagType RPC_FAR * RPC_FAR *rgelt,

/♦ [out] •/ ULONG RPC_FAR 'pceltFetched);

/* [call_asl */ HRESULT STDMETHODCALLTYPE IEnumTagTypβs_Next_Stub(

IEnumTagTypes RPC_FAR * This,

/* [in] */ ULONG cβϊt,

/* [length_is] [sizβ_is] [out] */ ITagType RPC_FAR * RPC_FAR *rgβlt,

/• [out] *7 ULONG __^RPCJ*AR *pcβltFβtched) ;

/* [local] */ HRESULT STDMETHODCALLTYPB ΣEnumDotFields_Nβxt_Proxy( lEnumDotFields RPC_FAR * This,

/* [in] */ ULONO celt,

/* [out] */ ΣDotFiβld RPC_FAR * RPC_FAR *rgβlt,

/* [out] */ ULONO RPC_FAR-'pceltFetched) ;

/* [call_as] */ HRESULT STDMETHODCALLTYPE ΣEnumDotFields_Nβxt_Stub⁽ lEnumDotFields RPC_FAR * This,

/* [in] */ ULONG celt,

/* [length_is] [size_is] [out] */ IDotField __RPC_FAR *__RPC_FAR *rgelt,

/* [out] *7 ULONG RPC_FAR *pceltFetched) ;

/* end of Additional Prototypes */

Λ sifdef __cplusplus

} •endif

•e dif

J2H InTouchTagDictⁱonary. idl : IDL source for InTouchTagDictionary il /

/ This f le wi l be processed by the MIDL tool to

/ produce the type library (InTouchTagDictionary. lb) and marshalling code.

..sport 'Tagl L. idl" ;

object, uuιd(C7192600-C5A5-lld0-302F-00A0243FE0BA) , helpstringC IlnTouchTagDictionary Interface") , pomter_default (unique).

I interface IlnTouchTagDictionary : ITagDictionary

{ typedef (vl enum] enum tagWWIDChanged

{

WWTAG_CHANGE_ADDED « 1,

WWTAGJ-HANGE_MODIFΣED,

WWTAGJ-HANGEJELETED } wwiDChanged;

HRESULT TagHasChanged( [in] DWORD ΣD , [in] ww∑DChanged enumChanged)

[ uuid ( 3EC11293 -ABB4- HD0- 9B70-080009C39144) , versιon(l . O) , helpstringCInTouchTagDictionary 1.0 Type Library")

] library InTouchTagDiβtionaryLib

{ ιmportlib("stdolβ32.tlb") ;

/// 1 ! 1111111111111111111111 III 111111111 i 11111 II TagDictionary Class //

///////////////////////////////////////////// [ uu d(3EC11294-ABB4-HD0-9B70-080009C39144) , helpstπng ( " InTouchTagDictionaryObj Class" ) 1 coclass InTouchTagDictionaryObj

{

[defaultl interface IlnTouchTagDictionary;

}^;

_<Λ2>0 import "TaglDL.idl"; ill 11 III I III mini 11 II 11 IIII m ill 11111111 II II TagDictionaryManager Type Library //

i uuιd(04F30122-96 6-llDO-3406-40D101C10000) , version i 1.3⁾, helpst in t "TagDictionaryManager 1.0 Type Library")

1 library TAGDICTIONARYMANAGERLib

( ιmportlibC'stdole32.tlb") ; ii ii IIII i illinium

II TagDictionaryManager Class // i IIII 11111 ii inn i III IIII III i IIII inn

[ uuid(04F3012F-96F6-llD0-3406-40D101C10000) , helpstnng ( "TagDictionaryManager Class" )

1 coclass TagDictionaryManager

{

[default] interface ITagDictionaryManager;

};

//// 1 III II ll/l II II TagBrowserDlg Class //

/////////////////////////////////////////////

[ uuid(71FBA542-9A5E-llD0-B723-0β0009C38108) , helpatring ( "TagBrowserDlg Class")

] coclass TagBrowserDlg

{

[default] interface ITagBrowserDlg;

};

Λ A r?p_quote i ' -.^■■ ^■' ^■■^■■ ^;,. II II 11 ' 11111 i 1111111111 II I" cpp quote ( "//Wonderware Tag Dictionary DL //") cpp_c;αote("/J///////////////////// / /////////////") interface ITagType; mter ace ITagDefinition,- interface IDotField; import "oaii ■ d " ;

III III III I ill I III 111 III III III 111111111111111 III I III I II 11 II 11 \. object, uuid(39cacda0-c66a-lld0-302f-00a0248fe0ba) , helpstringC IEnumTagTypes Interface") , oo cer default (unique) 1 interface IEnumTagTypes : IUnlnown

{

[local] HRESULT Next( [in] ULONG celt,

[out] ITagType "rgelt, [out] ULONG 'pceltFetched) ;

[call_as(Next) ]

HRESULT RemoteNext( [in] ULONG celt,

[out, size_is (celt) , length_is ('pceltFetched) ]

ITagType **rgelt,

[out] ULONG *pceltFetched) ;

HRESULT Skip ([in] ULONG celt);

HRESULT Reset ( ) ;

HRESULT Clone ([out] IEnumTagTypes ^»*ppenum) ; ^}

//////////////////////////////////////////////////////////// [ object, uuid(39cacdal-cS6a-lld0-802f-00a0248fe0ba) , helpstringClEnumDotFields Interface") , poin er_default (unique) 1 interface lEnumDotFields : lUnknown

{

[local]

HRESULT Next( [in] ULONG celt,

[out] IDotField **rgelt, [out] ULONG 'pceltFetched) ;

[call_as(Next) ]

HRESULT RemoteNext( [in] ULONG celt,

[out, 3ize_is(celt) , length_is ( 'pceltFetched⁾ ]

IDotField **rgeltt,

[out] ULONG 'pceltFetched) ;

ΛZ HRESULT Sk p i ^'. m . ^'-TLONG celt ⁾ ;

HRESULT Reset 0 ;

HRESULT Clone ([out] lEnumDotFields "ppenum); \ • i m m 11 m 111 m 111111 IIII 1111111111111111 in in III i III 111 r object, uuιd(39cacda2-c66a-lld0-802f-00a0248fe0ba) , helpstringC ITagDictionary Interface") , poιnter_default (unique) 1 interface ITagDictionary : lUnknown

{ typedef [vl_enuml enum tagWWlmageTypβ {

IMGTYPE_SMALL _* 16,

IMGTYPE_BIG « 32

} WWImageType; typedef struct tagWWFilterElement

{

DWORD UniqueID; LPOLESTR pFilterString; OLECHAR MultiChar; OLECHAR SingleChar; boolean bCaseSensitive; OLECHAR Placeholder; DWORD Reserved; } WWFilterEIement;

) typedef 3truct tagWWFilterSpecification

{

LPOLESTR pExpression;

DWORD Count;

[size_is (Count) ] WWFilterEIement* pFilterElements;

} WWFilterSpecification;

HRESULT Open ([in] LPCOLESTR dataSource) ;

HRESULT Close () ;

HRESULT GetDisplayName ( [out] LPOLESTR* ppDisplayNam^β);

HRESULT GβtDataSourceControlClsid( [out] GUΣD* pClsid);

HRESULT GetlmageList ( [in] WWΣmageTypβ imgTypβ, [in] ΣStream* pStream ^{) ;}

HRESULT Getlmagelndex( [out] long* pDeflmgΣndex, [out, optional] long* pSellmglndex) ;

HRESULT GetTagFromlD ( [in] DWORD ID, [out] ITagDefinition** ppTag^{) ;}

HRESULT GetTagTypeEnum( [out] IEnumTagTypes** ppEnumTagType⁾ ;

HRESULT GetTaglDs ( [in] WWFilterSpecification* pFilters,

XVb .out, sιze_ιs ⁽ . 'pCount) ] DWORD** • IDs, [outl long*

};

object, uuid(07F432A0-DCSS-lld0-303B-00A0243 E0BA) , helpstringC ISpecifyTagAttributes Interface") , poιnter_default (unique) 1 interface ISpecifyTagAttributes : lUnknown

{ typedef [vl enum] enum tagWWAttributelD {

AτTRΣBΣD_FULLYQUALIFIED_NAME - 0, //string

ATTRΣBΣDJilERARCHICALJlAME, //string

ATTRIBΣDJTYPE, ~ //string

ATTRIBΣDJ.OMMENT, //string

ATTRΣBID_ALARM_GROUP, //str g

ATTRΣBΣD_DDE_ACCESS_NAME, //string

ATTRΣBΣD-LOGGED, ~ //boolean

ATTRIBΣD-NESTED, //boolean

ATTR1BΣD-EXPANDABLE, //boolean

ATTRΣBΣDJJDT NSTANCE, //boolean

ATTRIBΣD_MAX //max number of standard attributes } WWAttributeΣD; typedef struct tagWWExtendedAttr -.-.ute

{

LPOLESTR pAttribute; ^■

DWORD uniqueID; } WWExtendedAttribute;

HRESULT GetAttributes ( (out. sizβ_is(, *pCount) ] WWExtendedAttribute** attrib, [out] DWORD* pCount) ;

HRESULT SetLCID ( [in] LCID locallD, [out] LCID* pOldlocallD);

HRESULT GetLCID ( [out] LCID* plocallD) ;

};

I! i i Ii i 11 i i I i i 111 i i 11 i III III IIII i IIII

[ object, uuid(C92FAA60-D88E-lldO-803A-OOA0248FEOBA) , helpstringCITagDictionaryDelta Interface") , pointer defaul (unique) 1 interface ΣTagDictionaryDβlta : ΣUnknown

{ typedef [vl_enum] enum tagWWResetDelta

{

RESET_NEW_IDS » 1,

RESET~DELETED_IDS,

RESET_ALL_IDS } WWResetDelta;

HRESULT ResetDelta( [in] WWResetDelta enumReset);

αs><f HRESULT GetNewlDs ⁽ [in] WWFilterSpeci ication* pFilter,

[in] boolean oReset, [out , sιze_ιs ( , ^»pCount) ] DWORD** p-Ds [out] long* pCount) ,^•

HRESULT GetDeletedlDs ( [m] ooolean oReset, [out, sιze_ιs ( , *pCount) ] DWORD" opIDs, [out] long* pCount);

} .

I I I I I I I I , ' i 1 1111111111111111111111111111111111111 object, uuιd(39cacda3-cS6a-lldO-302f-O0aO248feOba) , helpstringC ITagBrowserDlg Interface") , pointer default (unique) ] interface ITagBrowserDlg : lUnknown

{

HRESULT Inιt( [in] ΣTagDictionary *pTagDιctιonary, [in] WWFilterSpecification* pFilter) ;

HRESULT SetAecessNames ( [in] long nameCount, (in, sιzβ_ιs (nameCount) ] LPOLESTR* accessNames ) ;

HRESULT DoTagPickerUI ( [out] ITagDefinition** ppSelectedTag,

[outl IDotField** ppSelectedDotField, [out] LPOLESTR* pSelectedTagAccessName, [in] LPCOLESTR initialAccessName, [in] LPCOLESTR imtialTagName, [in] LPCOLESTR initialDotField, [in] boolean bAllowDictionarySβlection, [ l boolean bAllowDotFieldSelection, [in] boolean bAllowExpandableTagSelection, [in] boolean bAllowTreeNavigation, [in] boolean bAllowNoneTagSelec ion, [in] LPCOLESTR title, [in] HWND parentHwnd) ; };

//////////////////////////////////////////////////////////// [ object, uuιd(39cacda4-c66a-lld0-802f-00a0248fe0ba) , helpstringC ITagDefinition Interface") , poιnter_defaul (unique) ] interface ITagDefini ion : lUnknown

{

HRESULT GetMβmbβrTagΣDβ ( [in] WWFilterSpecification* pFilter,

Cout,sιze_ιs(,*pCount)] DWORD** ppΣDs, [out] long* pCount) ;

HRESULT GetTagType ( [out] ITagType** ppTagType);

HRESULT GetID( [out] DWORD* pΣD) ;

HRESULT GetAttributeValue ( [in] DWORD AttriblD, [out] LPOLESTR* ppAttribValue ) ; };

*>s - ^, , ^/ / ^■ ' n i . ¹ 1 n 1 1 n i . ^, 111111111 n i m m 111 I I I 111 ill i r object, uuιd(39cacdaS-c66a-lid0-302 -00a0248fe0ba) , helpstringC ITagDictionaryManager Interface") , pomter_default (unique)

] interface ITagDictionaryManager : lUnknown i typedef LPOLESTR' OLESTRARRAY;

HRESULT GetDictionaryNames ( [out, 3ize_ιs( , 'pCount) ] OLESTRARRAY* pArray, [out] long* pCount) ; };

111 III III 11 II lllll III 11 III IIII I III II

( object, uuιd(39cacda6-cδβa-lld0-302f-00a0248fe0ba) , helpstringC ITagType Interface") , pointer dei ult (unique) 1 interface ITagType : lUnknown

{

HRESULT GetTypeName ( [out] LPOLESTR* newVal);

HRESULT GetDotFieldEnum ( [out] lEnumDotFields** ppEnumDotFields) ;

HRESULT Get∑mage∑ndβx( [out] long* pDef∑mg∑ndβx, [out, optional] long' pSellmglndex) ; };

1111111 lllll lllll

[ object, uuid(39cacda7-c66a-lld0-802f-00a0248fe0ba) , helpstringCIDotField Interface") , pointer defaul (unique) 1 interface IDotField : lUnknown

{

HRESULT GetName ( [out] LPOLESTR* ppName); HRESULT GetTypeName ([out] LPOLESTR* ppTypeName);

}; i i h I ! I i 1111111 III 111 II I II II 111111 i 11 i 111 ! 11111 n i I n i in

[ uuid(39cacdaθ-c66a-lld0-802f-00a0248fe0ba) , version (1.0) , helpstringCTagΣDL 1.0 Type Library") 1 library TaglDLLib

{ ιmportlib("stdole32.tlb") ;

ΛS6 interface IEnumTagTypes; interface lEnumDotFields; interface ITagDictionary; interface ISpecifyTagAttributes; interface IDotField; interface ITagType; interface ITagDefinition; interf ce ITagDictionaryManager; interface ITagBrowserDlg;

11 II 111 II 111 lllll 11 III I IIII IIII II II II I I I Wonderware Tag Dictionaries Category // i ii 111 IIII 111 illinium i 11 ii I cpp_quoceC //////////////////////////////////////") cpp quote (" //Wonderware Tag Dictionary Category//") cpp^"quoce ( " 111111111111111111111111111111111111 J I " ⁾ cpp_quote ( "DEFINE_GUID (CATID_WonderwareTagDictionaryCategory, 0xSA8027A0, 0x3515 ,

OxlϊdO, 0x84, 0x06, 0x4.., OxDl, 0x01, OxCl, 0x00, 0x00);") III inniiiiii 11 inimm III i

I I Wonderware Tag Dictionaries HRESULTs // II lllll 1111 I lllll I III cpp_quote(" //////////////////////////////////////") cpp_quotβ(" //WonderWarβ Tag Dictionary HRESULTs//") cpp_quoteC//////////////////////////////////////") cpp_quote ("ttdefine WWTD_E_TAGID 0x80040200")

Al - APPENDIX C

J!ft The Tag Browser

The Tag Browser is your pnmary tool for ie in ind selecting local and remote gnames and tagname .fields from FactorySuite applications, or any other tag source ^•hat suppoπs the InTouch Tagname Dictionary interface. It allows you to select existing tagnames. add new tagnames and view basic Tagname Dictionary information. You also use the Tag Browser to access the dialog boxes that allow you to perform tagname -•Jiting. replication, and to select tagnames ( remote references) in remote tag sources.

The first time you access the Tag Browser, by default. <loca.> will be selected for the tag source. Meaning Out the tagnames m the local application's Tagname Dictionary will be displayed. Thereafter, the last accessed tag source's tagnames will be displayed.

The Tag 8rowser operates in two modes: "Filtered Selection Mode^'' and Unlimited Selection Mode." The mode for the Tag Browser is determined by the method you use to access it. The following lists the pnmary methods that you can use to access the Tag Browser in each mode:

Unlimited Selection Mode

Double -clicking an ammauon link tagname or expression input box.

Double-clicking an AcαveX or wizard tagname or expression input box.

Double-clicking a blank area in any InTouch Quick-Script window.

In the InTouch QuickScnpt editor, selecting the Tagname command on the Insert • menu.

Pressing the ALT * N keys in the InTouch QuickScnpt editor.

Double-clicking a blank New Name box in the Substitute Tagnames dialog box.

Double-clicking the Tagname-FieldNamt input box m the SQL Access Bind List , Configuration dialog box.

Filtered Selection Mode

Clicking the Select button in the Tagname Dictionary.

When WindowMaker is running, double-clicking a cell in the Unit# column in a Recipe Manager Unit Template definition.

In runtime, clicking any Pen* button in the Historical Trend Setup dialog box. In this instance, the Tag Browser will only display the tagnames that are defined with the Log Data option selected in the Tagname Dictionary.

^■U This functionality is only supported when the Allow Runtime Changes option has been selected for the tustoncal trend dunng development.

• In runtime, clicking any object linked to the HTSeiectTagϋ function.

«✓* For more information on the Tag Browser modes, see 'Tag Browser Selection Modes."

The Tag Browser's status bar provides status on the following items for the currently displayed tag source:

• Total number of items in the application.

• The name of the currently selected item.

• Tagname .field selected, if any.

• The Access Name -.ssocuied itli the tae source.

^ Tag Browser S _>?e7liec;cvtuiov-Hn. M mowdwew

The Tag Browser opera_tes ,ns . o selection modes: Filtered Selection Mo^de an^d Unlimited Selection Mode.

λ O Unlimited Selection Mode

The unlimited selection mode is accessed by double-clicking in a blanX area in any InTouch QuickScnpt window, animation link α na e or expression box or. a oianx ^e Name box in the Substitute Tagnames dialog box. The t3gnames defined :n a iocai or remote tag source can be displayed and selected in this mode.

Tagname .fields can aiso be selected for the tagname m this mode. When you select a ^•-gname and/or tagnamcfield in this mode, it is automatically entered into the InTouch Quicx-Scnpt, animation link tagname or expression box or. other location from which vou accessed the Tag Browser. For example:

> To select a .field:

1. Click the Dot Field arrow to open the list of .fields that you can associate with the type of tagname cuirauly selected.

-^ By default, <none will initially be displayed for all types of tagnames.

Note Dot Field is not available when you access the Tag Browser from the Tagname Dictionary or. dunng runtime, when selecting a tagname for a historical trend pen from the Historical Trend Setup dialog box. (The histoπcal trend must be configured with the Allow runtime changes option selected.)

2. Click the .field in the list that you want to append to the selected tagname.

^■^ Not every tagname type has the same .fields. For example, a Discrete type tagname has .OnMessage. whereas an analog does not. If you select a Discrete type tagname and you assign .OnMessage to it. and then you select another Discrete type tagname. the displayed .field list will not change. But. if you select another type of tagname in the control view list, for example an analog^, the displayed .field will revert to <none>

JM Tag Browser Views

The Tag Browser supports ;nree control views. Tagname List Control. Tagname Details Control and Taaname Tree ιew Control.

-Ξl List View

The list vie is used to display and select tags wuhin the current selection mode iescπoed acove). The Tagname List Control view displays the tagnames in t o views -spending upon the state of the List View and Details View buttons:

When you select list view, small icons will be displayed next to the tagnames with .cons displayed according to the type of each tagname. No other fields will be displayed in the list view. For example:

^■^ To refresh the display in the Select Tag dialog box. press F5.

UZ

_the new view.

Tree View

The Tree View displays the tagnames m two views depending upon the state of the List View and Oeuils View outtons. When you select tne tree view, a pane appears on the left side of the dialog box. By using tne Tree ie you can also access the member tagnames in any Super Tag template.

If the Oeuils View mode is active when you select the Tree View, Tag Browser appear as follows:

^■^ To expand a listing in the Tree View, double-click, the application name or. click the 2 To collapse a listing, double-elicit the application name again or. click the 3. Double-clicking an application in the tree view pane is the same as selecting it m the Tag Source list.

Note When you "drill down" through different levels in the Tag Browser, you can use the BACKSPACE key to "back up" to the previous level

M Defining Tag Sources

You must define the tag sources tor iewin in the Tag Browser. The procedures :αr adding, deleting or editing tag sources are -.escribed in this section. When you add or tdit a tag source definition, you will enter .ntormation such as the local network ccess Name you want to associate with the tag source s tagnames. a user-defined application name, and the data source tor the tag source.

^ote You will also use these procedures when you are converting placeholder tagnames ^•o remote tagname references. w For more information on remote tagname references, see 'Converting Tagnames to Remote References. '

To define a ug source:

I . Open the Tag Browser, and then click the Define Tag Sources button. The Define Tag Sources dialog box appears:

Note If tag sources are already defined, they will be listed when the dialog box appears. The list will include the user-defined Name for the tag source, the Location of the tag source (path) and the local network Access Name associated with the application.

^■ft To select multiple tag sources, hold down the SHIFT key as you click each name. To select multiple tag sources that are not consecutive in the list, hold down the CTRL key as you click each name.

Note When the Define Tag Sources dialog box closes, you must click the Tag Source arrow in the Tag Browser and select the new tag source in the list. The Tag Browser is then refreshed and tagnames for the selected tag source are displayed.

3. To remove a tag source(s) from the Tag Source list in the Tag Browser, click the Define Tag Sources button. The Define Tag Sources dialog box will appear. Select the tag source in the list, and then click Delete.

4. To edit a defined tag source, select it in the list, and then click Edit The Define Tag Source dialog box will appear displaying the configuration for the selected tag source.

5. To define a new tag source, click New. The Define Tag Source dialog box appears-

6. In the Tag Source Name box. type a name to identify the ug source.

7. Click the Access Name arrow and select the Access Name in the local appucauoo that you want to associate with the tagnames in the tag source.

3. Click the Tag Source Type arrow and select the source for the ug source' s tagname database. (By default InTouch is displayed.)

9. The Location box displays the full path to the tag source.

10. In the directory tree pane, locate the ug source, and then click OK. The Define Tag Sources dialog box reappears displaying the selected tag source:

G

11. Click Close. The Tag Browser will reappear.

12. Click the U=J tool to display the tree view pane to display all defined ug sources:

If you are not usmg the tree view mode, click the Tag Source arrow and select the name for the tag source that you want to display in the list. The Tag Browser will refresh and the ug sources' tagnames will be displayed.

The first time you access the Tag Browser, by default. <local> will be selected for the Tag Source. Thereafter, the tagnames for previously accessed tag source will be displayed.

13. Click OK.

λtø- Defining Tag Browser Filters

You will use the procedures descπbed in this section to define the filters (search criteria i you want to use to populate the Tag Browser. By creating filters, you can sort any tagname list and display only the tagnames that meet the criteria you specify. You can son the tagnames based on Tagname. Tag Type. Access Name. Alarm Groups and -agname Comments, You can use one or a combination of any of these items to set the criteria for your display. You can also save eacn filter instance and reuse it at any time

-* For example, if you have 40.000 tagnames defined in your Tagname Dictionary and you only need to deal with the 20 or so that are assigned to a particular Access Name or Alarm Group, you can create a filter and specify the Access Name and/or Alarm Group as the cπteπa that the tagnames must meet in order to be displayed in the Tag Browser.

Q To define a search filter

I . Click the Define Filter button. The Define Tag Filter dialog box appears:

^•*% If you nght click the mouse in any of the text entry boxes, a menu will appear displaying the commands that you can apply to the selected text.

2. In the Filter Name box. type a unique name to identify the filter that you are defining or. click the Filter Name arrow to select a previously defined filter name from the list. (As you define filters, the Filter Name you type is added to the list.)

-^ All of the Filter Option controls (Tagname. Tag Type. Access Name. Alarm Group and Comment) allow you to enter a wildcard expression to limn the scope of your search. If no filter is used, alt of the tagnames in the currently displayed tag source will be displayed.

M The multiple wildcard is the asterisk i ^•* For example, λsyn* *o ,.d -earc.-, for all tagnames beginning with the character ^'Asyn '.

The single character wildcard is the tilde i ? . For example, the filter. Tag ¹" would search for all four character tagnames that begin with Ta ^' The filter. Tag??", would search for all five character tagnames that begin with Tag ^'. and so on.

Any sequence of valid InTouch tagname characters, together with the two wildcard characters, is accepuble in a filter. The valid tagname characters are. A-Z. a-z. 0-9, '. @. -. λ *. S, %. _, \ and &.

3. In the Tagname box. type the ugname expression that you want to use as a filter. If left blank, the system will ignore this field in the filter definition.

4. In the Access Name box. type the local Access Name expression that you want to use as a filter. If left blank, the system will ignore this field in the filter defiruuon.

5. In the Alarm Group box. type the name of the Alarm Group expression that you want to use as a filter. If left blank, the system will ignore this field in the filter definition.

6. In ine Comment box. type the comment expression you want to use as a filter. If left blank, the system will ignore this field in the filter definition.

7. Click OK to close dialog box.

^■^ The Filter Name will now appear in the Filter list in the Tag Browser and you can select it to display only the tagnames meeting the cπtena specified in the filter.

> To delete a search filter:

1. Click the Filter arrow and select the filter name in the list that you want to delete.

2. Click Delete. The filter is immediately deleted.

Mf\ InTouch Cross Reference Utility

The Tagname Cross Referencing utility allows you to determine your tagname. remote tagname and SuperTag usage in animation links, izards. InTouch QuickScπpts, QuickFunctions, ActiveX controls, scripts and the following InTouch add-on programs. 3PC Pro. SQL Access Manager and Recipe Manager. For all objects such as wizards. ctiveX controls and animation links, it displays the w dow name and the coordinates oi all objects linked to the tagname. It also allows you to view any QuickScnpt or QuickFunction where a tagname is found

'ϊ For convenience, the Tagname Cross Reference utility can remain open in WindowMaker while you perform other tasks.

> To use the InTouch Cross Reference utility:

I . On the Special menu, click Cross Reference or. in the Application Explorer double-click Cross Reference. The InTouch Cross Reference Search Criteria dialog box appears:

2. The Search Criteria group allows you to limit the scope of your search. You can easily determine the scope by selecting only the options required.

Search for all occurrences Search for all uses of the tagname or SuperTag in animation links. InTouch QuickScπpts and all add-on programs such as SPC. SQL Access Manager. Recipe Manager, and so on.

Search for specific occurrences Search for only the tagname or SuperTag only in the specified options . For example, if you only want to search for the usage in window scripts, only select Usage in window scripts.

X> 1. Overview

The Tag Browser presented here is designed to replace the current InTouch tag selection mechanism. The new mechanism will allow selection of tags from all supporting FactorySuite and third parry applications. The Tag Browser will be built into WindowMa er. and WindowViewer.

2. Dialogs

2.1 Tag Browser

The Tag Browser dialog is used for selecting tags and dot fields from FactorySuite

Figure 1: Select Tig Dialog

2.1.1 Modes

2.1.1.1 Limited Selection to Current Tag Source

If the Tag Browser is launched from the InTouch Tag Dictionary dialog using the "Select" buπon. the ugs displayed and available for picking will be limited to the current InTouch application. This will keep ^the user from selecting tags from other ug sources that cannot be handled within the InTouch Tag Dictionary dialog.

SΛ where f

selection.

2 1 1.3 Allow Dot Field selection

The Tag Browser can be set to allow or disallow dot field selection. When launched from the Tag ^nonary dialog, dot field selection is no, allowed, when launched from a scrⁱpt for tag selectⁱon^, dot fields cu b. selected. No dot fields will be displayed if dot field selectⁱon ⁱs not allowed.

ΛS 2.1.1.4 Allow Super Tag Selection

The Tag Browser can be set to allow or disallow selection of ugs that contain other ugs (SuperTags). When launched from the Tag Dictionary dialog, SuperTags can be selected, but when launcned for script or animation link tag selection, only SuperTags member dau can be selected. One can select a SuperTag member from the list view by drilling down through the SuperTag as in Figures 2 and 3. Or one can select the SuperTag through the Tree View and the select the member dau in the list view as in Figure 4.

Figure 2 Member selection from list view

Figure Members inside of the SuperTag

Λ53

Figure 4 SuperTag member selection through the Tree and List views

2.1.1.5 Allow None tag selection

The Tag Browser can be set to allow or disallow selection of zero ugs. In normal operation, the user must select a ug before hitting OK. If the Tag Browser is set to allow selection of zero tags, <none will be presented as an option at the top of the tag list This mode is used for selecting pens for vending where assigning zero ugs to a pen is a valid operation.

2.1.1.6 Prβ-filtered tags λ base filter can be applied to the Tag Browser Tag List Control, restricting the set of ugs available for display. For example, this is used in the historical trend to display and allow selection of historically logged ugs only. This filter applies to the ug list only, not to the tree pane.

2.1.2 State Information

2.1.2.1 Persistent State

Sute information will be penisted to a stream handed to the Tag Browser by the calling process. All filters and tag sources defined withm the Tag Browser or its sub-dialogs are stored in this file. For InTouch. this information will be sσeamed to a file kept with the individual InTouch application in the application folder

2.1.2.2 Context Driven State

These are the properties of the Tag Browser dialog that the client application can set before displaying the Tag Browser dialog.

2 1 22 1 Local Tag Source

sg A tag source can be passed to the Tag Browser to set the local ug source to the current InTouch application.

2.1 2.22 Selected App / Tag / Dot Field

The client application can set the initially selected ug source, ug and dot field by passing them to the Tag Browser. Window Maker will use this feature to set the selected ug when the 'Select" burton is pressed from its Tagname Dictionary diaiog.

2.1.3 Tag List Control

The Tag List Control is used to display and select ugs within the current browsing scope. Multiple selection is not allowed in this control. The control will be displayed in either list view (small icon), or deuils view (report) depending on the state of the list / deuiLs buttons. When switching views, this control will keep its current selection visible. Standard UI of selecting a list item by typing the first few letters of a ug name will be used for this control. When focus is removed from the ug list control, the selected ug will remain highlighted. Tags in this conσol will initially be sorted alphabetically by ugname.

2.1.3.1 List View

Small icons will be displayed next to the ugs with icons displayed according to the ug type of each ug. No other fields will be displayed in this view. If switching from Report View, the sort order will be preserved.

2.1.3.2 Detail View

If selected to display in report view, the tags will be displayed in the multiple column format Columns initially included are "Tagname", "Tag Type", "Access Name", "Alarm Group", and "Comment". The columns can be sorted by clicking on the headers from the detail view. An item can be selected by clicking on any portion of its displayed element not just the ugname. A selection bar will highlight the entire row when selected.

2.1.4 Tag Source Droplist

The Tag Source droplist is used to select which ug source will be used to populate the ug list control. The default selection for this control will be "<local>". Tag sources can be added and removed from the list by using the adjacent Define... button. hen the selection is changed, the tags for the selected tag source will be displayed in the ug list control. If the Tag Source Tree View Pane is displayed, the same ug source will be highlighted in the Tag Source Tree View Pane.

2.1.5 Define Tag Sources

The Define Tag Sources... button, adjacent to the Tag Source Droplist control, will bring up the modal Define Tag Sources Dialog (see 2.2 Define Tag Sources Dialog below). When the Define Tag Sources Dialog has returned, the Tag Source Droplist control will be refreshed, and if its current selection is no longer in the group of configured applications, the Tag Source Droplist selection will retum to its default selection.

2.1.6 Tag Source Tree View Pane

A Tag Source Tree View Pane will be included. All configured tag dictionaries (InTouch. InSQL, etc.) will be displayed in the first level of the hierarchy. The second level of the hierarchy will display dau sources configured for the respective ug dictionaries. Selecting a ug source will perform the same action as changing the Tag Source from the Tag Source Droplist.

Uδ O 00/21001

2.1.7 List View and Details View Buttons

The List View and Deuils View buttons together form a radio burton group. Exactly o. burtons will be tn its "on" sute (depressed) at any given time. Using these buttons will . :cπtτoi to switch views.

2.1 3 Dot Field Droplist

The drop field droplist will only be enabled when exactly one ug is selected. It will contaii fields contained within the selected ug. The default value for this control will be "<πone " tag is selected from the Tag List conσol the selected item for this control will remain the sa invalid for the selected ug, in which case selected item will revert to "<none>".

2.1.9 Filter Droplist

The Filter Droplist is used to select which filter to apply to the Tag List control. It will be popul. all user-defined filters. The first entry of this list is "<none ", which means that no filter will be a the Tag List and all available ugs will be displayed. When a filter is selected, the Tag List contra repopulated using the new filter. Note that the base ug filter is always applied before the user filte the user filter can only reduce the set of ugs displayed.

2.1.10 Define Filter Button

The Define Filter Buπon will bring up the Define Tag Filter Dialog (see 2.4 below). If a filter is defined using the Define Tag Filter Dialog, it will be added to the filter droplist and then selected. Two wild cards can be used in order to facilitate filtering. The """ can be used to represent multicharacters and the '"?" can be used to represent a single character.For example, a ug name filter of T?me' could return (if such names are in the item list) such items as Time, Tome, TimeStart, etc.

2.1.11 OK Button

Exactly one ug must be selected from the Tag List control for the OK action to complete successfully. If zero ugs are selected when OK is pushed, the dialog will display the message dialog "Please select a ug" and retum the user to this dialog. If exactly one ug is selected, the Tag Browser dialog will close and return the selected tag and dot field to the calling process. The returned values will include the ugname, the ug ID (handle for InTouch), the dot field name and ID, and the access name associated with the ug source that the ug was chosen from. If the chosen tag is a member of a Super Tag, the fully qualified name for that ug will be returned.

2.1.12 Cancel Button

The Cancel button will always be visible and enabled When this buπon is pushed, the Tag Browser dialog will dose and not retum a tag to the calling process.

2.1.13 Status Bar

The sums bar will be located on the bottom of the dialog. It will include a right hand stretch handle. The following sums items will be indicated on the sums bar

• Total number of items in the Tag List Conσol.

• Name of currently selected ug if one ug selected, or the number of ugs selected if zero or multiple ugs are selected.

• The dot field name selected, if any.

• The access name associated with the ug source that the selected tag is associated with.

Λ5G 2.2 Define Tag Sources Dialog

The Define Tag Sources Dialog is used to specify ug sources to be used. fixed size dialog.

Figure 5: Define Tag Sources Dialog

2.2.1 Tag Sources List

This will show a list of the currently configured ug sources. It will show the local name for the ug source, the dau source string, and the DDE node name for the tag source. It is a multiple selection list conσol.

2.2.2 Close Button

The close button is always active. It will close the dialog when pushed.

2.2.3 New... Button

This buαon is always enabled. It will invoke the Define Tag Source Dialog (see 2.3 below). If a new app is created, it will be reflected in the Tag Sources List

2.2.4 Edit Button

This buαon is enabled when exactly one ug source is selected. It will invoke the Define Tag Source Dialog (see 2.3 below) for the selected tag source. If the ug source is successfully edited, the changes will be reflected in the Tag Sources List.

2.2.5 Delete Button

This bunon will be enabled when one or more ug sources are selected in the tag source list. When pushed it will confirm the deletion, then delete the tag sources selected in the Tag Sources List

2.2 Define Tag Source Dialog

This modal dialog will allow the user to enter in the information to define a ug source including the access name, a user defined ug source name, and dau source information that is custom for each FactorySuite application type. This dialog will retum the selected tag source. Access name, and dau source selected to the calling process.

Figure 6: Define Tag Source Dialog

2.3.1 OK Button

On selecting OK, the dialog will check for valid input then close. If the input is invalid, the user will be notified and focus will be given to the invalid input Valid input is defined as follows:

• The tag source name entered must not already be defined.

• The Network DDE Access name must exist

• The application path entered must exist and be accessible.

If the application path entered is on the local machine, the user will be warned that it is probably an invalid selection.

2.3.2 Cancβi Button

Will dose this dialog without affecting the calling process.

2.3.3 Tag Source Name Edit Control

Allows the user to type m an alias for the ug source. This alias must be unique.

2.3.4 Access Names Droplist

This droplist conσol will be populated with the list of all Access names available in the current application. Selecting one will define the Access name for the tag source.

5δ 2.3.5 Tag Source Location Control _P,_{c r Sulte} a_ppl_ica_tion _tvpe. information

U&\ 2.4 Defme Tag Filter Dialog

The Define Tag Filter Dialog is used to define filters that can be applied to the population of the Tag List conσol This is a modal fixed size dialog.

Figure 7: Define Tag Filter Dialog

2.4.1 OK Button

On selectmg OK. The dialog will check for valid input then close. If the input is invalid, the user will be warned and focus will be given to the invalid input The non-blank Filter Name defines a valid entry. If a new filter name has been entered, this filter will be added to the list of available filters.

2.4.2 Cancel Button

Will close this dialog without affecting the calling process.

2.4.3 Delete Button

If the Filter Name exists, the Delete Buαon will be enabled. If selected the program will delete the Filter Name specified in the Filter Name Edit Control.

2.4.4 Filter Name Edit Control

Allows the user to type in name that identifies the filter with the filter options.. This name must be unique.

2.4.5 Filter Options

Filter options allows the user to enter filter strings for various fields in a tag. When applying a filter to a tag, each filter string entered will be evaluated separately and then all results will be logically anded together to determine whether a tag will be included. Filter strings can be applied to the following fields:

AGO Tagname Tag Type Access Name Alarm Group Comment

ignoring case. Wild cards and . can oe us^βα , _w -^ _maχchts ^ _sιng._e

•_••_* w_ildcard ma_tches any sequence of zero or more c^harac^ters, aπα mm character.

M APPENDIX D

Tagfilter.cpp:

#include "stdafx.h" #include "TagFltr.h"

CTagFilter: :CStateTableEntry: :CStateTableEntry()

{

}

UINT CTagFilter: :CStateTableEntry::Create(const UINT CurrentState, const WCHAR Input, const WCHAR Multiple WildcardChar, const UINT StateToTransitionTo, const bool LastState, const bool FinalState)

{

// put information into the data members m_State = CurrentState; m_Input = Input; m_bLastState = LastState; m_bFinalState = FinalState; if (StateToTransitionTo = CREATE_STATE)

{ // define the new state, if necessary if (Input = MultipleWildcardChar)

{

// essentially no transition m_NextState = m_State;

} else

{

// we need to create a new state m NextState = CurrentState + 1 ;

}

} else

{ // accept the state passed in m_NextState = StateToTransitionTo; }

// all done return m_NextState;

448534 vl /PA

9M3@01 !.DOC G }

CTagFilter: :CTagFilter(const CString& strNewFilter, WCHAR MultipleWildcardChar, WCHAR SingleWildcardChar, bool bCaseSensitive)

{

// set the data m MultipleWildcardChar = MultipleWildcardChar; m_S ingle WildcardChar = SingleWildcardChar;

// set state count m_NumberOfStates = 0; m_pSetOfStates = NULL; m_pNewSetOfStates = NULL;

// do the swap m_CurrentFilter = strNewFilter;

// destroy current machine and then construct the new state machine ConstructStateMachine(m_CurrentFilter, bCaseSensitive); }

CTagFilter: :~CTagFilter()

{

// destroy the state machine

DestroyStateMachineO ; } bool CTagFilter: :FindDuplicate(const UINT States[], UINT CountOfStates, UINT TargetState)

{

// iterate over the collection looking for a match for (UINT Pos = 0; Pos < CountOfStates; Pos++)

{

// do the check if (States[Pos] = TargetState) return true;

}

// no duplicate found return false; } bool CTagFilter: :IsAMember(const CString& strTarget)

{

// look for empty filter if (m_CurrentFilter.IsEmpty()) return true;

ΛG // iterate over the string transitioning through state machine UINT CountOfSetOfStates = 0; UINT CountOfNewSetOfStates = 0;

// sanity check if (!m_pSetOfStates || !m_pNewSetOfStates)

{ // return the memory if (m_pSetOfS tares) delete [] mjpSetOfStates; if (mjpNewSetOfStates) delete [] m_pNewSetOfStates;

// reset pointers m_pSetOfStates = NULL; m_pNewSetOfStates = NULL;

// return failure return false; }

// set the first state m_pSetOfStates[CountOfSetOfStates++] = STARTING_STATE;

// transition through the characters in the tag name

// TSW 081098, 10002190, Filter of Tag Browser can not process Japanese

// OLD

//int TargetLength = strTarget.GetLength();

// NEW int TargetLength = mbstowcs(0, strTarget, strlen(strTarget));

//wcharj wcstr[128]; wchar_t *wcstr = (wcharj *)malloc((TargetLength+l)*sizeof(wchar_t)); mbstowcs(wcstr, strTarget, strlen(strTarget));

// TSW 081098, End for(int i = 0; i < TargetLength; i++)

{ bool bTransitionOccurred = false;

// TSW 081098, 10002190, Filter of Tag Browser can not process Japanese

// NEW

//char CurrentlnputChar = strTarget[i];

// OLD wchar_t CurrentlnputChar = wcstr[i];

// TSW 081098, End

ΛGL, // examine each state in the current set of states for (UINT CurrentStatelndex = 0; CurrentStatelndex < CountOfSetOfStates; CurrentStatelndex-H-)

{

// examine each state transition in the state machine

POSITION CurrentMachinePos = m_StateMachine.GetHeadPosition(); while (CurrentMachinePos)

{

CStateTableEntry* pMachineState = (CStateTableEntry*) m_StateMachine.GetNext(CurrentMachinePos); if (pMachineState)

{

// where can we go? if (m_pSetOfStates[CurrentStateIndex] = pMachineState->GetState())

// do the transition, if possible

WCHAR Validlnput = pMachineState-

>GetInput(); if (pMachineState->IsLastState() = false &&

(CurrentlnputChar = Validlnput || Validlnput = mJVIultipleWildcardChar

|| Validlnput = m_S ingle WildcardChar))

{

// keep track of the state transition to but avoid duplicates if (FindDuplicate(m_pNewSetOfStates, CountOfNewSetOfStates, ρMachineState->GetNextState()) = false)

{ mj)NewSetOfStates[CountOfNewSetOfStates++] = pMachineState->GetNextState();

}

// keep track of the fact that a transition has occurred bTransitionOccurred = true;

} else

{

// tag name or machine is hosed return false;

ΛG5 // make sure we transitioned if (bTransitionOccurred = false)

// return failure return false;

}

// copy newly created states into starting set of states for (UINT Pos = 0; Pos < CountOfNewSetOfStates; Pos++)

{ m_pSetOfStates[Pos] = m_pNewSetOfStates[Pos];

}

// redefine counts

CountOfSetOfStates = CountOfNewSetOfStates;

CountOfNewSetOfStates = 0;

}

// TSW 081098, 10002190 free(wcstr);

// TSW 081098, End

// where did we end up? if any state in the set of states is a final state // then the tag name is acceptable otherwise it is not for (UINT Pos = 0; Pos < CountOfSetOfStates; Pos++)

{

// iterate over the state machine looking for final state status

POSITION CurrentMachinePos = m_StateMachine.GetHeadPosition(); while (CurrentMachinePos)

{

CStateTableEntry* pMachineState = (CStateTableEntry*) m_StateMachine.GetNext(CurrentMachinePos); if (pMachineState)

{

// are we in a final state? if (m_pSetOfStates[Pos] = pMachineState->GetState() && pMachineState->IsFinalState())

{ // return success return true;

} } } }

// we failed to be in a final state return false; } void CTagFilter: :AddNewState( WCHAR CurrentlnputChar, bool bCaseSensitive)

{

// hang onto the previous state in case we need to create a duplicate

UINT PreviousCurrentState = m_CurrentState;

// create the new state

CStateTableEntry* pState = new CStateTableEntry; if(pState)

{ // fill in the information m CurrentState = pState->Create(m_CurrentState, CurrentlnputChar, mJVlultipleWildcardChar, CStateTableEntry: :CREATE_STATE, false, false);

// attach it to the existing state machine m_StateMachine.AddTail(pState);

// do we need to create a duplicate entry if (iswalpha(CurrentlnputChar) && bCaseSensitive = false)

{ // create the duplicate state pState = new CStateTableEntry; if(pState)

{ WCHAR InputChar; if (iswupper(CurrentlnputChar))

InputChar = towlower(CurrentlnputChar); else

InputChar = towupper(CurrentlnputChar);

// be careful about the state here since we want the machine

// to transition to the state previously created m CurrentState = pState->Create(PreviousCurrentState, InputChar, mJVlultipleWildcardChar, m_CurrentState, false, false);

// attach it to the existing state machine m_StateMachine.AddTail(pState);

// increment state count m_NumberOfStates++;

}

}

ΛG9- }

UINT CTagFilter::AddLastState()

{ // allocate the last state

CStateTableEntry* pState = new CStateTableEntry; if (pState)

{ // fill in the information m_CurrentState = pState->Create(m_CurrentState, ' ', mJVlultipleWildcardChar, m_CurrentState, true, true);

// attach it to the existing state machine m_StateMachine.AddTail(pState);

// increment the count m NumberOfStates-H-;

// return the last state return m CurrentState;

}

// return unknown state return UNKNOWN STATE;

} void CTagFilter: :MarkFinalStates()

{

// iterate over the list marking states as final. States are final if they // have a transition to the last state on input of m_MultipleWildcardChar CStateTableEntry* pState;

POSITION CurrentPos = m_StateMachine.GetHeadPosition(); while ((CurrentPos) && (pState = (CStateTableEntry*) rnJStateMachine.GefNext(CurrentPos)))

{ if (pState->GetNextState() = m_CurrentState && pState->GetInput() == m_MultipleWildcardChar)

{

// mark status pState->SetFinalState(true);

} } } void CTagFilter: :ConstructStateMachine(const CString& strFilter, bool bCaseSensitive) {

JGS // get rid of the current machine DestroyStateMachine();

// define the starting state m_CurrentState = STARTING_STATE;

// loop over input string

// TSW 081098, 10002190, Filter of Tag Browser can not process Japanese

// OLD

//int strLength = strFilter.GetLength();

// NEW

/ΛvcharJ

int strLength = mbstowcs(0, strFilter, strFilter.GetLength()); wcharj *\vcstr = (wchar_t *)malloc((strLength+l)*sizeof(wchar_t)); mbstowcs(wcstr, strFilter, strFilter.GetLength());

// TSW 081098,End

for(int i = 0; i < strLength; i++)

{

// build the state needed to process this char

// TSW 081098, 10002190, Filter of Tag Browser can not process Japanese // OLD //AddNewState(strFilter[i], bCaseSensitive);

// NEW AddNe\vState(wcstr[i], bCaseSensitive); // TSW 081098,End

}

// TSW 081098, 10002190, Filter of Tag Browser can not process Japanese free(wcstr);

// TSW 081098,End

// add the last state m_LastState = AddLastState();

// define final states MarkFinalStates();

// get memory for state machine operation m_pSetOfStates = new UINT[m_NumberOfStates]; m_pNewSetOfStates = new UTNT[m_NumberOfStates];

} void CTagFilter: : Destroy StateMachine()

{

// iterate over the collection deleting the elements

λG) POSITION Victim = m_StateMachine.GetHeadPosition(); while (Victim)

{

CStateTableEntry* pVictim (CStateTableEntry*) m_StateMachine.GetNext(Victim); if (pVictim) delete pVictim; }

// clear out the collection m_StateMachine.RemoveAll();

// reset the count m_NumberOfStates = 0;

// return previously allocated memory if(mjpSetOfStates)

{ delete [] mjpSetOfStates; m_pSetOfStates = NULL;

} if (m_pNewSetOfStates)

{ delete [] m_pNewSetOfStates; m_pNewSetOfStates = NULL;

} }

CFilterAddOns::CFilterAddOns(const CString& strNewFilter, WCHAR

MultipleWildcardChar,

WCHAR SingleWildcardChar, bool bCaseSensitive)

{ m_pFilterMachine = new CTagFilter(strNewFilter, MultipleWildcardChar,

SingleWildcardChar, bCaseSensitive); m_bValue = false;

}

tagfilter.h:

#ifndef__TAG_FILTER_ #define _TAG_FILTER_ class CTagFilter {

λlO public:

// general operations CTagFilter(const CString& strNewFilter, WCHAR MultipleWildcardChar, WCHAR SingleWildcardChar, bool bCaseSensitive = false); -CTagFilter(void);

// membership operations bool IsAMember(const CString& strTarget); private: enum

{ UNKNOWN_STATE = 0,

STARTING_STATE = 1,

} ;

// worker bees void ConstructStateMachine(const CString& strFilter, bool bCaseSensitive); void DestroyStateMachine(void); void AddNewState(WCHAR CurrentlnputChar, bool bCaseSensitive);

UINT AddLastState(void); void MarkFinalStates(void); bool FindDuplicate(const UINT States[], UINT CountOfStates, UTNT TargetState);

// data

CString m_CurrentFilter;

WCHAR m_MultiρleWildcardChar;

WCHAR m_SingleWildcardChar;

CObList m_StateMachine;

UINT m_CurrentState; UINT m_LastState; UINT m_NumberOfStates;

UINT* mjpSetOfStates;

UINT* m_pNewSetOfStates; private: //

// nested class needed to build state machine // class CStateTableEntry : public CObject

{ public:

CStateTableEntry(void);

UINT Create(const UINT CurrentState, const WCHAR Input, const WCHAR MultipleWildcardChar, const UINT StateToTransitionTo, const bool LastState, const bool FinalState);

// get status

UINT GetState(void) { return m_State; } WCHAR Getlnput(void) { return m nput; } UINT GetNextState(void) { return m_NextState; }

// set status void SetFinalState(bool State) { m_bFinalState = State; }

// for information bool IsFinalState(void) { return m_bFinalState; } bool IsLastState(void) { return m_bLastState; }

enum

{ CREATE_STATE = -1,

}; private: bool m_bFinalState; bool m_bLastState; UINT m_State; WCHAR mjnput; UINT m_NextState;

} ;

};

// class for attaching additional information to the provided filter class CFilterAddOns

{ public:

// member functions

CFilterAddOns(const CString& strNewFilter, WCHAR MultipleWildcardChar, WCHAR SingleWildcardChar, bool bCaseSensitive);

-CFilterAddOns(void) { delete m_pFilterMachine; } public: // data

CTagFilter* m_pFilterMachine; bool m_bValue;

} ;

//

// stack class for operators

A 1 //

template <class T> class CStack

{ public:

CStack(int nMaxSize);

-CStack(void);

T Top(void);

T Pop(void); int Push(T nSymbol); int IsEmpty(void); static int Prcd(char opl, char op2); static int IsOp(char nChar); private:

T* m_pStack; int m_TopIndex; int m_M ax Index;

};

// member functions template <class T> CStack<T>::CStack(int nMaxSize)

{

// sanity check on the requested size if(nMaxSize <= 0) nMaxSize = 100;

// get the memory m_pStack = new T[nMaxSize]; if (!m_pStack) return;

// define the top of stack index m_TopIndex = -l;

// keep track of max index m Maxlndex = nMaxSize - 1 ;

} template <class T> CStack<T>::~CStack()

{ delete [] m_pStack;

}

λϊ?> template <class T>

T CStack<T>::Top(void)

{

// sanity check if (m_TopIndex == -1) return ' ';

// return topmost item return m_pStack[m_TopIndex];

} template <class T>

T CStack<T>::Pop(void)

{

// sanity check if (mJTopIndex = -1) return ' ';

// return the information, adjust the top of stack return m_pStack[ιri_TopIndex— ];

} template <class T> int CStack<T>::Push(T nSymbol)

{

// sanity check if (m_TopIndex >= m_MaxIndex) return 0;

// do the push m_pStack[++m_TopIndex] = nSymbol; return 1; } template <class T> int CStack<T>::IsEmpty(void)

{ retum m TopIndex = -1 ? 1 : 0;

}

// TRUE if opl has precedence over op2

// when opl is to the left of op2 in an

// infix expression template <class T> int CStack<T>: : Prcd(char op 1 , char op2)

{

// handle the parenthesis

Λl-L if(opl=T) return 0;

if (opl !=')^■&& op2 = '(') return 0; if (opl !='('&& op2 == ')') return 1; if (op l=='('&&op2 ==')') return 0;

// ! has precedence over everything left if (opl =='!') return 1;

if(op2 = T) return 0;

// & had precedence over | if(opl='&'&&op2 = ^,r) return 1; if (opl = '&' && op2 = '&') return 0;

// everything else must yield return 0; } template <class T> int CStack<T>::IsOp(char nChar)

{ switch (nChar)

{ case '&': case 'I': case '!': case '(': case ')"• return 1; break; default: return 0; break;

S } }

#endif

λ^G APPENDIX E

DataSource Validation:

ODL syntax: boolean DataSourceValidation( [out] long* phWnd, [out] boolean* pBIsEdit)

IDL syntax: HRESULT DataSourceValidation([out]long* phWnd, [out]VARIANT_BOOL* pBIsEdit, [out,retval] VARIANT_BOOL* pbResult);

Where the return value is VARIANT_TRUE if the DataSource property is valid, VARIANT_FALSE otherwise. The phWnd (if non-NULL) indicates a valid HWND so that the control container may set focus and the boolean pBIsEdit indicates if this HWND is an EDIT control. If it is an EDIT control, the control container will set the selection property after setting focus. If this method is not provided by the DataSource control, the control container assumes that the DataSource control is always valid. If the validation fails, then the DataSource control has two options for allowing notification of the validation failure to be presented to the user. Either the DataSource control displays a message box, or more preferably the control provides an optional read-only BSTR property called LastErrorDescription.

Optional read-only property named "LastErrorDescription " of type BSTR. The control container, to determine the description of the validation failure (see DataSourceValidation), will query this property. This string should be a complete description of the reason for validation failure.

Optional read- write property named "LocallD" of type long. This optional property will be used by the control container to specify the local identifier (LCID). The local identifier may affect the presentation of the control and the optional read-only LastErrorDescription property.

x&

Claims

What is claimed is:

1. A system for providing representations of one or more tag sources associated with corresponding component devices, said system comprising: a tag dictionary for defining said tag sources in a predefined format, said tag dictionary including tag definition objects containing information relating to associated ones of said tag sources; and a tag browser for displaying said representations of said tag sources based upon said tag definition objects.

2. The system of claim 1 wherein each of said tag definition objects is associated with a tag type object.

3. The system of claim 2 wherein each said tag type object comprises a collection of dot field objects.

4. The system of claim 1 wherein said tag dictionary implements a method disposed to return a unique identifier from each of said tag sources, each of said tag sources being implemented as an object-oriented control.

5. The system of claim 1 further including means for generating a template tag dictionary, said template tag dictionary being capable of modification to reflect attributes of said tag sources.

6. The system of claim 1 further including means for generating template object-oriented controls of a predefined format compatible with said tag dictionary, said tag sources being represented by instantiated ones of said template object-oriented controls.

7. The system of claim 1 wherein each of said representations includes information relating to a predefined set of parameters characterizing said tag sources, and wherein.said tag browser includes a tag filter for causing display of only said representations of said one or

λU more tag sources comporting with tag selection criteria, and for suppressing display of all other ones of said representations.

8. The system of claim 7 wherein said tag filter includes means for generating a non- deterministic finite automation disposed to accept identifiers of said tag sources comporting with said tag selection criteria, said tag filter displaying said representations corresponding to said identifiers comporting with said tag selection criteria and suppressing display of representations of all other such representations.

9. A program product for use in a computer system, the program product comprising: a signal bearing media; and a sequence of instructions executable by the computer system, the sequence providing a tag dictionary for defining said tag sources in a predefined format, said tag dictionary including tag definition objects containing information relating to associated ones of said tag sources, and a tag browser for displaying said representations of said tag sources based upon said tag definition objects, each of said representations including information relating to predefined set of parameters characterizing said tag sources.

10. The program product as defined in claim 9, wherein the tag browser further includes a tag filter for causing display of only said representations of said one or more tag sources comporting with tag selection criteria, and for suppressing display of all other ones of said representations.

11. A tag provider for displaying representations of a plurality of tag sources associated with a corresponding plurality of component devices, said tag provider comprising a tag dictionary for defining said tag sources in a predefined object-oriented format, said tag dictionary including tag definition objects containing information relating to associated ones of said tag sources wherein each of said tag definition objects is associated with a tag type object; and

Λ a tag browser for displaying and editing said representations of said tag sources in accordance with said tag definition objects, each of said representations including information relating to a predefined set of parameters characterizing said tag sources.

12. The tag provider of claim 11 wherein said tag browser further includes tag filter for causing display of only said representations of said one or more tag sources comporting with tag selection criteria, and for suppressing display of all other ones of said representations.

13. A method for providing representations of one or more tag sources associated with corresponding component devices, said method comprising the acts of: defining said tag sources in a predefined format, said tag dictionary including tag definition objects containing information relating to associated ones of said tag sources; and displaying said representations of said tag sources based upon said tag definition objects, each of said representations including information relating to predefined set of parameters characterizing said tag sources.

14. The method of claim 13 further including the act of associating a tag type object with each of said tag definition objects.

15. The method of claim 13 further including the acts of displaying only said representations of said one or more tag sources comporting with tag selection criteria, and suppressing display of all other ones of said representations.

16. The method of claim 13 further including the act of generating a template tag dictionary and modifying said template tag dictionary to reflect attributes of said tag sources.

17. A tag dictionary for use with an application program disposed to monitor a plurality of tag sources, said tag dictionary comprising: a plurality of tag definition objects containing information relating to associated ones of said tag sources; and a plurality of tag type objects, each of said tag type objects (i) being associated with a corresponding one of said tag definition objects, and (ii) including a collection of dot field objects.

18. The tag dictionary of claim 17 further including means for implementing a method for returning a unique identifier from each of said tag sources in response to a query by said application program wherein each of said tag sources is implemented as an object-oriented control.

λ%Λ