Home
HCL Domino Designer User Guide and Reference
This guide provides information on using HCL Domino Designer and programming language reference information.
Programming Overview and User Interface
This section contains general guidelines and examples that show where to use Java, LotusScript, and the formula language.
XML for Domino
The following topics cover some general guidelines for using XML in Domino applications and list all the elements, attributes, and entities in the Domino Document Type Definition (DTD):
Org.W3C.DOM package
The documentation for the org.w3c.dom package covers the following Java interfaces:
DOMImplementation (Org.W3C.DOM Package)
The DOMImplementation interface provides methods for performing operations that are independent of any particular instance of the document object model.

HCL Domino Designer User Guide and Reference
This guide provides information on using HCL Domino Designer and programming language reference information.
- What's new in Domino Designer 14.5?
  The following features are new for developers in HCL Domino® Designer 14.5.
- What's new in Nomad Designer?
  HCL Nomad for web browsers v1.0.10 introduces the capability to design Notes databases. For more information, see HCL Nomad for web browsers User Documentation, Nomad web Designer.
- Accessibility and keyboard shortcuts
  Accessibility features assist users who have a disability, such as restricted mobility or limited vision, to use information technology content successfully.
- Application Design
  Welcome to the Application Design section of Domino® Designer Help.
- Application Management
  Welcome to the Application Management section of Domino® Designer Help.
- Domino® Query Language
  Domino® Query Language (DQL) is a facility running on a Domino server that provides a terse, shorthand syntax for finding documents. It supports a wide variety and complexity of search terms. It leverages existing design elements, avoiding the need to write detailed code to access them. DQL consolidates all methods in Domino for searching document contents.
- Composite Applications - Design and Management
  Composite applications are a key element in a service-oriented architecture (SOA) and contextual collaboration strategy. The ability to create and edit composite applications lets you easily integrate different types of components and technologies.
- DB2® Access views
  Domino® Designer includes two types of design elements to assist you in managing data contained in DB2® enabled Notes® databases:
