Jan 292008

Today we explore two extended form widgets I used in my Lotusphere session BP212: The Great Code Giveaway: “Beyond Cool”. The first article in this series can be found here. You can download the instructions, code and databases here.

domino.form.ComboBox & domino.form.FilteringSelect

These widgets are extended from dijit.form.ComboBox and dijit.form.FilteringSelect to accommodate for the URL syntax that a Domino view requires when doing a view search. They are modern and Ajax based. You can open both by clicking the down arrow but you can also type in the field to narrow down the choices. The important part of these widgets is in the _startSearch function.

if(key != ""){
var sLetters = "abcdefghijklmnopqrstuvwxyz**";
var lastChar = key.substring(key.length-1,key.length);
var sUntilKey = "";
var iCharNum = sLetters.indexOf(lastChar);
sUntilKey = key.substring(0,key.length-1) + sLetters.substring(iCharNum+1,iCharNum+2);
sUntilKey = key.substring(0,key.length-1) + (parseInt(lastChar)+1);
query["StartKey"] = key;
query["UntilKey"] = sUntilKey;
query["StartKey"] = null;
query["UntilKey"] = null;

What we do here is creating the URL syntax for a Domino view search that requires the &StartKey= and &UntilKey= arguments to find the document(s) the user is searching for.

From Domino Designer 8 Help:

Where string is a key to a document in sorted view. The view displays at that document. In cases where there is no match for the StartKey, the next document is returned. So, for example, if the StartKey is “A” and there are no documents that begin with “A”, StartKey returns the first document that begins with “B.”

UntilKey is only valid when used with StartKey. It allows you to display the range of view entries beginning with the document specified by StartKey until the document specified by UntilKey. For example, &StartKey=A&UntilKey=B would give you all the entries that start with A. Use the &Count keyword to further limit the number of entries returned within any given range.

How to add to them to your form

Both these widgets are very easy to add to your forms. Both require the domino.data.ViewStore discussed in the previous article so you start by adding that.

<div dojoType="domino.data.ViewStore" jsId="DominoStore" url="../sessions.nsf/sessionlookup"></div>

Here we add a div tag with dojoType of domino.data.ViewStore, we give it a jsId of DominoStore and the url is pointing to a database and view. In this case a database called sessions.nsf parallel to the current database and a view named sessionlookup.

We add a Notes field to our form and make it type Dialog list. In the HTML Attributes of the field we add the following:

"dojoType="domino.form.ComboBox" store="DominoStore" searchAttr="IDTitle" pageSize="10" autoComplete="false""

The store attribute is the same as the jsId attribute of our domino.data.ViewStore above. The pageSize attribute is the number of documents we get/show at a time and the autoComplete attribute is for making the top search value auto complete the field. Try if for yourself by setting it to true.

I left the searchAttr attribute for last because it need some explaining. As you know we are using a store to get the values for the field.

If we open up the view sessionlookup in the database sessions.nsf in Domino Designer we see that the view has two columns. If you look at the Programmatic Name for the first column you’ll see that it is IDTitle. This column is what we want values from so we set the searchAttr to IDTitle. The value saved by a domino.form.ComboBox is the same as what you see.

The difference between a domino.form.ComboBox field and a domino.form.FilteringSelect field is that the latter has an onChange attribute and that the value of the field is always the identifier of the store it is using. What is an identifier you ask? Well, all data stores has a unique identifier. In some cases that is just an incrementing number starting at zero, but in the domino.data.ViewStore I created I used the NoteID. Why not the UNID? Because a document can actually exist several times in the same view.

So in a domino.form.FilteringSelect field representing all speakers I have the following attributes.

"dojoType="domino.form.FilteringSelect" store="SpeakerStore" searchAttr="Name" pageSize="10" autoComplete="false" onChange="setMentor(arguments);""

You can see this field in the “Mentor Selection” form in the “Mentors.nsf” database. It is part of the download. We now need the setMentor function.

function setMentor(arguments){
var identityRequest = {
identity: arguments[0],
onItem: function(item){
var sEmail = SpeakerStore.getValue(item, "Email");
onError: function(){
console.error("Fetch failed.");

A version of this function can be found in the “index” page inside the “Registration.nsf” database. In this function we first create an object, identityRequest, and set the property identity to the first value in the passed in arguments array by setting identity: arguments[0]. We also have an onItem property. This is the function we call when we have retrieved a value. onError is being called if an error occurs. In the bottom of the function we do the call to the store and pass in our identityRequest object. SpeakerStore.fetchItemByIdentity(identityRequest); In this case we only alert the email address of the user we selected but if you look at the same function in the “index” page mentioned above you’ll see that we call another function to go get the profile from greenhouse.lotus.com for that email.

If you want to dig deeper in all possible attributes that a ComboBox and a FilteringSelect can change see the dijit.form.ComboBox and the dijit.form.FilteringSelect JavaScript files. Remember that in Dojo the name space is done by the periods you see in the names above. So in the folder dijit you find a folder called form where you’ll find the files ComboBox.js and FilteringSelect.js.

I hope this tutorial together with my code examples will clarify these two widgets for you. If not please comment below and I will try to explain further.

Jan 282008

At Lotusphere in my session BP212: The Great Code Giveaway: “Beyond Cool” I showed a couple of widgets and a Grid based on the Dojo Toolkit. I’m going to show you how I did those in a couple of articles the next few days. Instead of going through the code line for line I’m just going to highlight some of the changed variables and code. All the code for these examples and demos can be found here.

Extending Dojo code

One of the really powerful things you can do with a large toolkit like Dojo is that you can extend a widget/class instead of having to change the underlying code in the toolkit itself. Instead of having to write all the code for your class you just extend an existing class and change the functions/variables you need to. You can also add your own variables and functions. Extending Dojo code is really easy. You create your own JavaScript file and “require” the existing class/widget.

dojo.declare("my.new.Widget", dijit.widgetToExtend, {
variablesToChange: "myNewValue",
functionToChange1: function(arg1){
//New code
functionToChange2: function(arg1, arg2){
//New code

In the example above we have extended a widget class called “dijit.widgetToExtend”. You would copy this JavaScript in a file named Widget.js inside a folder structure of “/my/new/” located parallel to the dijit, dojo and dojox folders. There are other places you can put your code but this is the simplest.

Using dojo.data

What is dojo.data?
Dojo.data is a uniform data access layer that removes the concepts of database drivers and unique data formats. All data is represented as an item or as an attribute of an item. With such a representation, data can be accessed in a standard fashion.

Ultimately, the goal of dojo.data is to provide a flexible set of APIs as interfaces that datastores can be written to conform to. Stores that conform to the standard interfaces should then be able to be used in a wide variety of applications, widgets, and so on interchangeably. In essence, the API hides the specific structure of the data, be it in JSON, XML, CSV, or some other data format, and provides one way to access items and attributes of items consistently.

The great thing about dojo.data stores are that they use a predefined way of getting/setting/updating code in the store. Whoever writes code for widgets that use stores does not have care about where the underlying data is located. It could come from a MySQL database, a XML file on the file system or now a Domino view.


I’ve added three variables to this class. You see them below with their default value.

parseTypes: false,
dateFormatLength: "short",
handleAsJSON: true,

parseTypes: Parses all view data into it’s correct format. Numbers become floats, dates become locale dates. Locale dates are dates that show up in the format that the current browser language want to show them.
dateFormatLength: If parseType is true, then show the date in this “length”. Can be long, short, medium or full.
handleAsJSON: Default is that all data from the Domino view is returned with JSON using the “&OutputFormat=JSON”. If you set this to false all data is retrieved using XML instead. JSON was not implemented on the Domino server until version 7.0.2 so if you use a server prior to this you need to set this variable to false.

There are five functions I want to mention briefly.

_filterResponse: Used for parsing view data in JSON format to the required format for a store.
_filterXMLResponse: Used for parsing view data in XML format to the required format for a store.
_returnColumnValue: Helper function to get the value for a specific object. Used from _filterResponse.
_returnEntryValue: Helper function to get the value for a specific XML node. Used from _filterXMLResponse.
_returnDateTime: Helper function to format the Domino date string to a dojo.date.locale.

That’s it for this time. Next time we’ll look at domino.form.ComboBox and domino.form.FilteringSelect that both use the domino.data.ViewStore. Happy coding.

Jan 252008

Troy Reimer at SNAPPS has created LotusScript classes for parsing and creating JSON text. These classes are contained within five script libraries. There is a JSONReader and a JSONWriter class together with some wrapper classes including JSONArray and JSONObject. The JSONWriter class is really cool. You can pass it basically anything Notes data related and let it create the JSON for you. This is really handy for passing a NotesDocumentCollection to the class and let it return perfect JSON to the browser or whatever called it.

This class provides two ways of outputing JSON text. The first is to pass an array, list, NotesDocument, NotesDocumentCollection, NotesView, NotesViewEntryCollection, or NotesViewEntry to the ToJSON method. This will render the object as JSON. If the object is a type of view object, the output will be taken from the column values. The output data is basically the same as the properties/values of NotesViewEntry. If the object is a document, its output follows the NotesDocument properties/values.

Troy has wrapped the code in a Notes database and the download can be found here. UPDATE! The link to this download is now available at JSON.org and at OpenNTF.org

Jan 252008
Lotusphere 2008 OGS
Photo by Aidy Spender

Rob, Jerald, Troy and I are back home at the office after a very exciting week at Lotusphere 2008. As always I wish I could have attended more sessions but with 5 sessions this year I just ran out of time.

Lotusphere 2008 Boat Race
Photo by Macian

Monday Carl Tyler and I had our heat in the annual Lotusphere Boat Race. Carl could not attend the final on Thursday because of his early flight back home but Troy Reimer from SNAPPS filled in and we finished in 3rd place.

Tuesday morning Troy and I presented BP205 – Extending and Customizing Templates for IBM Lotus Quickr. It was very well attended and even needed a overflow room. The presentation and demo files can be downloaded here.

Lotusphere 2008 Speed Geeking
Photo by RLB865

Tuesday night Rob Novak and I presented a cut down version of that session (in 5 minutes) 12 times at the Speed Geeking event.

Wednesday after lunch Troy and I had our very first Hands-On-Lab at Lotusphere: HND305 – Building Custom Themes for IBM Lotus Quickr and it was repeated the same afternoon by Jerald and Troy. A full room in the morning and almost full in the repeat in the afternoon tells me that we need to do this lab next year as well. Session materials can be downloaded here.

Wednesday afternoon Rob and I presented our session: BP212 – The Great Code Giveaway: “Beyond Cool”. This was the third year we presented a “Code Giveaway” session and it was very well attended. We went over 12 demos in 1 hour and it was a lot of fun. Session materials can be downloaded here.

Wednesday night party was a blast at Universal Studios – Islands of Adventure. Jerald, Troy and I made it to a few of the rides.

Lotusphere 2008 GuruPalooza
Photo by elesar1

Thursday morning Rob and I repeated our BP212 – The Great Code Giveaway: “Beyond Cool” session at 10 AM. To see the room almost full that early the last day of the conference was very exciting.

Thursday afternoon Rob and I also sat on stage for the annual “GuruPalooza” session.

It was a great Lotusphere and I really hope to be at Lotusphere 2009. I’ll see you there.

Jan 182008

Rob Novak has created a Lotusphere Keynote Bingo card!

As the Keynote (Opening General Session or OGS in Lotusphere land) progresses, you simply check off the items that really do happen. If you find yourself in the lucky position of having a straight line of five, simply yell out “BINGO!”.

You can download the PDF from his site.

Jan 152008

We here at SNAPPS has outlined plans to convert our entire line of AnyPlace™ for Quickr and QuickPlace to free licenses.

From Rob Novak’s blog:

Our products, especially AnyPlace Administrator, have been an entry point for many enterprise customers who have then become high-value consulting or development clients. Making the AnyPlace products free brings down the price barrier to realizing the value of these powerful tools, while expanding the reach of the SNAPPS name throughout IBM’s Lotus Quickr customer enterprises. Our goal is to expand the use of these products by 50 times their level as paid licenses. It’s about giving back, and it’s about ubiquity.

The four products are detailed on the SNAPPS website under “Solutions”, and have trial versions available.

At the same time we are announcing the immediate availability of fully supported subscription versions of the template applications for as little as $1 per user, in addition to new support options for the free versions.

A subscription entitles the subscribing company to benefits usually associated with fully paid licenses – for a fraction of the price – including:

  • Unlimited technical support, a helpdesk and escalation system
  • A new blog, wiki and documentation site combined with the template website
  • Guaranteed first release with new features, and a feature request mechanism
  • Guaranteed compatibility with new IBM Lotus Quickr versions within 30 days of their release

Subscription pricing is between $1 and $2 per user, per application, per year depending on the number of subscription units purchased. Custom subscription options are available for modified or combined templates, and QSite is priced at 2x the normal subscription price (QSite includes 10 applications in one).

Is that not great news just before Lotusphere?

Jan 032008

First of all, Happy New Year. I hope 2008 will bring you good fortune.

Here at SNAPPS I’ve been extremely busy preparing for my sessions at Lotusphere. I’ve already posted about them here. If you have a chance to attend Lotusphere this year, and are using Domino, I think this will be the most exciting one in years. If you see me in the halls, come up and introduce yourself. I love meeting new people.

December ended very hectic with my youngest son Erik’s first birthday and later Christmas with in-laws visiting. A great time with family and lots of great food.

I know a lot of you are waiting for my update of the Dojo Calendar to work with the Dojo Toolkit 1.0 and beyond. I’m working hard to have it out there for you soon. I’ve been very busy with “real” work, but I have a working copy so all I can say is soon.

Speaking of the Dojo Calendar. I have decided to make it work with dojo.data. To make the calendar get information from many different resources is important and the Dojo data stores make that more convenient using the same API no matter what the source is.

I hope I see you at Lotusphere.

Dec 052007

As Rob Novak already blogged about here, today is SNAPPS (real name – Strategic Net Applications, Inc.) 10th birthday.

I have been an employee of SNAPPS and Rob for 8 years now and I could not be happier and, yes, proud that we reached this milestone together.

Congratulations Rob, and the rest of my co-workers, Melissa, Troy and Jerald.

Nov 162007

I have had the privilege to speak at every Lotusphere since 2002. In 2001 my first son, Jakob, was about to be born and my wife did not want me to travel that close to his birth. I have actually never attended Lotusphere as anything other than a speaker. This year I have three sessions accepted by the Content Team.


Session: Building Custom Themes for IBM Lotus Quickr
Track: Hands-on Sessions
Abstract: The elements of a good user interface are just the beginning when it comes to Lotus Quickr — with this platform, you expose functionality, user context and security in the “look and feel.” Custom themes give you much more. In this first-ever hands-on session you’ll explore the inner workings of themes, building one from scratch (with a little help). Your instructors wrote the book on themes, and have developed more than 100 in the past 8 years for companies worldwide, from simple corporate looks to highly complex, feature-packed themes. You’ll learn the custom tags, tips and tricks on Lotus Quickr CSS, and how to use themes to improve Lotus Quickr performance. You’ll also get some brand new themes you can take home to study … and even deploy!The corresponding breakout session for this hands-on is “AD502 Customizing IBM Lotus Quickr Themes and Skins”.Please refer to the Pocket Agenda for date, time and location information.
Speakers: Viktor Krantz
Troy Reimer

This is the first time that I am presenting at a hands-on session and it will be fun. You will learn a lot about theme developing here.


Session: Extending and Customizing Templates for IBM Lotus Quickr: Straight from the Developers
Track: Track Four: Best Practices
Abstract: The IBM Lotus Quickr 8 release was quickly followed by a suite of eleven free, open templates, now used by thousands of companies worldwide. Each template has a specific business purpose and design, but they share common elements and reusable techniques and components. In this session, the developers of the templates will dig into the code, expose and explain some of the most valuable components, and teach you to assemble Lotus Quickr applications using a modular, extensible approach. By learning techniques for adding comment capabilities, custom workflow, tagging, and more, you’ll come away with the skills and tools necessary to build your own Lotus Quickr application. Plus, you’ll also receive a new template designed exclusively for Lotusphere 2008!
Speakers: Viktor Krantz
Troy Reimer

This will be a really fun session. You will learn how to extend and combine some of the 11 free templates we at SNAPPS have created for Lotus Quickr 8.


Session: The Great Code Giveaway: “Beyond Cool”
Track: Track Four: Best Practices
Abstract: All new development techniques are brewing in the labs at SNAPPS, an IBM Business Partner with a penchant for giving expensive code away while providing a great education. It’s always very cool, and incredibly useful — the code is used by businesses, governments, partners, customers, and celebrities to improve applications and techniques. This year the SNAPPS labs have produced some of the most impressive IBM Lotus Domino-centric techniques in four areas: visual effects, data access and processing, mashups, and cross-product integration. Sounds like a lot, and it is! We’ve logged more than 500 hours bringing you these demos, so don’t miss the opportunity to experience “Beyond Cool” and take home incredible examples and full-blown applications!
Speakers: Rob Novak
Viktor Krantz

This is the session I look forward to all year long. Rob Novak and I spend a lot of time on this one. Over 500 hours last year and it will not be less this year. We have delivered it several years in a row now, always with new content, free useful code to take home and sometimes a little cool.

I hope to see you at Lotusphere 2008 in January.

Oct 092007

From Rob Novak’s blog, his original posting can be found here.

So – to recap – we found a massive, hairy, evil monster that can cause pain and most definitely fear in most human beings, especially around the office. So naturally, we named it SharePoint. Here is an actual photo of the beast, taken just this weekend.

Sadly this week, we’re going to kick SharePoint out. Turns out it’s too expensive to keep feeding it, and it really needs a bigger box (probably more than one) and more attention than anybody originally thought. It keeps getting bigger and bigger, and we’re honestly getting more afraid of it every day.

We have a lot of fun at SNAPPS.