Developing XPages using Domino Designer 8.5
Course Title: Developing XPages using Domino Designer 8.5
Units: 16
Duration: 4 classroom equivalent days
Discussion Access: One Year

Summary Description
XPages are the first new application design element for Domino in years and will change the way you think about Notes/Domino application design. TLCC, the leader in Notes and Domino training, is the first to offer a comprehensive course on XPages. Developing XPages using Domino Designer 8.5 takes a deep dive into XPage development. Learn the basic building blocks of XPages, from controls to events to the JavaScript editor. All the XPage controls are covered. The available programming languages for XPages along with the various supporting libraries including the new @Functions and the Domino Object Model are covered in detail. Discover how Cascading Style Sheets are fully implemented in XPages along with an all new design element called Themes. Another new design element, Custom Controls, allows controls to be easily re-used on multiple XPages (just like a subform). This course also covers the use of XPages in the Notes client.

This course covers advanced techniques such as:
  • Combine a view and a document on one page with complete edit capabilities
  • Combine multiple documents or multiple views on a page
  • Create dynamic tables with repeat controls
  • Join data from different views and databases into one view
  • Filter views to show only certain categories or the results of a full-text search
  • Integrate Java and web services in XPages
  • Use the built-in AJAX functionality to enable type ahead and partial page refresh
  • Display a responses-only column so it appears just like the Notes client
  • Enable Authors and Readers fields
This distance learning course, like all TLCC courses, includes many demonstrations and activities you will do "live" in Domino Designer. No simulations or videos are used. You will get hands-on experience building XPages while learning at your own pace in your own home and/or office. A Domino server is not required and the course will install on your local system. Need help? An expert TLCC instructor is a click away via an integrated course discussion database.

Developing XPages using Domino Designer 8.5 is a complete and comprehensive course and not just a collection of sample exercises. You will gain a complete understanding of XPages and how this exciting technology can be used to enhance your new and existing Domino applications.

Audience and Prerequisites
Experienced Notes and Domino 8.5 application developers. Experience with the Document Object Model is helpful using either LotusScript or Java.
The following TLCC courses (or their equivalent) are recommended prerequisites for this course:
  • Notes Domino 8.5 Application Development 1 or Notes Domino 8.5 Application Development Update
  • JavaScript for XPages Development (8.5)
System Requirements
  • Domino Designer 8.5
    (This must be installed prior to installing this TLCC course.)
  • A current web browser client
  • Access to the Internet for instructor support
Course Modules

Module 1 - XPages Overview
XPages are the new design element introduced in the Lotus Notes Designer 8.5. XPages are a new way to develop web applications for Domino 8.5 (and starting in 8.5.1 for the Notes client as well). This module provides an introduction to this exciting new design element as well as an overview of the new Eclipse based IDE used in Designer 8.5. The general XPage architecture as well as the XPages design features are discussed in this module. This module discusses the supported programming languages used in XPage design. The nature of the XPage design element, and the process and necessity of compiling the XPage source code in Designer is covered. Finally, starting with Notes Domino Release 8.5.1, XPages can now be rendered in the Notes Client. Domino developers can now create a single design element that can be accessed by both Web browsers and the Notes client, allowing the developer to concentrate on functionality and not platform.
  • The new Domino Designer interface in Eclipse (DDE)
  • The general architecture and design features of XPages
  • Supported programming languages used in XPage design including JavaScript, the Expression Language, @Functions, and Java
  • Understand the nature of the XPage design element in context of compiling the XPage source code and compatibility considerations
  • Considerations for rendering XPages in the Notes client such as launching the "Home XPage", applying different Themes for Notes and Web clients, and XPage security in the Notes client
Module 2 - Creating an XPage
This module covers the basic components used when creating an XPage. Understanding each of these basic components will provide you with the necessary skills to create an XPage. For example, learning how to add and use the different control types on an XPage, and understanding the importance of data sources and data bindings for creating XPages is covered in this module. You will discover how to use the new Domino Designer views such as the Outline, Properties and Events views necessary for XPage development. This module also demonstrates how to use simple actions and the JavaScript editor to code client-side and server-side events.
  • Create a new XPage, add and format text, and then save and preview the XPage
  • Troubleshoot errors
  • The different control types available for XPage design
  • Use The Outline view to select, move, and delete the XPage controls
  • Use the Properties view to view and set properties for the various elements and controls on an XPage
  • Dynamically compute properties
  • Write Client-side and Server-side JavaScript that is triggered by events
  • Invoke Simple Actions from Events
  • Directly edit and view XPage source code
  • Use the JavaScript Editor
  • Use Domino data sources to connect XPages to views and documents
  • Understand data binding of Domino fields to XPage controls
  • Utilize the Data palette to drag and drop Domino fields onto an XPage