- Programming Overview and User Interface
  This section contains general guidelines and examples that show where to use Java, LotusScript, and the formula language.
  - Programming Overview
    This documentation describes how to attach Java, JavaScript, LotusScript, and formula code to Domino design elements. Here are some overview topics:
  - User Interface
  - XML for Domino
    The following topics cover some general guidelines for using XML in Domino applications and list all the elements, attributes, and entities in the Domino Document Type Definition (DTD):
    - Using XML with Domino
      Domino now provides support for Extensible Markup Language, or XML. XML enables you to tag data in order to delimit it, leaving the interpretation of the data to the applications that read it. Unlike Hypertext Markup Language (HTML), which describes the appearance of data, XML describes the structure of data. This makes XML compatible with Domino, which stores data in structured documents, separate from its presentation. By using XML -- working on data separated from its presentation -- you can now generate more powerful Domino applications.
    - Reading a DTD
      A Document Type Definition (DTD) describes the content and hierarchy of Extensible Markup Language (XML) tags that are used by an organization to define data it wants to share across platforms. The DTD consist of the following:
    - The Domino DTD
      The Domino Document Type Definition (DTD) describes the structure of DXL, the Domino version of Extensible Markup Language (XML). The DTD contains the definitions of the XML tags that you can use to validate your XML documents while converting external XML data into Domino databases or to understand any XML documents produced while exporting internal Domino databases into XML.
    - Org.W3C.DOM package
      The documentation for the org.w3c.dom package covers the following Java interfaces:
      - Attr (Org.W3C.DOM Package)
        Extends Node. The Attr interface represents an attribute in an Element object. Typically, the allowable values for the attribute are defined in a DTD (document type definition).
      - CDATASection (Org.W3C.DOM Package)
        Extends Text. CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections cannot be nested. The primary purpose is for including material such as XML fragments, without needing to escape all the delimiters.
      - CharacterData (Org.W3C.DOM Package)
        Extends Node. The CharacterData interface extends Node with a set of attributes and methods for accessing character data in the DOM. No DOM objects correspond directly to CharacterData, though Text and others do inherit the interface from it. All offsets in this interface start from 0.
      - Comment (Org.W3C.DOM Package)
        Extends CharacterData. This represents the content of a comment, i.e., all the characters between the starting ''. Note that this is the definition of a comment in XML, and, in practice, HTML, although some HTML tools may implement the full SGML comment structure.
      - Document (Org.W3C.DOM Package)
        Extends Node. The Document interface represents the entire HTML or XML document. Conceptually, it is the root of the document tree, and provides the primary access to the document's data.
      - DocumentFragment (Org.W3C.DOM Package)
        Extends Node. DocumentFragment is a "lightweight" or "minimal" Document object. It is very common to want to be able to extract a portion of a document's tree or to create a new fragment of a document.
      - DocumentType (Org.W3C.DOM Package)
        Extends Node. Each Document has a doctype attribute whose value is either null or a DocumentType object. The DocumentType interface in the DOM Level 1 Core provides an interface to the list of entities that are defined for the document.
      - DOMException (Org.W3C.DOM Package)
        Extends RuntimeException. DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable). In general, DOM methods return specific error values in ordinary processing situation, such as out-of-bound errors when using NodeList.
      - DOMImplementation (Org.W3C.DOM Package)
        The DOMImplementation interface provides methods for performing operations that are independent of any particular instance of the document object model.
      - Element (Org.W3C.DOM Package)
        Extends Node. By far the vast majority of objects (apart from text) that authors encounter when traversing a document are Element nodes. Assume the following XML document:
      - Entity (Org.W3C.DOM Package)
        Extends Node. This interface represents an entity, either parsed or unparsed, in an XML document. This models the entity itself, not the entity declaration. The nodeName attribute that is inherited from Node contains the name of the entity.
      - EntityReference (Org.W3C.DOM Package)
        Extends Node. EntityReference objects may be inserted into the structure model when an entity reference is in the source document, or when you wish to insert an entity reference. Character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference.
      - NamedNodeMap (Org.W3C.DOM Package)
        Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes. .
      - Node (Org.W3C.DOM Package)
        The Node interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree. While all objects implementing the Node interface expose methods for dealing with children, not all objects implementing the Node interface may have children. For example, Text nodes may not have children, and adding children to such nodes results in a DOMException being raised. The attributes nodeName, nodeValue and attributes are included as a mechanism to get at node information without casting down to the specific derived interface. In cases where there is no obvious mapping of these attributes for a specific nodeType (e.g., nodeValue for an Element or attributes for a Comment), this returns null. The specialized interfaces may contain additional and more convenient mechanisms to get and set the relevant information.
      - NodeList (Org.W3C.DOM Package)
        The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.
      - Notation (Org.W3C.DOM Package)
        Extends Node. This interface represents a notation declared in the DTD. A notation either declares, by name, the format of an unparsed entity, or is used for formal declaration of Processing Instruction targets. The nodeName attribute inherited from Node is set to the declared name of the notation.
      - ProcessingInstruction (Org.W3C.DOM Package)
        Extends Node. The ProcessingInstruction interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document. .
      - Text (Org.W3C.DOM Package)
        Extends CharacterData. The Text interface represents the textual content (termed character data in XML) of an Element or Attr. If there is no markup inside an element's content, the text is contained in a single object implementing the Text interface that is the only child of the element. If there is markup, it is parsed into a list of elements and Text nodes that form the list of children of the element.
    - Org.XML.SAX package
      The documentation for the org.xml.sax package covers of the following Java interfaces:
  - JSP Custom Tag Libraries
    A JavaServer Page (JSP) is a HTML Web page that contains code which executes application logic to generate dynamic content. The page is created at the time it is requested. JSP pages are compiled into servlets; the code they contain is executed by the server. For more information on JSPs, see the Sun Microsystems Web site: http://java.sun.com/products/jsp/.
  - Programming Domino for Web Applications
    You should be aware of certain procedures, restrictions, and enhancements available to you when using Domino Designer to program Web applications. This section describes the following areas:
- Formula Language
  This section documents the formula language.
- LotusScript® Language
  Welcome to the LotusScript® Language section of Domino® Designer Help.
- LotusScript/COM/OLE Classes
- Java/CORBA Classes
  This section documents the Java/CORBA classes.
- Connectors
  Connectors provide native access to a wide variety of DBMS products, ODBC, the platform File system, Enterprise Resource Planning systems, and Transaction Processing systems.
- Javadoc™ for Domino® Designer related APIs
  As part of providing additional Java™ reference documentation, Domino® Designer ships with a help plugin that contains Javadoc™ for additional Domino Designer related APIs.

DOMImplementation (Org.W3C.DOM Package)

The DOMImplementation interface provides methods for performing operations that are independent of any particular instance of the document object model.

The DOM Level 1 does not specify a way of creating a document instance, and hence document creation is an operation specific to an implementation. .

See the following for methods.

hasFeature

Test if the DOM implementation implements a specific feature.

Syntax:

public boolean hasFeature(java.lang.String feature, java.lang.String version)

Parameters:

feature - The package name of the feature to test. In Level 1, the legal values are "HTML" and "XML" (case-insensitive).

version - This is the version number of the package name to test. In Level 1, this is the string "1.0". If the version is not specified, supporting any version of the feature will cause the method to return true.

Return value:

True if the feature is implemented in the specified version, false otherwise.