Wednesday, December 22, 2010

XPages and Server Side Javascript libraries

So, you have created an XPage and you have a Javascript function that you want to reuse in multiple places within the XPage (say, for example, to hide a number of different controls on the page using identical logic).  Where do you place the Javascript function so that you can access it from Server Javascript and not have to rewrite (and maintain) identical code multiple times?  The answer is a "Server Javascript" script library.

You create a "Server Javascript" script library in the same way you would any other script library.  The secret is to change the script library type to "Server Javascript".

Figure 1 - Creating a Server Javascript script library

Give the script library a name and click OK.  The "Server Javascript" editor panel opens.

Figure 2 - The Server Javascript editor panel
This is the editor panel that you should be familiar with from adding Server Javascript to XPages.  Add the Javascript function to your library in the same manner you would if you were adding it direct to your XPage.  When you are finished, save and close the editor.

So, how do you reference your script library from your XPage?  The key is the import keyword.  At the start of your Server Javascript routine, you need to enter the following statement:
import xpages;
where xpages is the name of your Server Javascript script library.  You will then be able to call all of the functions you placed in the script library in your routine.

Monday, June 28, 2010

Introduction to Domino servlets - Part 1

Domino servers support Java servlets.  According to wikipedia, servlets are "a Java class which conforms to the Java Servlet API, a protocol by which a Java class may respond to http requests".

For the Domino developer, it is easiest to think of servlets as Java web agents that sit outside a database.  There are two advantages of using servlets over standard Java web agents:
  1. They are not constrained by the limitations of agents inside a database.  So, for example, a servlet can access the raw HTTP data sent by the browser - whereas this information is already pre-processed in a standard agent and cannot be accessed.  In addition, a servlet can send binary data to a browser - an agent cannot.
  2. They are only loaded into memory the first time they are called.  This means they run more efficiently than standard web agents -  which are loaded into memory every time they run.

In order to use Java servlets, your Domino server needs to enable the Domino Servlet Manager. This is done in the Internet Protocols... section of the server configuration document:


There are a series of configuration options for Java servlets, however, the default options will generally suffice.  You will need to restart the server once the servlet manager has been enabled.

Part 2 of this post will examine how to write a servlet in Java.  The final part will examine how to implement and call them from your Domino server.

Wednesday, June 9, 2010

Domino 8.5 upgrade gotcha

There is a difference in the functionality of the Send method between Domino version 7.0.3 and Domino version 8.5.1.  In Domino 7.0.3, the following code:
Call document.Send(False, "First Person/OU=One/OU=2/O=3; Second Person/OU=Four/OU=Five/O=Six")
would send two e-mails - one to First Person  and another to Second Person.  Domino treated the ";" character as a name separator.

With Domino 8.5.1, this is no longer the case.  Domino no longer recognises the ";" as a name separator.  Instead, it will now attempt to send an e-mail to a person called "First Person/OU=One/OU=2/O=3; Second Person/OU=Four/OU=Five/O=Six" - and will obviously fail.

So, what is the correct code for Domino 8.5?  To achieve the same result as Domino 7.0, your code now needs to be written as follows:
Dim names(1) As String
names(0) = "First Person/OU=One/OU=2/O=3"
names(1) =  "Second Person/OU=Four/OU=Five/O=Six"
Call document.Send(False, names)
The Send method expects an array of strings as the second argument.  The problem is identical, regardless of whether you supply the recipient names as a parameter on the Send method or you add a SendTo field to the document.

Sunday, May 30, 2010

Lotusscript and Windows APIs

Did you know that Lotusscript supports Windows APIs?  Windows APIs are routines that provide access to commonly used lower-level Windows functionality.  There are literally thousands of APIs that provide almost all of the functionality available through Windows.  For example, you could change the caption of a window using an API, you could add a printer to the list of available printers or you could complete many other tasks that cannot be achieved through Lotusscript alone.  Windows APIs are contained in DLL files that are installed when Windows is installed - so they will work on all Windows machines without any additional file installation required.

So, how do you import API functionality into your Lotusscript agent?  You use the Lotusscript Declare keyword. The Declare keyword tells the Lotusscript compiler that a subroutine is not defined in Lotusscript but can instead be found in an external DLL file.

The best way to demonstrate the use of this keyword is by example.  We will create a Lotusscript agent that flashes the foreground window on your desktop - something that cannot be achieved through Lotusscript alone.

In the Declarations section of your agent, enter the following code:
Declare Private Function GetForegroundWindow Lib "user32.dll" () As Long
This declaration imports the GetForegroundWindow API.  This API retrieves the handle to the desk-top foreground window (usually the active window on the desk-top).  A window handle is a unique number identifying a specific window to the Windows operating system.  The declaration tells the compiler that this API can be found in the user32.dll file.  It also tells the compiler that the API returns a value of type Long.  It is important to note that API names are case-sensitive - so, getforegroundwindow is not the same as GetForegroundWindow.

On the next line of the Declarations section of your agent, enter the following code:

Declare Private Function FlashWindow Lib "user32.dll" (Byval hwnd As Long, Byval bInvert As Long) As Long
This declaration imports a second API - FlashWindow.  As with the GetForegroundWindow API, it is  found in the user32.dll file and returns a Long variable.  However, unlike GetForegroundWindow, the FlashWindow API expects two parameters - hwnd and bInvert.  The Declare statement tells Lotusscript what parameters an API expects and the variable type of the parameters.  The purpose of these parameters for this particular API is discussed below.

Now that we have successfully told the Lotusscript compiler about the APIs we will be using, we can write the Lotusscript to call them.  In the Initialize section of your agent, enter the following code:
Dim hWnd As Long

hWnd = GetForegroundWindow()

Call FlashWindow(hWnd, 1)
The first line of code,
hWnd = GetForegroundWindow()
retrieves the handle to the desk-top foreground Window.

The second line of code,
Call FlashWindow(hWnd, 1)
actually causes the window to flash. The first argument (hwnd) is the handle of the window we wish to flash. The second argument (bInvert) is 0 if we want a window to stop flashing, or non-zero if we want a window to start flashing.

Save the agent, then run it.  You will see in the taskbar of Windows the tab for the active window flash. 
This basic structure can be followed for all Windows APIs - and there are thousands of them. They can be used to cleverly extend Lotusscript agents to perform functionality well beyond its standard limitations.

Thursday, May 27, 2010

Domino 8.5

So, my work has just upgraded the first of our Domino servers to version 8.5 - which means I am finally showing interest in some of the new features in the latest release.

In particular, I am so excited that the JVM now runs version 1.6 of Java - giving us access to all of the cool new features in that release of Java. To my mind, this is a step towards providing Domino servers with some of the powerful features that ASP.NET developers have had for some time.