Module 3 - XPage Controls
This module covers the extensive palette of XPage controls available from the Controls palette in Domino Designer. This module covers these controls in logical categories such as Edit controls, Selection controls, Action controls, Display controls, Container controls and Error Display controls. The Controls palette categorizes the controls as either Core controls or Container controls. The core controls are common controls that appear as single entities in an XPage, whereas Container controls are more complex because they are designed to contain other controls.
  • The edit/input controls used to display Domino fields such as the Edit Box, Multiline Edit Box, Date Time Picker, and Rich Text controls
  • The selection controls such as the Combo Box, List Box, Check Box Group and Radio Button Group controls
  • Use various techniques to control the list of choices shown to the user when using a ComboBox or ListBox control
  • The action controls such as the Button, Link, File Upload and File Download controls
  • Add buttons to an XPage to submit a page and control navigation between XPages
  • Create buttons to perform simple actions such as switching between read and edit mode
  • Use the display controls such as the Label, Image and Computed Field controls for displaying text or images when the page is rendered
  • The different container controls such as Sections, Panel, Tables, Tabbed Panels, and Include Page controls
  • Container controls used to display data such as the Repeat, and Data Table controls
  • The Display Error and Display Errors controls to display error messages
Module 4 - XPages with Domino Views and Documents
This module covers the relationship between controls on an XPage and Domino data (views and documents.) We begin with an overview of the Domino design elements that are required to support XPage development, whether working with an existing Domino application, or creating a new one. Details on how to display a Domino view on an XPage are covered. Learn how to create an XPage that can be used to display, create, and edit Domino documents. Finally, the validation of data on an XPage is covered in this module.
  • Understand the relationship between Domino design elements and XPages
  • Use the computeWithForm property to utilize Domino form formulas (Default, Input Validation, and Input Translation)
  • Display a Domino view on an XPage using a View control
  • Control the XPage to be used when a user clicks on document in a View control
  • Hide Controls on an XPage dynamically based on edit mode vs. read mode
  • Set the properties for the View control including the pager, view column headers, and view columns
  • Display and edit Domino documents using an XPage (read mode and edit mode)
  • Design navigation buttons and links on an XPage for creating and saving a new document
  • Create buttons to perform simple actions such as switching between read and edit mode
  • Validate user entered data on an XPage
  • Understand the difference between client-side and server-side validation and how to set validation properties
  • Use the Display Error and Display Errors controls to display error messages
  • Use advanced validators including regular expressions to validate data in XPage controls
Module 5 - Formatting and Styles
This module covers the use of Cascading Style Sheets (CSS) to change the look and feel of XPage applications. Formatting and styles can be applied directly to almost every control on an XPage through the Style tab in the Properties view. However, the best practice is to apply styles using an included Style Sheet that sets styles via Element, ID and Class attributes. Themes are a new design element in Domino 8.5 to control the look and feel of an entire application without needing to add formatting and styling to each individual XPage.
  • A brief introduction to Cascading Style Sheets and how CSS is used to style a web page
  • The XPage style properties and how they are used to provide style/formatting to individual XPage controls
  • Create and add style sheets to an XPage
  • Apply style sheet rules to elements/controls on an XPage
  • Use the CSS Editor in Domino Designer
  • Use an external CSS editor to edit Domino Style Sheet Resources
  • Import and export style sheets into/out of Domino applications
  • Add Style Sheet Resources to an XPage
  • Export styles from a control to a Style Sheet resource (CSS file)
  • Learn what themes are and how they can be used to globally alter an application
  • Use the provided Themes in an application
  • Select a theme to be used in an application
  • Create a new theme to reference a specified style sheet
  • Use a theme to apply a style to all XPage controls such as all the Label controls
