IntelleDoc Viewer Control Implementation Guide
Licensing CSi IntelleDoc Solutions™ Products
CSi IntelleDoc Solutions™ license keys are used to provide access to the functionality the financial institution has licensed from CSi.
All financial institutions receive a single license key for all CSi IntelleDoc Solutions™ products. This includes Custom Document Editor, the Transaction Manager suite, Compliance Services, IntelleDoc Viewer Control, CSi Simplicity, and documents.
A CSi IntelleDoc Solutions™ license key contains an encoding string of the following attributes: CSi Custom Number, CSi Customer name, Expiration Date, Document Sets Licensed, Custom Institution Type, Simplicity, CDE, IntelleDoc SDK and all properties associated with each attribute listed before.
The license key can vary in length due to its dynamic structure. The previous key (V2) ranges from 90 to 200 characters. The new key (V3) ranges from 350 to 500 or sometimes more characters. For storage purposes, a length less than one database page is sufficient for the license keys. For example, in SQL server the size of database page without header is about 8kb.
Updates
License keys expire on a predetermined date. CSi will contact the financial institution to provide a new license key in advance of that date to ensure that there is no interruption in product access. In the event that a financial institution adds or subtracts products, it will be issued a new license key by CSi.
Integration
CSi business partners need to store only a single license key per financial institution. The financial institution’s license key must be passed to the IntelleDoc Viewer Control and Transaction Manager integration point (Transaction Server/Transaction Runner/Compliance Service) for each document selection or rendering. This is critical as the license key holds the financial institution’s Institution Type (i.e., bank, mortgage bank, savings & loan, etc.). Failure to pass the correct financial institution’s personal license key can result in incorrect document selection.
CSi IntelleDoc Solutions™ Product Redistribution
Certain products associated with CSi IntelleDoc Solutions™ are intended for redistribution for use at financial institutions while others are not. The table below provides CSi guidelines for redistribution of CSi IntelleDoc Solutions™ components.
| Redistribute | Do Not Redistribute |
|---|---|
| IntelleDoc Viewer Control | FxlRender |
| Custom Document Editor | |
| Transaction Manager Suite Components | |
| All document libraries |
IntelleDoc Viewer Control Concepts
The IntelleDoc Viewer Control is a CSi IntelleDoc Solutions™ API and GUI that allows documents to be viewed and data for datapoints to be collected. It is delivered as a .NET class library and embeds the CSi IntelleDoc Solutions™ Compliance Engine for the selection and rendering of documents in a GUI environment. It is intended for client workstation implementations.
The IntelleDoc Viewer Control visualizes documents on screen and allows data to be collected for its datapoints. When a document is loaded with no missing datapoints, the IntelleDoc Viewer Control renders the document. If the loaded document has missing datapoints, the IntelleDoc Viewer Control displays a table of the missing data.
When no document is loaded, the IntelleDoc Viewer Control displays the CSi logo.
Understanding Documents
CSi IntelleDoc technology creates different types of electronic documents, or eDocs, that can be viewed on screen and printed.
Static IntelleDocs use fixed text. The only data that changes is the transaction-specific input for the datapoints included in the documents. The static text and layout of these documents does not change based on data input.
The content of dynamic IntelleDocs varies based on the data values that are provided. Blocks of content may be included or excluded based on the values of one or more datapoints.
FXL files contain document content, content selection logic, and associated metadata as well as data processing logic for selecting documents and additional metadata. They perform two types of selection:
Document selection. FXL files may be used to generate a list of documents required to perfect a transaction.
Content selection. FXL files may be used to generate the text content of a document.
The IntelleDoc Viewer Control is designed for content-selection documents.
Datapoints
Datapoints are variable data placeholders used to populate a document. Datapoints may have an associated data type for data validation. The majority of CSi datapoints are mapped to a node in the CSi Data Schema, and values can be provided via the schema instead of as a key/value pair.
Datapoint names are not case sensitive, but datapoint values are case sensitive. For example, the datapoint names C_GNL_ADDR_INST_InstitutionCity and c_gnl_addr_inst_institutioncity are recognized as the same datapoint by CSi software. However, the datapoint values A1 and a1 are recognized as different values by CSi software.
CSi Datapoint Naming Conventions
Datapoints are named based on succeeding levels of Division, Group, Category, Section and Description. Each level is separated by an _ (underscore). Each level follows a standard abbreviation convention that communicates its identifying information.
Example
C_GNL_ADDR_INST_InstitutionCity
| Level | Identifier |
|---|---|
| Division (1 character) | The division level represents the highest level product grouping to which the data is applicable. C – Common. Applicable if data may be used for all products (Deposit, Lending, and Tax Deferred Accounts) D – Deposit. Used exclusively for data appearing only in Deposit products. L - Lending. Used exclusively for data appearing only in Lending products (Consumer, Commercial, or Mortgage). I – TFA. Used exclusively for data appearing only in TFA products. _ No Identifier indicates a calculated field |
| Group (3 characters) | The group level represents the product usage within each division. CML - Commercial CNS - Consumer GNL – General GOV – Government SEL – Document Selection |
| Category (4 characters) | The category level represents the primary nature or type of data as which the datapoint is classified. Custom: CTOM - Custom Field Product: ACCT - Account Information ADDL - Additional Information ADDR - Address BSNE - Business Entity Information BUSN - Business Information CLLT - Collateral Information CLON - Collateral Co-owner |
| Section (4 characters) | The section level represents a secondary or additional layer of information descriptive of the nature or type of data the datapoint is classified as. Section is supplemental to the category selected. Workflow: XSIM – Simplicity Workflow TFAW – TFA Workflow DEPW – Deposit Workflow LNDW– Lending Workflow PMTW– Payment Calculation Workflow Custom: CTOM - Custom Field SPRT - Support (Custom) Information Product: ADDR - Address ADTL - Additional Information AGRI - Agricultural BENE - Beneficiary Information BORR - Borrower Information BSNE - Business Entity Information BUSN - Business Information CALC - Sherman Calculations only CARD - Access/Debit/Credit Card CDIS - Closing Disclosure CESA - ESA Agreement Provisions CLLT - Collateral CLON - Collateral Co-owner COSN - Co-signer Information DATA - Administrative Data DATE - Date DEPR - Depositor Information FDCY - Fiduciary Information GFES - Good Faith Estimate Information GUAR - Guarantor Information HSAX - HAS Agreement Provisions HUDI - HUD Information HYPO - Hypothecator Information INDV - Individual Information INST - Institution Information INSU - Insurance Information |
| Description (unlimited characters; word breaks designated by uppercase letter; no spaces) | Example: FirstSecondThirdWord |
General Datapoint Naming Conventions
Datapoint names can consist of the following characters:
- letters
- numbers
- dash (-)
- underscore (_)
- period (.)
Datapoint names must not begin with a period (.). Two periods in succession (..) are not allowed anywhere in a datapoint name.
CSi recommends that partners using custom datapoint names begin those names with a company abbreviation prefix to avoid namespace conflicts.
Datapoint names beginning with underscore (_) are reserved for CSi datapoint names.
Datapoint Usage Types
All datapoints have an associated usage type that identifies when its data is required or optional. A form may be considered complete or incomplete based on data supplied to its datapoints. Additionally, a form may or may not render based on data supplied to its datapoints.
An in-play datapoint is one that is required in order for a document to be considered complete. In order for a form to be considered complete, all in-play datapoints must be supplied. As data is supplied to a document to satisfy initial datapoints and its form logic is executed, additional datapoints may be required for the form to render or be considered complete. The in-play datapoints for a given document may thus evolve as the document is being completed.
| Usage type | Description |
|---|---|
| structural_required | The datapoint is required to render the document. If such a datapoint is not supplied, CSi IntelleDoc Solutions™ does not render the document and reports that a value for the datapoint must be supplied. |
| structural_conditional | The datapoint may be required, depending on the values supplied for one or more other datapoints. If such an in-play datapoint is not supplied, CSi IntelleDoc Solutions™ does not render the document and reports that a value for the datapoint must be supplied. Once a structural_conditional datapoint is put in-play, it is considered structural_required. |
| structural_optional | Identifies datapoints that are not required, but affect the structure and/or content of the form if values are supplied. |
| data_required | The datapoint is required in order for the document to be legally compliant. If such a datapoint is not supplied, CSi IntelleDoc Solutions™ renders the document and places the warning message Form must be completed as a watermark on the top of the document. |
| data_conditional | The datapoint may be required, depending on the values supplied for one or more other datapoints. If such an in-play datapoint is not supplied, CSi IntelleDoc Solutions™ renders the document and places the warning message Form must be completed as a watermark on the top of the document. Once a data_conditional datapoint is put in-play, it is considered data_required. |
| optional | The datapoint is not required. If a value is supplied, CSi IntelleDoc Solutions™ includes this value in the document. If no value is supplied, CSi IntelleDoc Solutions™ renders the document with no warning or error messages. |
Suffixed Datapoints
Some datapoints can be suffixed, allowing a single datapoint name to reference multiple values. A realized datapoint name is one that has been populated with suffix data values. Suffixed datapoints have a format of datapointName.i, where .i represents an unrealized suffix: one that has not been populated with suffix data values. The .i is a placeholder for a suffix value that has not yet been identified. For example, EntityId.1 and EntityId.2 can each hold a different entity ID value. If a suffixed datapoint has no value, it does not render.
Some datapoints have multiple suffix levels, which behave similar to a multidimensional array. For example, a datapoint with three suffix levels has a format of datapointName.i.j.k.
Embedded Datapoint Tags
Certain character attributes may be embedded with the data in a datapoint. Attributes may be combined in any sequence as long as an attribute’s tag pairing is maintained.
| Attribute | Tag | Example | Output |
|---|---|---|---|
| Datapoint insertion | <datapoint name=“dp”/> | Today’s date: <datapoint name=“date_datapoint” /> | Today’s date: January 1, 2006. |
| Bold | <bold> </bold> | The <bold>lazy</bold> dog. | The lazy dog. |
| Italics | <ital> </ital> | The <ital>lazy</ital> dog. | The lazy dog. |
| Strikeout | <strike> </strike> | The <strike>lazy</strike> dog. | The |
| Subscript | <sub> </sub> | The <sub>lazy</sub> dog. | The ~lazy~ dog. |
| Superscript | <super> </super> | The <super>lazy</super> dog. | The ^lazy^ dog. |
| Underline | <under> </under> | The <under>lazy</under> dog. | The lazy dog. |
| New line | <printline/> | The lazy dog.<printline/>The quick fox. | The lazy dog. The quick fox. |
| Tab | <tab/> | <tab/>The lazy dog. | The lazy dog. |
Using the Datapoint Insertion Tag
A datapoint name tag can reference a series of nested datapoints, all of which resolve in the parent data field so long as they are written correctly. When the data field displayed in the Datafields window, only the parent datapoint is eligible for modification.
For example, an OXL file may contain a fixed text overlay field. The field contains text and a CSiScript tag:
The <datapoint name=“Dp2”/>
The value of Dp2 is “brown <datapoint name=“Dp3”/>
The value of Dp3 is “dog jumps over the <datapoint name=“Dp4”/> fox.”
The value of Dp4 is “lazy”.
The resulting output for the fixed overlay field is “The brown dog jumps over the lazy fox.”
Predefined Datapoints
Datapoints that begin with an underscore ( _ ) are reserved for use by CSi and are referred to as predefined datapoints. If datapoints begin with an underscore, but are not included on CSi’s predefined datapoint list, they are ignored. These datapoints are not returned by the Compliance Engine as in play.
CSi IntelleDoc Solutions™ Files
A combination of data files contain the information necessary to fully process a document with the Compliance Engine.
FXL Document Files
FXL is the file format used by an IntelleDoc file. It is an encrypted XML file that contains document content, content selection logic, and associated content metadata. It also includes data-processing logic for selecting documents and additional selection metadata. They perform two types of selection:
Document selection. FXL files may be used to generate a list of documents required to perfect a transaction.
Content selection. FXL files may be used to generate the text content of a document.
Multiple FXL files can be chained together in the Compliance Engine to enhance functionality. For example, partner and institution document-selection customization may be handled by chaining additional partner-specific and institution-specific FXL files behind a generic/general document selection FXL file.
Data Files
CSi supports two formats for the data files that supply transaction-specific values to FXL files.
DXL Data Files
DXL is the file format for an eDoc data file. It is an XML file that supplies to the Compliance Engine data values along with the associated layout directives for values that are displayed. Data values that are displayed on an eDoc form may have a number of corresponding attributes that dictate their display characteristics. See Appendix C (”Appendix C — DXL Syntax, Schema, and Datavalue Attributes” for more information.
The DXL format uses key/value pairs to present transaction data defined with a common data dictionary. Generally, a DXL file corresponds to a single IntelleDoc.
TXL Data Files
TXL is the data file format modeled on the CSi Data Schema. TXL is an XML file that supplies all of the information necessary to document a given transaction and may require multiple IntelleDocs to contain and present that information. Value elements in the TXL file may have a number of corresponding attributes that dictate their display characteristics.
OXL Overlay Files
OXL is the file format used by overlay files. It uses XML to store overlay information. It is an optional file used only when customizations have been added to an FXL file. See Appendix B (”Appendix B — OXL Structure and Schema” on page 53) for more information on OXL file structure and schema.
OXL files contain overlays. An overlay is a field used to add additional elements to a CSi document. The element can be:
fixed text - static text that displays in the same way every time the document is used. Fixed text overlays may also hold datapoints inserted into the static text.
mergable text - data from any single datapoint that you define for the field.
images - contains a datapoint that specifies an image that is used for display in the field.
graphic shapes used to format the document or increase its readability. These can be lines, rectangles, or circular shapes.
IntelleDoc Viewer Control Features
Passing Data
Data from DXL files may be read by the Compliance Engine using three methods. These methods are applicable to image data as well as data values for mergable text overlays and image overlays.
| Text | general text string General text strings are rendered as is in the document. XML-sensitive characters in the text must be escaped. For example, “&” becomes “&“ |
| From File | <image name=“datapointName”/> The value of the datapoint may be a file location. The file at the given location is read and the file’s data is rendered in the document. <file type=“image |
| Stream | <image name=“datapointName”/> The value of the datapoint may be a streamed image. The image data is decoded and rendered as an image in the document. <image>base64 encoded image data</image> |
The Compliance Engine validates all input data values before processing the FXL file. This means that a data value is validated even if it is not used. For example, if a superfluous datapoint has a value that references a file and the file does not exist, then an error is generated for that datapoint.
Graphics
The CSi IntelleDoc Solutions™ supports the use of graphics as a datapoint value. The IntelleDoc Viewer Control can read a file in the data of a datapoint, or it can accept a streamed graphic. Supported graphic file formats include:
| BMP | JPEG | TIFF |
| EMF | BMP | WMF |
| GIF | PNG |
An image can be specified as a datapoint value using one of the two following syntaxes.
<file type=“image”>UNC path of image file</file>
OR
<image>base64-encoded image data</image>
For example, if the image file intended for datapoint use was located at \images\file01.jpg, the datapoint value would be:
<file type=“image”>\images\file01.jpg</file>
All binary data must be encoded in BASE64. When passing graphic data for current Logo and new Signature datapoints, the data must be enclosed in case-sensitive tags.
Digital Signature Images
CSi’s documents support image fields that can be used to insert digital signature images collected from a signature pad into a document. The IntelleDoc Viewer Control allows the user to select a signer by clicking on the appropriate signature field within the document. This is particularly helpful for documents that require more than one signature from the same signer and for documents that include a number of boxes requiring the signer’s initials.
The IntelleDoc Viewer Control indicates the location of all unlocked image fields through the display of a colored rectangle. This color is configurable by your application using the ImageFieldHighlightColor property and is independent of colors used to display other fields in the document. The default value of this property is Yellow.
A field is highlighted with the color indicated by the property if:
The ImageFieldsEnabled property is set to true. The default for this property is false in order to maintain its previous behavior.
The field is defined in a dynamic FXL file using the <image> tag or the field is defined in a static FXL or OXL file using the <object type= “image”> tag.
The value of the field’s locked attribute is false.
The IntelleDoc Viewer Control does not differentiate between image fields used for digital signatures and image fields used for any other purpose, such as a financial institution logo. The application must set locked to true for any image field that is not intended to be clickable.
Page Size and Orientation
The page size and page orientation of dynamic eDocs can be changed. Use the PageFormatCanChange property to determine if page size and orientation can be changed for a given document. If they can be changed, use the PageFormat property to make necessary modifications.
Overflow Text
Shrink-to-Fit and Truncate options may be applied to mergable text overlay fields and fields in static documents. Dynamic documents are not affected by these options.
Shrink-to-Fit forces the size of text characters to shrink to fit in a field when the size of the field does not allow all text characters to be displayed. The text shrinks until it fits or reaches the minimum font size. If the minimum font size is reached before the text fits, the text overruns the field. The font is reduced by .1 increments.
Truncate shortens text to fit in a field when the size of the field does not allow all text characters to be displayed. When Truncate is enabled and the text of the datapoint does not fit in a field, the truncation symbol (§) appears in the lower right of the field to indicate that there is additional data that is not displayed.
| Element | Truncate and Shrink-to-Fit disabled | Truncate enabled | Shrink-to-Fit enabled | Truncate and Shrink-to-Fit enabled |
|---|---|---|---|---|
| Dynamic document | NA | NA | NA | NA |
| Static document, single-line field | Text runs off right edge. | Text truncates when it reaches the right edge. | Text shrinks to the minimum point size, then runs off right edge. | Text shrinks to the minimum point size, then truncates when it reaches the right edge. |
| Static document, multi-line field OR Mergable text overlay field |
Text wraps in field and runs off bottom edge. | Text truncates when it reaches the right edge of the last line. | Text shrinks to the minimum point size, then wraps in field and runs off bottom edge. | Text shrinks to the minimum point size, then truncates when it reaches the right edge of the last line. |
When both Shrink-to-Fit and Truncate are enabled, the Shrink-to-Fit guidelines are enforced, followed by the Truncate guidelines.
Blank Datapoints
The IntelleDoc Viewer Control supports the use of blank datapoints in a document that are intended for completion later. For example, a notary datapoint may be left blank for later completion at another location. There may also be instances when the datapoint information is not know at the time that the document is rendered.
A blank field refers to a data/fill-in datapoint that is rendered on a dynamic document as a blank fill-in field. To designate a datapoint as a blank field, its value must be set to an empty string and its EmptyValue property must be set to blankField.
A blankable datapoint refers to a data/fill-in datapoint whose value may be empty without triggering the “form must be completed” margin message when EnableBlankFields is true.
Structural datapoints are not allowed to be blank, as they are required to render the document. The only datapoints that may be blank are:
- data_required
- data_conditional
- optional
When blank fields are enabled, a non-zero blank field width allows space representing the blank datapoint to be rendered in the document. When a blank field width of zero is used, no space for the datapoint is rendered in the document. Blank fields are enabled with the BlankFields property.
The presentation of blank datapoints is managed in several locations, with an order of precedence determining if a blank datapoint is expressed in the document as a blank space.
| Location | Precedence (1 is highest) | Description |
|---|---|---|
| DXL file | 1 | emptyvalue attribute within the datavalue element. |
| TXL file | 1 | emptyvalue attribute within a leaf node. |
| FXL file | 2 | Cannot be modified. |
| Compliance Engine preferences | 3 | See below |
| Compliance Engine / IntelleDoc Viewer Control | 4 | See below |
Compliance Engine preferences using csi.Engine.Properties.Preferences class:
using csi.Engine.Properties;
…
Preferences prefs = new Preferences( csiLicenseKey );
prefs.FieldPrefs.EnableBlankFields = true;
prefs.FieldPrefs.BlankHighlight = DataFieldPreferences.BlankHighlightType.gray30;
// Not required, but helps readability of rendered document.
prefs.FieldPrefs.RenderForDataCollection = true;
…
Compliance Engine / IntelleDoc Viewer Control using BlankFields and BlankShading properties:
csi.Controls.EDocView viewer = new csi.Controls.EDocView();
…
viewer.BlankFields = true;
viewer.BlankFieldsShading = BlankFieldsShadingType.Underline;
…
The background color of blank datapoints is managed with the BlankFieldsShading property.
EmptyValue Default
If EmptyValue is not set explicitly for a given data value (such as a DataValue object or DXL file), a default value is used.
The default EmptyValue value may be set in the IntelleDoc Viewer Control or as an appSetting in the application configuration file:
viewer.EmptyDataValueDefault = csi.Utility.Datapoints.DataValue.EmptyValueType.blankField;
or
<appSettings>
...
<add key="EmptyDataValueDefault" value="blankField"/>
</appSettings>
Application preferences take precedence over the configuration file setting. If neither is defined, the hard-coded default of ignoreValue is used.
To be backwards compatible with releases prior to February 2009, set EmptyDataValueDefault to blankField.
Specifying Which Fields Render as Blank
Blank fields must be enabled in order for blank fields to be rendered.
File Attributes and Class Properties
A datapoint is designated as a blank field by setting its value to an empty string and setting its DXL/TXL emptyvalue attribute to blankField or by setting its EmptyValue object property to blankField.
BlankWidth / blankwidth
The BlankWidth property of the DataValue class (or blankwidth attribute in DXL or TXL files) indicates the character width of a blank field.
If not set explicitly, a default value is used. The default for a specific datapoint may come from the datapoint dictionary of the FXL file being evaluated, or, if it is not provide there, the Compliance Engine default of 10 is used.
Valid values include integers with a value of zero or greater. An empty data value with a blank width of zero is not rendered and will therefore not appear on the rendered document.
This property is ignored if the data value is not empty, or it is not designated as a blank field, or if blank fields are turned off.
EmptyValue / emptyvalue
The EmptyValue property of the DataValue class (or emptyvalue attribute in DXL or TXL files) indicates how an empty data value is treated when a document is rendered. Possible values include:
| blankField | Indicates that, when blank fields are turned on, an empty value is rendered as a blank field according to the blankwidth value. When blank fields are turned off, an empty value is treated as an empty string. |
| emptyString | Indicates that an empty value is treated as an empty string. This allows an empty value to be treated as an empty string, not a blank field. Datapoints with an emptyString value are generally not rendered, and therefore have limited utility. |
| ignoreValue | Indicates that an empty value is ignored and treated as if no value was supplied for the datapoint. |
If not set explicitly, a default value is used, which may vary depending upon the consuming application. The default may be set in the application preferences (FieldPrefs.EmptyDataValueDefault) or as an appSetting in the application configuration file. For example:
<appSettings>
...
<add key="EmptyDataValueDefault" value="ignoreValue"/>
</appSettings>
Application preferences takes precedence over the configuration file setting. If neither is defined, the hard-coded default of ignoreValue is used.
DataValue Class
A DataValue object (csi.Utility.Datapoints.DataValue or csi.Engine.Containers.DataValue) can be used with the IntelleDoc Viewer Control or Compliance Engine. For the IntelleDoc Viewer Control, use the SetData() or UpdateData() methods. For the Compliance Engine, use the csi.Engine.Containers.DataValueList object.
Sample
In the following sample data value set, the form will render as follows (assuming that blank fields are enabled):
dp_01 will render as a blank field with a width of 10 characters.
dp_02 will not render because blankwidth is zero.
dp_03 will not render because emptyvalue is emptyString. If an empty string is not a valid value for the datapoint, an invalid value error is generated.
dp_04 will render as a “Apollo”, blankwidth and emptyvalue are ignored.
using csi.Engine.Containers;
…
DataValue dataValue01 = new DataValue( "dp_01", "" );
DataValue dataValue02 = new DataValue( "dp_02", "" );
DataValue dataValue03 = new DataValue( "dp_03", "" );
DataValue dataValue04 = new DataValue( "dp_04", "Apollo" );
…
DataValue01.BlankWidth = 10;
DataValue01.EmptyValue = DataValue.EmptyValueType.blankField;
DataValue02.BlankWidth = 0;
DataValue02.EmptyValue = DataValue.EmptyValueType.blankField;
DataValue03.BlankWidth = 10;
DataValue03.EmptyValue = DataValue.EmptyValueType.emptyString;
DataValue04.BlankWidth = 10;
DataValue04.EmptyValue = DataValue.EmptyValueType.blankField;
…
DXL Files
DXL files may be used with the IntelleDoc Viewer, Compliance Engine, and SOAP interfaces. In the IntelleDoc Viewer, use the SetData() or UpdateData() methods. In the Compliance Engine, use the csi.Engine.Containers.DataValueList and DataValue objects.
Sample
In the following sample data value set, the form will render as follows (assuming that blank fields are enabled):
- dp_01 will render as a blank field with a width of 10 characters.
- dp_02 will not render because blankwidth is zero.
- dp_03 will not render because emptyvalue is emptyString.
- dp_04 will render as a “Apollo”, blankwidth and emptyvalue are ignored.
<datavalues>
<datavalue name="dp_01" blankwidth="10" emptyvalue="blankField"/>
<datavalue name="dp_02" blankwidth="0" emptyvalue="blankField" />
<datavalue name="dp_03" blankwidth="10" emptyvalue="emptyString"/>
<datavalue name="dp_04" blankwidth="10" emptyvalue="blankField">Apollo</datavalue>
</datavalues>
TXL Files
TXL files may be used with the SOAP interfaces and with the Transaction Server.
A feature that is important in some implementations involves setting the emptyvalue attribute to “ignoreValue”. This allows a TXL file to be generated (i.e., via XSLT) that contains a number of empty values, and those empty values will be ignored.
Sample
In the following sample data set, the middle name node will cause a blank field to be generated (assuming blank fields are enabled), and the name suffix node will be ignored regardless of whether blank fields are enabled.
<TransactionValues>
<Entities>
<Entity id="Borrower_1">
<Roles>
<Role>Borrower</Role>
</Roles>
<Name>
<First>Will</First>
<Middle blankwidth="10" emptyvalue="blankField"></Middle>
<Last>Badger</Last>
<Suffix emptyvalue="ignoreValue"></Suffix>
</Name>
</Entity>
</Entities>
</TransactionValues>
Overlay Tab Order
Assigning an overlay field the tab order of 0 (zero) allows it to supersede the existing tab order on a document page and be recognized as the first data field on the page. If more than one overlay field as a tab order of 0 (zero), then the z-order of the overlay fields determines precedence.
Orphan and Widow Control
The IntelleDoc Viewer Control automatically manages orphan and widow lines in dynamic documents.
An orphan is a single line of text beginning a new paragraph that appears at the bottom of a page. A widow is a single line of text ending a paragraph that is carried over to the top of the next page.
If a paragraph breaks across a page boundary so that an orphan or widow would result:
the orphan line is moved to the next page
additional paragraph lines are moved to join the widow line on the next page
Caching FXL Files
A container application can take advantage of automated caching of FXL files. Automated caching changes how the IntelleDoc Viewer Control reacts to changes in the FxlName property.
With automated caching, IntelleDoc Viewer Control ignores the path information in FxlName and checks for the file’s existence in two locations: the local cache path and the remote cache path.
If the file exists in both places and the local version matches the remote version, then the local file is opened.
If the files do not match and the remote file is newer, then the remote file is copied to the local location and the local file is opened.
While the IntelleDoc Viewer Control must check the remote file location each time a document is opened, only the version information at the beginning of the file is read. Network congestions is reduced because files are opened locally after local caches are populated with remote copies. Deployment of document updates is simplified because local clients automatically pick up new document versions from the remote cache location.
Caching implementation:
Set CacheLocalPath to a directory on the client machine. The default value of this property is an empty string. The container application must set the property to an existing path. Be sure that local users have write permissions for the directory.
Set CacheRemotePath to a directory on a remote machine. UNC or drive-letter mappings are both acceptable, but note that IntelleDoc Viewer Control does not create the directory if it does not exist. Be sure that the local users have read permissions for the directory.
Check CacheStatus to ensure that the directory paths are valid.
Add FXL files to the directory specified in CacheRemotePath.
User Interface
The IntelleDoc Viewer Control is presented with a simple user interface and requires a custom application to host it. The IntelleDoc Viewer Control displays a document view with optional scroll bars that are only active when necessary.
When a document is loaded with no missing datapoints, it is displayed in a Document window that offers scroll controls when the size of the window does not accommodate the display of a document’s page.
When a document is loaded with missing datapoints, a table of the missing datapoints is displayed. When no document is loaded, the CSi logo is displayed.
Drag and Drop
A document may be loaded in the IntelleDoc Viewer Control by dragging the FXL file into the Document window. Overlays may be loaded by dragging the OXL file into the Document window. This functionality can be disabled and enabled with the EnableDragDrop property.
Entering Data
Data may be entered into data fields in the Document window when those data fields are designated as read-write.
To enter data, click in a read-write data field. The Datafields window is displayed, where text may be entered or modified. The DELETE key removes text to the right of the cursor. The BACKSPACE key removes text to the left of the cursor.
There are three modes of data entry based on the document type and the setting of OnFormDataEntry.
| Document type | OnFormDataEntry is true | OnFormDataEntry is false |
|---|---|---|
| Custom Document | Data entry is on the form. | Data entry is managed in the Data Entry window. |
| CSi Stock Static Document | Data entry is on the form. | Data entry is managed in the Data Entry window. |
| CSi Stock Dynamic Document | Data entry is managed in the Data Entry window. | Data entry is managed in the Data Entry window. |
The Data Entry window appears differently depending on if it is accessed to enter data on CSi stock dynamic documents or custom documents/CSi stock static documents when OnFormDataEntry is false.
Data entry may be disabled for an entire document. When the DataFieldsEnabled property is set to false, data entry is disabled for the entire document without affecting the enabled/disabled status of image fields in the document.
Datapoint Name Display
When the mouse is positioned over a datapoint in the Document window, the datapoint’s short help description is displayed as a ToolTip. To include the datapoint’s name in the ToolTip text, set the csi.Controls.EDocView.AppendDatapointNameOnToolTip property to true. This option is available in the IntelleDoc Viewer Control and when rendering an FXL file as PDF with AcroFields turned on.
The datapoint information is presented as “Short description [datapoint name].”
Example
Enter the name of your financial institution, which resides on line 1 of the document. [ C_GNL_NAME_INST_InstitutionName1]
Integration
This code adds the IntelleDoc Viewer Control to a .NET form and displays an FXL document.
//instantiate the Viewer Control
csi.Controls.EDocView eDocView = new csi.Controls.EDocView();
//add it to the current .Net form
this.Controls.Add(eDocView);
//specify the fxl document to open
eDocView.FxlFile = @"\csi\AccountInformationSheet.fxl";
//provide a valid CSi IntelleDocs license key
eDocView.LicenseKey = "..."; //provide a valid license key here
//display the document
eDocView.Render();
Controlling Log File Size
CSi IntelleDoc Solutions uses the log4net library to handle logging services. The Compliance Engine configuration file csi.Engine.Configuration.dll.config handles logging directives for nearly all CSi IntelleDoc Solutions API assemblies.
By Log Level
The easiest way to reduce log file size is to set the log level to WARN or ERROR, thus suppressing all DEBUG and INFO level messages. For example:
...
<root>
<level value="WARN" />
<appender-ref ref="RollingLogFileAppender" />
</root>
...
By Specifying Assemblies
The logging level for specific assemblies can be set as well. For example, the following configuration logs warnings and errors for the csi.Transaction.Server assembly, but only errors for everything else:
...
<root>
<level value="ERROR" />
<appender-ref ref="RollingLogFileAppender" />
</root>
<logger name="csi.Transaction.Server">
<level value="WARN" />
</logger>
...
By Maximum File Size
Another way to limit the size of the log file is to designate a maximum size. In the following example, the file will roll once it reaches 1000 KB and up to 10 old files will be kept.
...
<appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
<file value="${APPDATA}\CSi IntelleDoc Solutions Software\IntelleDoc Visualizer\engine.log" />
<appendToFile value="true" />
<rollingStyle value="Size" />
<maxSizeRollBackups value="10" />
<maximumFileSize value="1000KB" />
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
</layout>
</appender>
...
By Date
Log files can be rolled by date as well. Here, the file will roll every day.
...
<appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
<file value="${APPDATA}\CSi IntelleDoc Solutions Software\IntelleDoc Visualizer\engine.log" />
<appendToFile value="true" />
<rollingStyle value="Date" />
<datePattern value="yyyyMMdd" /> <!-- roll every day -->
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
</layout>
</appender>
...
Other configuration options are available. Detailed information can be found at http://logging.apache.org/log4net/release/manual/configuration.html.
Dependencies and Technology Requirements
| Technology | Workstation Applications: | Server Components: | Web Server |
|---|---|---|---|
| Custom Document Editor IntelleDoc Viewer IntelleDoc Advisor IntelleDoc Visualizer |
Transaction Manager Transaction Runner Transaction Server Compliance Engine |
Components: Compliance Service |
|
| Processor | 1.8 GHz Intel Core 2 Duo equivalent or better. | 2.0 GHz Intel Core 2 Duo equivalent or better. | 2.0 GHz Intel Core 2 Duo equivalent or better. |
| RAM | 1 GB (minimum). 2 GB (minimum) for Windows 7. |
2 GB (minimum). | 2 GB (minimum). |
| Hard Drive | 100 MB free space or more. | 100 MB free or more for software. | 10 MB free or more for software. Up to 1 GB free space for document library. |
| LAN | TCP/IP 100 Mbps or better. Applicable only when the documents being read/written are stored on the network. |
TCP/IP 100 Mbps or better. | TCP/IP 100 Mbps or better. |
| Internet or WAN | NA | 2.4 Mbps or better. Applicable only when components or document library are accessed via internet or WAN. |
2.4 Mbps or better. |
| Operating Systems | Windows Server 2003 - all editions, latest service pack Windows Server 2008 - all editions, latest service pack Windows 7 - latest service pack Windows 8 - latest service pack |
Windows Server 2003 - all editions, latest service pack Windows Server 2008 - all editions, latest service pack Windows 7 - latest service pack Windows 8 - latest service pack |
Windows Server 2003 - all editions, latest service pack Windows Server 2008 - all editions, latest service pack Windows 7 - latest service pack Windows 8 - latest service pack |
| .NET Runtime | 4.6.2. | 4.6.2. | 4.6.2. |
| Internet Information Services (IIS) | NA | NA | V6.0 or better. |
| Fonts | Times New Roman Courier New |
Times New Roman Courier New |
Times New Roman Courier New |
Default Values
The default values for properties associated with the IntelleDoc Viewer Control API are listed below.
| Property | Default Value |
|---|---|
| AllowDataEntry | false |
| AutoRender | true |
| BlankFields | BlankFieldsOff |
| CacheLocalPath | ”” |
| CacheRemotePath | ”” |
| DataFieldHighlightColor | Aqua |
| DataFieldReadOnlyHightlightColor | OrangeRed |
| ImageFieldsEnabled | false |
| ImageFieldHighlightColor | Yellow |
| InvalidDataFieldHighlightColor | Red |
| NullDataFieldHighlightColor | LightGreen |
| NullDataFieldReadOnlyHighlightColor | Green |
| Page | 1 |
| ShrinkToFitSize | 8.0 |
| Truncate | Shrink |
| WatermarkFont | Default font of .NET framework for control |
| Zoom | 100 |
IntelleDoc Viewer Control Events
The IntelleDoc Viewer Control sends events indicating the status of document data fields and pages as well as document rendering, error notification, and logging activities.
DataFieldChanged Event
This event is thrown when a data value changes. It returns the initial value and the new value.
public event DataFieldChangedHandler DataFieldChanged;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DataFieldChanged event occurs
eDocView.DataFieldChanged += new csi.Controls.EDocViewEvents.DataFieldChangedHandler(eDocView_DataFieldChanged);
//Perform actions within local method when the DataFieldChanged event occurs
private void eDocView_DataFieldChanged(object sender, csi.Controls.EDocViewEvents.DataFieldChangedEventArgs e)
{
//extract information from the event arguments object
string dataPointName = e.datapointName;
string initialValue = e.initialValue;
string newValue = e.newValue;
}
DataFieldGotFocus Event
This event is thrown when the data field gets focus for editing.
public event DataFieldGotFocusHandler DataFieldGotFocus;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DataFieldGotFocus event occurs
eDocView.DataFieldGotFocus += new csi.Controls.EDocViewEvents.DataFieldGotFocusHandler(eDocView\_DataFieldGotFocusHandler);
//Perform actions in local application when the DataFieldGotFocus event occurs
private void eDocView\_DataFieldGotFocusHandler(object sender, csi.Controls.EDocViewEvents.DataFieldEventArgs e)
{
//extract information from the event arguments object
string datapointName = e.datapointName;
string datapointValue = e.datapointValue;
}
DataFieldInvalid Event
This event is thrown if the data value entered is not valid.
public event DataFieldInvalidHandler DataFieldInvalid;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DataFieldInvalid event occurs
eDocView.DataFieldInvalid += new csi.Controls.EDocViewEvents.DataFieldInvalidHandler(eDocView\_DataFieldInvalidHandler);
//Perform actions in local application when the DataFieldInvalid event occurs
private void eDocView\_DataFieldInvalidHandler(object sender, csi.Controls.EDocViewEvents.DataFieldEventArgs e)
{
//extract information from the event arguments object
string datapointName = e.datapointName;
string datapointValue = e.datapointValue;
}
DataFieldLostFocus Event
This event is thrown when the data field loses focus.
public event DataFieldLostFocusHandler DataFieldLostFocus;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DataFieldLostFocus event occurs
eDocView.DataFieldLostFocus += new csi.Controls.EDocViewEvents.DataFieldLostFocusHandler(eDocView\_DataFieldLostFocusHandler);
//Perform actions in local application when the DataFieldLostFocus event occurs
private void eDocView\_DataFieldLostFocusHandler(object sender, csi.Controls.EDocViewEvents.DataFieldEventArgs e)
{
//extract information from the event arguments object
string datapointName = e.datapointName;
string datapointValue = e.datapointValue;
}
DatafieldWarning Event
public event DataFieldWarningHandler DatafieldWarning;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DatafieldWarning event occurs
eDocView.DatafieldWarning += new csi.Controls.EDocViewEvents.DataFieldWarningHandler(eDocView_DataFieldWarningHandler);
//Perform actions in local application when the DatafieldWarning event occurs
private void eDocView_DataFieldWarningHandler(object sender, csi.Controls.EDocViewEvents.DataFieldWarningEventArgs e)
{
//extract information from the event arguments object
string dataPointName = e.datapointName;
string dataPointValue = e.data;
string dataPointWarningMessage = e.warning;
}
DocumentRequiresRendering Event
This event is thrown when AutoRender is set to false and the document requires rendering.
public event EventHandler DocumentRequiresRendering;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView DocumentRequiresRendering event occurs
eDocView.DocumentRequiresRendering +=new EventHandler(eDocView\_DocumentRequiresRendering);
}
//Perform actions in local application when the DocumentRequiresRendering event occurs
private void eDocView_DocumentRequiresRendering(object sender, System.EventArgs e)
{
//perform some action...
}
ErrorNotification Event
This event is thrown on any error.
public event ErrorNotificationHandler ErrorNotification;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView ErrorNotification event occurs
eDocView.ErrorNotification += new csi.Controls.EDocViewEvents.ErrorNotificationHandler(this.eDocView_ErrorNotification);
}
//Perform actions in local application when the ErrorNotification event occurs
private void eDocView_ErrorNotification(object sender, csi.Controls.EDocViewEvents.NotificationEventArgs e)
{
//extract information from the event arguments object
string errorMessage = e.message;
}
ImageFieldClick Event
This event is thrown when the user clicks and releases the left mouse button on any visible, unlocked image field when ImageFieldsEnabled is set to true. The arguments for this event are passed as an ImageFieldEventArgs object. ImageFieldEventArgs contains the datapoint name for the image field upon which the user clicked.
public event ImageFieldClickHandler ImageFieldClick;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView ImageFieldClick event occurs
eDocView.ImageFieldClick += new csi.Controls.EDocViewEvents.ImageFieldClickHandler(eDocView_ImageFieldClickHandler);
//Perform actions in local application when the ImageFieldClick event occurs
private void eDocView_ImageFieldClickHandler(object sender, csi.Controls.EDocViewEvents.ImageFieldEventArgs e)
{
//extract information from the event arguments object
string datapointName = e.datapointName;
}
Logging Event
This event is thrown for all logging activities. The logging activities must be no greater than the logging level set with LoggingLevel.
public event LoggingHandler Logging;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView Logging event occurs
eDocView.Logging += new csi.Controls.EDocViewEvents.LoggingHandler(eDocView_LoggingHandler);
}
//Perform actions in local application when the Logging event occurs
private void eDocView_LoggingHandler(object sender, csi.Controls.EDocViewEvents.LoggingEventArgs e)
{
//extract information from the event arguments object
string loggingMessage = e.message;
EDocViewEnums.LoggingLevelType level = e.level;
}
PageGotFocus Event
This event is thrown when a new page is displayed.
public event PageGotFocusHandler PageGotFocus;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView PageGotFocus event occurs
eDocView.PageGotFocus += new csi.Controls.EDocViewEvents.PageGotFocusHandler(eDocView_PageGotFocusHandler);
}
//Perform actions in local application when the PageGotFocus event occurs
private void eDocView_PageGotFocusHandler(object sender, csi.Controls.EDocViewEvents.PageEventArgs e)
{
//extract information from the event arguments object
int pageNumber = e.page;
}
PageLostFocus Event
This event is thrown when a page is changed.
public event PageLostFocusHandler PageLostFocus;
Parameters
n/a
Return Value
n/a
Example
//specify a local method to call when the eDocView PageLostFocus event occurs
eDocView.PageLostFocus += new csi.Controls.EDocViewEvents.PageLostFocusHandler(eDocView_PageLostFocusHandler);
}
//Perform actions in local application when the PageLostFocus event occurs
private void eDocView_PageLostFocusHandler(object sender, csi.Controls.EDocViewEvents.PageEventArgs e)
{
//extract information from the event arguments object*
int pageNumber = e.page;
}
Appendix A — Migration from eDoc Utilities OCX to IntelleDoc Viewer Control
| eDoc Utilities OCX | IntelleDoc Viewer Control |
|---|---|
| n/a | IsFxlFileLicensed() method |
| n/a | PageLostFocus event |
| n/a | Error event |
| n/a | DataFieldWarning event |
| n/a | DocumentRequiresRendering event |
| n/a | DocumentRendered |
| AboutBox method | Version property |
| AllFieldsReadWrite property | AllowDataEntry property |
| AllowScreenUpdates property | Render method AutoRender property Status property |
| AllPrint method | RetrievePageImage() method IntelleDoc Viewer Control does not print directly to a device. It returns an image of the document, which can be manipulated and sent to output devices. |
| Blank fields | Blank Field functionality is supported in the CSi Compliance Engine via the Properties object and through the IntelleDoc Viewer Control for embedding into a container application. In addition, the need for the BEL file is removed as the metadata is stored in the individual form files (FXL). |
| BlankFieldMode property | BlankFields property |
| BlankFieldShading property | n/a |
| BuildFormList method | n/a |
| Caching | Caching functionality is supported in the CSi Compliance Engine via the Properties object and through the IntelleDoc Viewer Control for embedding into a container application. A local and remote cache path are specified with the CacheLocalPath and CacheRemotePath, respectively. |
| Change event | DataFieldChanged event |
| ClearData method | n/a |
| CompareForms method | n/a |
| CreateFAOfromWMF method | Create() method |
| DataCoding property | n/a |
| DataFieldBackColor property | n/a |
| DataFieldForeColor property | n/a |
| DataFieldROBackColor property | DataFieldReadOnlyBackgroundColor property |
| DataFieldROForeColor property | DataFieldReadOnlyForegroundColor property |
| DataFieldRWBackColor property | DataFieldBackgroundColor property |
| DataFieldRWForeColor property | DataFieldForegroundColor property |
| DataFontMinimumPointSize property | ShrinkToFitSize property |
| DataOverflowAction property | Truncate property |
| DatFileName property | n/a |
| Debug | Text property Retrieves the text of the document without layout information. |
| DisplayWarnings property | DisplayMessages property |
| EmptyFieldBackColor property | NullDataFieldBackgroundColor property |
| EmptyFieldForeColor property | n/a |
| EmptyFieldROBackColor property | NullDataFieldReadOnlyBackgroundColor property |
| EmptyFieldRWBackColor property | n/a |
| EnabledWarnings property | NA. Always enabled. |
| ExportTIFF method | RetrievePageImage() method |
| FieldGotFocus event | DataFieldGotFocus event |
| FieldLostFocus event | DataFieldLostFocus event |
| FormFileName property | FxlFile property |
| FormName method | n/a |
| FormType method | n/a |
| FormVersionNumber method | n/a |
| GetAllData method | GetDataValue() method |
| GetChangedData method | GetDataValue() method |
| GetCurrentFields method | GetDataFields() method |
| GetData method | Deprecated |
| GetFields method | GetDataFields() method |
| Height property (inherited) | Height (inherited) |
| InvalidData event | DataFieldInvalid event |
| InvalidFieldBackColor property | InvalidDataFieldBackgroundColor property |
| InvalidFieldForeColor property | InvalidDataFieldForegroundColor property |
| IsValidValue method | IsDataValueValid() method |
| Left property (inherited) | X (inherited) |
| LocalCachePath property | CacheLocalPath property |
| Mode property | Overlay mode is replaced by the CSi IntelleDoc Solutions™ Custom Document Editor. |
| NumPages method | Pages() method |
| OverlayFieldBackColor property | n/a |
| OverlayFieldForeColor property | n/a |
| OverlayFileName property | OxlFile property |
| OverlayNameList property | Not Applicable. This functionality has been replaced by the CSi IntelleDoc Solutions™ Custom Document Editor. |
| PageChange event | PageGotFocus event |
| PageNum property | Page property |
| PageSize method | Deprecated |
| PrintOrientation property | n/a |
| PrintOrientationCanChange property (read-only) | n/a |
| PrintPaperSize property | n/a |
| PrintPaperSizeCanChange property (read-only) | n/a |
| RemoteCachePath property | CacheRemotePath property |
| Reset method | Reset |
| ResetData method | n/a |
| RopCode property | Deprecated |
| SaveData method | n/a |
| SaveOverlay method | Not Applicable. This functionality has been replaced by the CSi IntelleDoc Solutions™ Custom Document Editor. |
| SelPrint method | RetrievePageImage() method IntelleDoc Viewer Control does not print directly to a device. It returns an image of the document, which can be manipulated and sent to output devices. |
| SetData method | SetDataValues() method |
| SetFieldFocus method | SetDataFieldFocus() method |
| SetSpecialValue method | LicenseKey property IsValidLicenseKey() |
| ShowBlankFields property | Deprecated |
| ShowSampleImage property | NA. See watermark properties. |
| ShowThumbnail property | RetrievePageImage method |
| StrictDataEntryLocking property | n/a |
| Top Property (inherited) | Y (inherited) |
| TransferArrayColDelimiters property | n/a |
| TransferArrayRowDelimiters property | n/a |
| UseAutomatedCache property | CacheStatus property |
| ValidationStatus property | n/a |
| VerifyCacheIntegrity property | n/a |
| Visible property (inherited) | Visible (inherited) |
| WatermarkColor property | WatermarkColor property |
| WatermarkPlacement property | WatermarkPlacement property |
| WatermarkSize property | WatermarkSize property |
| WatermarkText property | WatermarkText property |
| WatermarkWashout property | WatermarkWashout property |
| Width property (inherited) | Width (inherited) |
| ZoomHeight method | Zoom property |
| ZoomPage method | Zoom property |
| ZoomPercent property | Zoom property |
| ZoomWidth method | Zoom property |
Appendix B — OXL Structure and Schema
Structure
<formoverlay formfile="form">
<object type="mergabletext">
<objectname>datapoint name</objectname>
<description>description</description>
<text font-family="" font-size="" fill="" align-horiz="" align-vert="" padding-vert="" padding-horiz=""/>
<rect x="" y="" height="" width="" stroke-width="" stroke="" fill=""/>
<overflow shrink="" truncate="" font-size="" max-chars=""/>
</object>
<object type="statictext">
<text font-family="" font-size="" fill="" align-horiz="" align-vert="" padding-vert="" padding-horiz="">
text
</text>
<rect x="" y="" height="" width="" stroke-width="" stroke="" fill=""/>
</object>
<object type="image">
<objectname>datapoint name</objectname>
<description>description</description>
<rect x="" y="" height="" width="" stroke-width="" stroke="" fill=""/>
<scale shrink="" expand=""/>
<image align-horiz="" align-vert=""/>
</object>
<object type="line">
<line x1="" y1="" x2="" y2="" stroke-width="" stroke=""/>
</object>
<object type="rectangle">
<rect x="" y="" height="" width="" stroke-width="" stroke="" fill=""/>
</object>
<object type="ellipse">
<ellipse x="" y="" height="" width="" stroke-width="" stroke="" fill=""/>
</object>
</formoverlay>
Schema
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- edited with XMLSpy v2005 rel. 3 U (http://www.altova.com) by Keith McCreery (Compliance Systems, Inc.) -->
<!--W3C Schema generated by XMLSpy v2005 rel. 3 U (http://www.altova.com)-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="description">
<xs:annotation>
<xs:documentation>short description of datapoint (valid for MT,I)</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:element>
<xs:element name="ellipse">
<xs:annotation>
<xs:documentation>ellipse object (valid for E)</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="x" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="y" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="width" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="height" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke-width" use="optional" default="0">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke" use="optional" default="#00FFFFFF">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="fill" use="optional" default="">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="formoverlay">
<xs:annotation>
<xs:documentation>top-level element</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element ref="object" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="formfile" type="xs:string" use="optional"/>
</xs:complexType>
</xs:element>
<xs:element name="line">
<xs:annotation>
<xs:documentation>line object (valid for L)</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="x1" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="y1" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="x2" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="y2" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke-width" use="optional" default="0">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke" use="optional" default="#00FFFFFF">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="object">
<xs:annotation>
<xs:documentation>an overlay object. the 'type' attribute determines the type of Overlay Field.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element ref="objectname" minOccurs="0"/>
<xs:element ref="description" minOccurs="0"/>
<xs:element ref="text" minOccurs="0"/>
<xs:element ref="rect" minOccurs="0"/>
<xs:element ref="overflow" minOccurs="0"/>
<xs:element ref="scale" minOccurs="0"/>
<xs:element ref="line" minOccurs="0"/>
<xs:element ref="ellipse" minOccurs="0"/>
<xs:element ref="sample" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="ellipse"/>
<xs:enumeration value="image"/>
<xs:enumeration value="line"/>
<xs:enumeration value="mergabletext"/>
<xs:enumeration value="rectangle"/>
<xs:enumeration value="statictext"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="page" type="xs:integer" use="required"/>
<xs:attribute name="zorder" type="xs:integer" use="optional"/>
<xs:attribute name="taborder" type="xs:integer" use="optional"/>
</xs:complexType>
</xs:element>
<xs:element name="objectname">
<xs:annotation>
<xs:documentation>datapoint name (valid for MT,I)</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:element>
<xs:element name="overflow">
<xs:annotation>
<xs:documentation>shrink-to-fit and truncate options for text (valid for MT)</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="shrink" use="optional" default="false">
<xs:simpleType>
<xs:restriction base="xs:boolean"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="truncate" use="optional" default="false">
<xs:simpleType>
<xs:restriction base="xs:boolean"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="font-size" use="optional" default="6">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="max-chars" use="optional" default="0">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="rect">
<xs:annotation>
<xs:documentation>rectangle object (valid for MT, ST, I, R)</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="x" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="y" use="required">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="height" use="required">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="width" use="required">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke-width" use="optional" default="0">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="stroke" use="optional" default="#00FFFFFF">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="fill" use="optional" default="">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="scale">
<xs:annotation>
<xs:documentation>shrink and expand options for images (valid for I)</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="shrink" use="optional" default="proportional">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="proportional"/>
<xs:enumeration value="fill"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="expand" use="optional" default="none">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="none"/>
<xs:enumeration value="proportional"/>
<xs:enumeration value="fill"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="text">
<xs:annotation>
<xs:documentation>text attributes (valid for MT, ST)</xs:documentation>
</xs:annotation>
<xs:complexType mixed="true">
<xs:attribute name="font-family" use="optional" default="Times New Roman">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="font-size" use="optional" default="10">
<xs:simpleType>
<xs:restriction base="xs:integer"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="fill" use="optional" default="#00FFFFFF">
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="align-horiz" use="optional" default="left">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
<xs:enumeration value="center"/>
<xs:enumeration value="justified"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="format" type="xs:string" use="optional"/>
<xs:attribute name="align-vert" use="optional" default="top">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="padding-horiz" type="xs:integer" use="optional" default="0"/>
<xs:attribute name="padding-vert" type="xs:integer" use="optional" default="0"/>
</xs:complexType>
</xs:element>
<xs:element name="sample">
<xs:annotation>
<xs:documentation>sampe data attribute (valid for MT, I)</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:element>
</xs:schema>
Appendix C — DXL Syntax, Schema, and Datavalue Attributes
DXL Syntax
Optional attributes (locked, alignment, forecolor, backcolor, blankwidth) only apply to visible (fill-in) datapoints.
<datavalues>
<datavalue name="name"
locked="true|false"
alignment="left|right|center|justified"
forecolor="black"
backcolor="white"
blankwidth="10">
*datapoint value*
</datavalue>
*... unbounded number of datavalue elements ...*
</datavalues>
Datavalue Attributes
| name | The name of the datapoint, including a realized suffix for suffixed datapoints. |
|---|---|
| locked | This is a directive to the IntelleDocViewer Control to disallow on-screen editing. |
| alignment | Indicates horizontal alignment of the datavalue text. This attribute is only valid for static forms. The value is not case-sensitive. |
| forecolor | Indicates the foreground or stroke color of the data value text. The value is a .NET color name (White, Black, Red, Green, Blue, Yellow) or it is a color hex code prefixed by “#” (e.g., #FF00EE). The value is not case sensitive. |
| backcolor | Indicates the background color of the fill-in field. The value is a .NET color name (White, Black, Red, Green, Blue, Yellow) or it is a color hex code prefixed by “#” (e.g., #FF00EE). The value is not case sensitive. |
| blankwidth | Indicates the character width of the fill-in field when an empty value or no value is given for the datapoint. This overrides the blank width attribute specified in the datapoint dictionary in the FXL file. The field width is calculated based on the width of a “W” character using the current font and font size. This attribute is ignored when a non-empty value is assigned to the datapoint and when the datapoint is not fill-in. |
DXL Schema
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!--W3C Schema generated by XMLSpy v2005 rel. 3 U(http://www.altova.com)-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="datavalue">
<xs:complexType mixed="true">
<xs:attribute name="name" use="required">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="example_0"/>
<xs:enumeration value="example_1"/>
<xs:enumeration value="example_2"/>
<xs:enumeration value="example_3"/>
<xs:enumeration value="example_4"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="locked" use="optional" default="true">
<xs:simpleType>
<xs:restriction base="xs:boolean"/>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="alignment" use="optional" default="left">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="center"/>
<xs:enumeration value="justified"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="forecolor" use="optional" default="#000000">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="#000000"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="backcolor" use="optional">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="#000000"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="blankwidth" use="optional" default="0">
<xs:simpleType>
<xs:restriction base="xs:integer">
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="datavalues">
<xs:complexType>
<xs:sequence>
<xs:element ref="datavalue" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Glossary of Terms
Administrative
Part of the CSi Data Schema, Administrative is the schema data group that contains institutional and document setup elements for documents generated to contain transaction data. Data elements in this group are generally set up once by an institution for ongoing transactional use.
blank field
A dynamic datapoint approved by CSi to have the data entered manually by the end user after the document is printed.
branch
Within the CSi Data Schema, a branch is a distinct subdivision that organizes related data elements in a logical manner. Branch names comprised of multiple words are presented using the CamelCase naming convention so those words are joined together as a single word with the first letter of each component word capitalized, as in PowerOfAttorney.
Classic eDocs
This product line refers to CSi non-dynamic documents. They use fixed, or static text. The only variable data entered is transaction-specific input in the correct datapoints, which populates the document fields. The static text of these documents does not change based on the transaction parameters.
Collaterals
Part of the CSi Data Schema, Collaterals is the schema data group that contains data elements describing security pledged for a transaction.
COM
An acronym for Component Object Model, a specification developed by Microsoft for building software components that can be assembled into programs or add functionality to existing programs running on Microsoft Windows platforms. COM components can be written in a variety of languages and can be unplugged from a program at runtime without having to recompile the program.
COM+
COM+ is an extension of Component Object Model (COM), Microsoft’s strategic building block approach for developing application programs. COM+ is both an object-oriented programming architecture and a set of operating system services. It adds to COM a new set of system services for application components while they are running, such as notifying them of significant events or ensuring they are authorized to run.
Compliance Engine
A CSi IntelleDoc Solutions™ assembly that evaluates input transaction data and selects appropriate documents or document content based on a given data set, returns error messages if more information is needed, and renders the documents. These documents are rendered on screen as well as output as PDF, printed copy, or image files.
Compliance Logic System or CLS
Compliance Logic System is an application with a wizard-like interface that walks users through a Q&A session to define and assemble regulatory disclosures. It is presented as individual modules under two umbrella groups:
| CLS-Deposit | CLS-Lending |
|---|---|
| CLS-Truth In Savings | CLS-Adjustable Rate Mortgage |
| CLS-Funds Availability | CLS-Home Equity |
| CLS-Electronic Funds Transfer |
An additional module, CLS-Privacy, can be licensed with either the Deposit or Lending group, or it can be purchased separately. It can be licensed to create:
Initial Privacy Disclosures (presented at account opening)
Annual Privacy Disclosures (mailed to an institution’s customers once each year)
Compliance Service
The Compliance Service is a web service that provides access to CSi IntelleDoc Solutions™ functionality through a web service interface.
CSi Classic Solutions
An integrated solution suite of dedicated compliance modules based on CSi static document technology.
CSi eDoc
A CSi electronic document that can be viewed on screen or printed. The CSi eDoc libraries includes lending, deposit, and tax-favored account documents.
CSi IntelleDoc Solutions™
An integrated solution suite of dedicated compliance modules delivered as .NET-managed code. It is dedicated to the production of CSi’s document library in both static and dynamic formats.
Custom Document Editor
An application dedicated to the design of custom documents, either based on existing CSi static IntelleDocs or by creating new documents files from scratch, image files, or PDF files.
Data Schema
The logical and physical definition of a database structure. CSi uses a single data schema for Deposit, IRA, Consumer Lending, and Mortgage transactions. In the CSi Data Schema, XML is used to create a single data set, based on a single standard, to define all transactions across multiple channels of customer contact.
data type
The type of data acceptable as entry for a given datapoint, such as dollar, percentage, alpha, numeric, etc. If the correct data type is not entered, the eDoc cannot render or renders with an error message. Data type can also be used with logic triggers to call for additional information before the eDoc is rendered.
data_conditional
A datapoint usage type designating a datapoint that may be required, depending on the values supplied for one or more other datapoints. If the datapoint is required and not supplied, the Compliance Engine displays and prints the document with the warning message Form must be completed at the top.
data_required
A datapoint usage type designating a datapoint as required in order for the document to be legally compliant. If such a datapoint is not supplied, the Compliance Engine displays and prints the document with the warning message Form must be completed at the top.
datafield
The location on an eDoc form for the variable data associated with a datapoint. There can be many datafields associated with a single datapoint.
datapoint
A CSi variable data placeholder used to populate a document with transaction-specific information. Datapoints may have an associated data type for data validation. Datapoint names are not case sensitive.
datapoint usage type
The use of dynamic datapoints is indicated by one of the following:
- structural_required
- structural_conditional
- structural_optional
- data_required
- data_conditional and
- optional.
A structural_required or structural_conditional datapoint is generally part of a logic question that drives document creation.
Document Selection Logic or DSL
A software tool that selects the documents required for a given financial transaction type and produces a list of documents that CSi warrants as accurate. The list is the minimum set of documents necessary, including the quantity of each document, for a compliant transaction based on state and federal laws as well as industry standards. DSL products include:
- DSL for Classic Lending
- DSL for Dynamic Lending
- DSL for Dynamic Deposits and TFA
DSL
Part of the CSi Data Schema, DSL is the schema data group that contains data used to select documents appropriate to a given transaction. DSL stands for document selection logic and it is CSi’s Document Selection Logic product that produces the warranted list of necessary documents as a DSL summary session.
DXL
An eDoc data file. An XML file that contains data values along with the associated layout directives for values that are displayed. It is used to aid processing of FXL files. It is equivalent to a DAT file.
Dynamic eDoc
A CSi document that requires variable data to define the usage of the form, to render it with proper language, and to populate the variable fields.
Dynamic eDocs
This product line refers to a library of documents consisting of dynamic and some static documents. The documents are assembled based on customer and transaction-specific data creating a customized document with fully integrated compliance logic and knowledge.
eDoc Advisor
A CSi application used to map, view, and test a dynamic eDoc using a DAT session and applicable FAO files.
eDoc Library
CSi’s collection of eDocs, categorized by Lending, Deposit, and Compliance Logic System.
| Mortgage | Consumer/ Commercial Lending | Deposit | Compliance Logic System | Tax Favored Accounts |
|---|---|---|---|---|
| Conventional Lending | Consumer | Savings | HELOC Disclosure | IRA/ESA |
| Government Lending | Real Estate | CDs | HELOC Agreement | Traditional/SEP IRA |
| Home Equity Lending | Construction | Money Market | ARM Early Disclosure | Roth IRA |
| Construction Lending | Credit Line | Checking | Funds Availability | Simple IRA |
| Private Investor Documents | Home Equity | NOW | Truth in Savings | Coverdell ESA |
| Broker Documents | Commercial | Safe Deposit Box | Electronic Funds Transfer | Health Savings Accounts (HSA) |
| State Disclosures | Agricultural | Privacy |
eDoc Utilities
A CSi software suite preceding CSi IntelleDoc Solutions™. It was dedicated to the production of CSi’s document library in both static and dynamic formats. It was written in C++ and delivered as OCX and COM+ objects.
Entities
Part of the CSi Data Schema, Entities is the schema data group that contains any real business, individual, association, trust, or governmental body related to a transaction.
FAO
The file extension used by eDoc files. These files store the form with its datapoint dictionary, validation, and help information. It is deprecated in the CSi IntelleDoc Solutions™ and replaced with FXL.
fat-client
In client/server architecture, a fat-client machine performs most or all of the processing, with little or none performed by the server. The client handles presentation and functions, and the server manages data and access to it.
Financial Calculator Logic (FCL)
A CSi component that performs financial calculations of annual percentage rate (APR) and annual percentage yield (APY).
fixed text overlay
An overlay field that holds static text labels. They may also hold variable datapoints inserted as part of the field text data.
FXL
An eDoc file. It is an XML file that contains coded file information as well as metadata about its form and contents. It is equivalent to an FAO file.
FxlCreate
A utility used to create FXL files. FxlCreate is used for documents in other source formats such as graphic image files. Many banks use WMF documents, for example.
FxlModify
A utility and .NET class object that modifies custom FXL files without using Custom Document Editor. A license key determines what documents customers can modify. Customers cannot modify CSI stock documents.
FxlRender
A utility used to render FXL files as printed output or as a PDF. FxlRender creates these files without using Compliance Engine.
hexadecimal
System using 16 rather than 10 as the base for representing numbers. The hexadecimal system uses the digits 0 through 9 and the letters A through F to represent the decimal numbers 0 through 15. For example, 1 is represented as 01 and 10 is represented as 0A or A. To prevent confusion with decimal numbers, hexadecimal numbers are usually followed by H or preceded by &, \$, #, or 0x.
ID
Part of the CSi data schema, an ID is the unique identifier used to establish the relationship of an entity with other transaction components.
image overlay field
An overlay field that holds an image specified as the datapoint for the field.
in-play datapoints
A datapoint that is required in order for a document to be considered complete. As data is supplied to a document to satisfy initial datapoints and its form logic is executed, additional datapoints may be required for the form to render or be considered complete. The in-play datapoints for a given document may thus evolve as the document is being completed.
IntelleDoc
A dynamic document supporting financial transactions that is assembled based on transaction-specific information.
IntelleDoc Advisor
IntelleDoc Advisor is an application used to modify data values in order to assess changes in document rendering. It supports .NET CSi IntelleDoc Solutions file formats.
IntelleDoc Visualizer
IntelleDoc Visualizer is an application used to validate the content of CSi TXL data files structured on the CSi Data Schema. It allows transaction data in a TXL file to be checked against a schema file, flagging data that does not comply with parameters of the schema so that it may be corrected.
Job Ticket
An object that packages all information related to the document request for the Transaction Manager, including the transaction data, preferences information defining document setup, and custom overlay information.
leaf node
Within the CSi Data Schema, a leaf node is a termination in the schema branching structure and contains no additional branches. Leaf node names comprised of multiple words are presented using the CamelCase naming convention so those words are joined together as a single word with the first letter of each component word capitalized, as in NumberOfRequiredSigners.
mergable text overlay
An overlay field that can hold any single datapoint.
MXL
A file format used by script files. MXL uses XML to store script information that manipulates and maps datapoint values before applying them to a customized form. These scripts are created or modified in Custom Document Editor. This scripting information is executed by the host.
natural person
A natural person is a human being, as opposed to a corporation, partnership, organization, trust, partnership, etc., which are also referred to as persons under state and federal law.
OCX
The ActiveX control file object representing the eDoc Utilities implementation in a platform system on a workstation via a container application.
optional
A datapoint usage type that designates a datapoint that is not required. If a value is supplied, the Compliance Engine includes this value in the document. If no value is supplied, the Compliance Engine displays and prints the document with no warning or error messages.
overlay field
A field used to add additional elements to an existing CSi eDoc or to a custom document.
OXL
The file format used by overlay files, which store overlay information for the document as XML.
An acronym for Portable Document Format, a file format developed by Adobe Systems that captures the text, graphics, and formatting of a file so that it may be viewed and printed correctly without the original authoring software. Adobe Reader is distributed by Adobe Systems as freeware to display or print PDF files.
pel
A pel is a unit of measure that CSi defines as 1,000th of an inch.
primary overlay
An overlay field used as the standard for controlling the properties and layout of other overlay fields.
realized datapoint name
A realized datapoint name is one that has been populated with suffix data values (for datapoints with suffixes), as opposed to the generic “.i” suffix placeholder value.
Regulation CC
Regulation CC is the Funds Availability regulation. It governs the disclosure of an institution’s funds availability policy and the establishment of timetables for the processing of deposits to accounts subject to the regulation.
Regulation DD
Regulation DD is the Truth in Savings regulation. It governs the disclosure of deposit account
Regulatory
Part of the CSi Data Schema, Regulatory is the schema data group that contains data related to the fulfillment of state and federal disclosures and requirements.
Roles
Part of the CSi Data Schema, Roles refer to the function that the data element serves in the transaction.
secondary overlay
An overlay field that derives its properties and layout on the document from a primary overlay.
SOAP
An acronym for Simple Object Access Protocol, SOAP is a protocol for exchanging XML-based messages over computer networks, normally using HTTP/HTTPS.
Static 2
Nickname for the Classic documents used in the dynamic product line that have dynamic datapoints rather than Classic datapoints embedded in the document. Examples are state titling documents and UCC documents.
Static eDoc
A CSi document with fixed text.
structural_conditional
A datapoint usage type designating a datapoint as potentially required, depending on the values supplied for one or more other datapoints. If the datapoint is required and not supplied, the Compliance Engine displays a black screen with an error message.
structural_optional
A datapoint usage type designating a datapoint that is not required for a document to be considered complete, but affecting the structure of the document if values are supplied to it.
structural_required
A datapoint usage type designating a datapoint as required to render the document. If such a datapoint is not supplied, the Compliance Engine displays a black screen with an error message.
suffixing
A datapoint style that allows a single datapoint name to reference multiple values. It continues to render as long as data is sent to it. For example, if eight signatures are required on a document, a suffixed signature datapoint renders eight times so that all eight signers are listed on the document.
tab order
The order in which datafields are accessed when pressing the TAB key.
TermsAndProvisions
Part of the CSi Data Schema, TermsAndProvisions is the schema data group that contains the data describing the institution’s product and policies regarding the transaction.
TFA
Tax Favored Accounts. CSi’s TFA library includes documents for both IRA/ESA and HSA, which can be licensed separately.
thin-client
A software layer of a small client for a centrally managed network terminal. A thin client allows the user access to server-hosted applications and data.
Transaction Manager
The Transaction Manager is a component within the Transaction Manager Suite. It assigns job IDs to Job Tickets brought by the Transaction Runner and selects a server URI for job processing based on a load-balancing algorithm.
Transaction Runner
The Transaction Runner is a transaction support system and serves as a means for managing document processing requests from client applications with CSi IntelleDoc Solutions™ technology. The Transaction Runner receives data for a given transaction from client applications, then processes the data into document selection and document rendering for those client applications.
Transaction Server
The Transaction Server is a .NET assembly that processes Job Ticket data into document selection and document rendering for the client applications. It translates input data into multiple Compliance Engine transactions, if necessary, and executes the Compliance Engine. The Transaction Server also reports job status and performance information to the Transaction Manager.
TXL
An XML data file based on the CSi Data Schema containing all of the transaction data necessary to document a given transaction.
Underwriting
Part of the CSi Data Schema, Underwriting is the schema data group that contains decisioning information used to open an account or extend credit. In the case of Deposit and IRA business lines, underwriting includes data elements used to determine account eligibility. In the case of Consumer Lending, Commercial Lending, and Mortgage business lines, underwriting includes data elements used to evaluate risk and determine credit eligibility.
unrealized datapoint
An unrealized datapoint is one that is not yet populated with suffix data values (for datapoints with suffixes), and uses the generic “.i” suffix placeholder value.
VFI
File format output as part of CSi’s JetForm process for creating static documents. It contains data field names, locations, and other relevant information for a single document page.
WSDL
An acronym for Web Services Description Language, an XML-based language that provides a model with which to describe web services.
XHTML
Extensible HyperText Markup Language. This is a reformulation of HTML to conform with the rules of XML.
XML
An acronym for eXtensible Markup Language, a subset of Standard Generalized Markup Language (SGML), XML is a meta-language that allows customized structures and syntaxes of individual markup languages that manage information.
z-order
The order in which objects are drawn on top of one another onscreen to simulate depth (the third dimension) in conjunction with the x and y (height and width) coordinates.