Module 6 - JavaScript: The Language of XPages
JavaScript is the programming language of XPages. The events for most XPage controls can be both client-side and server-side JavaScript. Server-side JavaScript can also be used for computing the value of most of the properties on controls on an XPage. Server-side JavaScript code has full access to Domino data either in the current application or other applications via the Domino Object Model or @Functions. This module will explore the back-end Domino Classes and introduce how to access the Domino objects using server-side JavaScript on an XPage. Creating and using script libraries for storing reusable code in an application is covered in this module. The implementation of AJAX functionality to support type ahead and partial page refresh of an XPage is also covered.
  • Use client-side JavaScript for events on XPage controls
  • Learn how to write client-side JavaScript to access XPage controls
  • Use server-side JavaScript.for events on XPage controls
  • Use sever-side JavaScript to get and set the values in controls on an XPage
  • Use Global Objects and Global Functions in server-side JavaScript
  • Use Scoped Variables to store data, such as the application scope, session, scope, request scope and view scope variables
  • Debug server-side JavaScript using either the log file or using a Computed Field control
  • Write server-side JavaScript to get full access (security permitting) to Domino applications via the Domino Object Model or @Functions
  • The Domino @Functions
  • Using @DbColumn and @DbLookup in Server-side JavaScript
  • Dynamically hide XPage controls
  • Use the Domino Object Model in server-side JavaScript such as the NotesSession, NotesDatabase, NotesView and NotesDocument classes
  • The XSP Library classes that support XPage development
  • Create and use client-side and server-side JavaScript libraries to store reusable code
  • Use the Dojo library on an XPage
  • Implement the type ahead and partial page refresh features of the included AJAX functionality
Module 7 - Advanced Techniques
The XPage basics including how to display a Domino view and how to link the view to Domino documents have already been covered. XPages are very powerful and can do much more than that. This module will cover some examples of how to harness the full power of XPages in a Domino application. These advanced techniques will be very practical to a Domino developer and will also provide some ideas on how to move even beyond these techniques and take advantage of the power of XPages for your specific needs. Techniques that were once either not possible or very difficult to perform in standard Domino development are accomplished quite simply due to the underlying key difference in XPages; the separation between the presentation and the data source. This module will show how to exploit this key difference by learning how to combine a view and document on the same XPage, have multiple data sources per page, and effectively display categorized and response-only views for example. Several other advanced techniques and XPage related properties will be covered in this module. Also covered is how to integrate Java code from both a Java class file or a web service on an XPage.
  • Add a dynamic view filter to a View control on an XPage
  • Display data from multiple data sources on an XPage
  • Link a view and form on the same XPage together so the document details are displayed when a user clicks on a document in the view
  • Create dynamic tables using a Repeat control to display information from a Domino view
  • Join together information from two different Domino views in one view control
  • Use a Repeat control to display the contents of a multi-value field
  • Write, compile, and execute Java code from an XPage
  • Call a web service and return data to an XPage script
  • Implement advanced techniques for displaying Domino views on an XPage such as categorized views and displaying a responses only column in a view
  • Compute the values in a view column of a view control
  • Explore the relationship between the Domino form design and an XPage
  • Use the 'Run form validation' property on the XPage to implement Domino field formulas
  • Implement "Authors" and "Readers" names fields on an XPage
  • Use the XPage events to take the place of the Domino WebQuerySave and WebQueryOpen agents
  • The XPage server and application properties , as well as several other advanced properties that affect XPage development.
  • Add an XPage as a component in a composite application
Module 8 - Building Custom Controls
Custom Controls provide the same functionality for XPages as subforms do for Domino forms. Custom Controls can be used to group common elements and controls on a "subXPage", perhaps to create a common header or footer. The Custom Control can then be added to other XPages in the same application. A Custom Control can also use properties that can be defined when the Custom Control is used on an XPage. A Custom Control can also have an "editable area" where content can be added once the control is used on an XPage. The use of these properties and editable areas allow the custom control to be fine-tuned for that particular XPage it is used on. This module will cover how to create and use your own custom controls, and how to add editable areas to a Custom Control.
  • Create Custom Controls and use them in XPage design
  • Set up configurable properties on a Custom Control
  • Define the value for a Custom Control property after it is used on an XPage
  • Add Editable areas to a Custom Control
Module 9 - Additional Exam Topics
This module covers additional topics to help prepare for Test LOT-986: Creating IBM Lotus Notes and Domino 8.5 Applications with XPages and Advanced Techniques. Some of these topics are covered at an introductory level in this module and are covered in greater detail in the XPages Development 2 for Notes and Domino 8.5 course.
  • Understand the design differences and considerations between traditional Notes application design elements and XPages
  • Running agents from Server-side JavaScript
  • Set required properties to allow an XPage to display one data source in read mode and another in edit mode
  • Use the context, facesContext and view global objects to access the current URL and to redirect to a URL
  • Get CGI variables via the JSF context
  • Use methods of the global facesContext object to set a cookie from an XPage and return all cookies for an XPage
  • Use the getValue() method of the cookie object to return the value for a specified cookie
  • Set XPage ACL property values to control access to XPages, Custom Controls and Panels
  • Understand the process for using DECS/DCRs as an XPage data source
  • Apply Single Copy XPage Design for improved performance
This list of topics is valid for the latest version of this course and may not be accurate for older versions.