Mindoo Blog Cutting edge technologies - About Java, Lotus Notes and iPhone http://www.mindoo.de/web/blog.nsf/ en-us Thu, 22 Jul 2010 22:32:43 +0200 The View article: Add LSDoc Support to Domino Designer on Eclipse with Custom Plug-ins (download link included) Thu, 22 Jul 2010 22:32:43 +0200 http://blog.mindoo.com/web/blog.nsf/dx/22.07.2010223240KLES4H.htm DDE Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/22.07.2010223240KLES4H.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/22.07.2010223240KLES4H.htm
Here is the public abstract and the download link for the plugin. Of course, we highly recommend that you get a subscription for THE VIEW if you're not a subscriber yet.


Add LSDoc Support to Domino Designer on Eclipse with Custom Plug-ins

Improve, accelerate, and streamline the Domino application development process by adding custom Eclipse extensions to Domino Designer on Eclipse (DDE). Find out how to add a handy development tool - LotusScript documentation support - to DDE and learn techniques and tricks that you can reuse for your own plug-in development.
Moving IBM Lotus Domino Designer to the Eclipse platform has opened a new world of extensibility and customizability opportunities to developers. No longer restricted to using error-prone C add-in development to add features to Designer, you can now write Eclipse plug-ins for Domino Designer on Eclipse (DDE) 8.5 and above, taking advantage of a variety of Eclipse and DDE extension points to add functionality for both UI and back-end logic.

Image:The View article: Add LSDoc Support to Domino Designer on Eclipse with Custom Plug-ins (download link included)

Using Eclipse APIs, you can create a wide range of helpful tools, like the batch processing of design elements and one-click imports of frequently used script libraries. You can even customize Designer’s user interface - for example, add your own design element properties to the property panel (like the width and height in pixels of image resources).

We’ll provide a useful example of using Eclipse APIs to enhance DDE as we take you through the steps for integrating LotusScript doc (LSDoc) support into DDE. LSDoc is a very popular development tool created by Mikkel Heisterberg that generates well-formatted code documentation for LotusScript, similar to Javadoc for the Java language. Version 2 of LSDoc has been completely rewritten in Java, so it integrates better into the Java-based Eclipse world - it is faster, scales better with large database designs, and it can be seamlessly used in Eclipse plug-ins.
LSDoc generates HTML files for LotusScript documentation and stores them in a Notes database. However, it does not provide a mechanism to display those files. The files are served by the local Web preview of DDE, which requires Anonymous access to the LSDoc database; otherwise, the LSDoc database needs to be placed on a Domino server, which is not an option if you need to use LSDoc offline. In addition, there is no direct integration into Domino Designer yet. The documentation has to be opened in a separate browser window.

We’ll show you how you can solve these two issues by creating a new DDE/Eclipse feature that carries its own Web server and displays the LSDoc content for the currently selected design element in a new visual area of DDE, an Eclipse ViewPart.

Download link (source code and binary distribution):
DDE_LSDoc_Plugin.zip

Full article version (subscription required):
Article on eview.com

]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/22.07.2010223240KLES4H.htm http://blog.mindoo.com/web/blog.nsf/dx/22.07.2010223240KLES4H.htm?opendocument&comments XPages series #9: How to debug an XPages application Tue, 20 Jul 2010 09:49:53 +0200 http://blog.mindoo.com/web/blog.nsf/dx/20.07.2010094952KLEB7R.htm XPages Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/20.07.2010094952KLEB7R.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/20.07.2010094952KLEB7R.htm System.out.println's to track what the code of your XPages application is actually doing and why it is not working as expected? Life as a developer would be so much easier if there was a way to debug an XPages app while it is running.
Well, at least for code written in Java there is a solution.

Before we start, let me summarize which other options you have as an XPages developer to get runtime information about an application:

Writing log messages to the console or a log file/database
Of course you can manually collect the necessary information about the application state and write it to a log.  For client-side JavaScript logging, Firebug and console.log are your friends.
On the server-side, you can use System.out.println() in Java to write a message to the console. For server-side JavaScript, there is a command called _dump() that does the same. If you don't have your own private Domino server for development, you will then soon get a call from the administrator, because the server's log database is rapidly filled with funny log messages like "before method xyz", "after method xyz" or another popular syntax: "method xyz.1", "method xyz.2", "method xyz.3" to see whether specific lines in your code are executed or skipped for a certain set of input parameters (of course, we never do that! ;-) ).
You should at least use some global debug switches to quickly enable/disable debugging. Otherwise, moving an application to production and removing all those debug prints when the app is ready for prime time can be a lot of work.

To not stress the administrator too much, you should use more advanced variants of this technique that do not write to the console, but make use of a dedicated log database or send status messages via email to the developer.  The TaskJam template contains a SSJS library that generates log records for the popular OpenLog project of Julian Robichaux (Java classes to do the same are available as part of the project).
Tommy Valand has written a helper function to send debug messages via email.

Analyzing the XPages component tree
For more advanced XPages applications, writing simple status messages to a log is often not enough. You need detailed information about how the XPage is stored in the server memory. For example, if your XPages contain dynamic elements like repeater controls that create part of the UI at runtime or - even more powerful - you generate the whole component tree on the fly in your code, it's very hard to find out why an application is behaving unexpectedly.
The Medusa project of Nathan Freeman, Tim Tripcony and Colin Macdonald can help you in this case. In short, it provides a Firebug plugin that lets you examine the server-side component tree (see the screenshot section of the Medusa project page for more details), e.g. to check whether a link has any server-side event code attached at all.

Debug library code outside of XPages/Lotus Notes
When you write a lot of application code in Java, a smart approach is to make most of it work outside of an XPage or even outside of a Lotus Notes context. That way, you can easily debug your library code in Eclipse and you can even build test cases for test-driven development.
Unfortunately, there is no easy approach for SSJS debugging. There might be a way to build your own runtime environment using a JavaScript engine like Rhino, but we haven't really invested much time in that area, because most of our SSJS code is just directly calling bean methods in Java.

What is missing?
Looks like we already have a lot of options for logging and debugging. We have more for logging than debugging though, and there is no way yet to watch Java code while it is being executed on the server. That's exactly what this article is about.

Now why is this important? At first, you save a lot of time, because you don't have to blow up your code with dozens of println's to track a specific issue, and remove all of them again after the issue has been resolved.
And if you need to know more about complex objects and data structures, it's pretty hard to serialize them and print all parts to the log. Finally, in case of memory profiling and searching for memory leaks, it's a lot easier to just set a breakpoint in the code and examine which Java objects are stored in the server memory than trying to dump all that information to a log, if possible at all.

Requirements for debugging
Well, to be able to debug Java code, the Java Virtual Machine that is running the code, must be running in debug mode. Pretty logic, isn't it? In addition, you need to have the source code of something that you would like to debug, on the one hand to define the breakpoint position and on the other hand, because the debugger has to show something to tell you what is being executed.

The best solution
Our first idea was: What if we could launch the Domino server as a target platform from Eclipse, just like we do with the Notes Client or Domino Designer (DDE)? Then we could bring the JVM in debug mode and it would stop when a breakpoint in the code is reached. That's a similar approach to working with the Eclipse EE development environment, where Eclipse launches an embedded Tomcat server with a servlet configuration.
Unfortunately, we don't know (yet) how to do this, because the Domino server is a bit more than just a few Java classes.

Our solution :-)
But, as I said above, we do know how to launch the Notes Client from Eclipse (with installed Expeditor). And since the Lotus Notes Client is able to serve "XPages in the Client" since release 8.5.1, it should be possible to debug the executed Java code in an XPages app. And in fact, it really is.
We tried it and it worked, but when you launch Notes from Expeditor, you have to choose between launching the Notes client or DDE. Both cannot run at the same time, which is bad if you want to make small adjustments to your XPages application.

There is an even simpler solution that does not require installing the Expeditor toolkit: Eclipse Remote Debugging.

Launching Lotus Notes with enabled Remote Debugging
This technique was inspired by a blog article of Bob Balfe that he wrote back in 2008: Lotus Notes can be launched in a special mode that makes it possible to connect to a running Notes Client from Eclipse.
You can find detailed setup instructions on Bob's blog. Unfortunately, the picture links are broken, but you should get the idea what you have to do make it work.

The calling syntax for Lotus Notes from his blog entry has slightly changed since 2008. Here is the syntax that works for release 8.5.1 and (most probably) 8.5.2:

C:\Program files\IBM\Lotus\Notes\framework\rcp\rcplauncher.exe -config notes -debug -console -vmargs -Xdbg:transport=dt_socket,suspend=n,server=y,address=8000 -Xss512k

Please note how we specify the port (8000) at the end of the line. We need to use the same port when we now create a new debug configuration in Eclipse (we're using version 3.4.2):

Image:XPages series #9: How to debug an XPages application
Debug configuration for remote debugging of Lotus Notes

While Lotus Notes is running in debug mode, we can now connect to its JVM from our Eclipse IDE.

You should now add Java projects to Eclipse that contain the Java code that you execute in your XPages application and set a few breakpoints.
When you add the Java projects, Eclipse might complain about unresolved dependencies to classes of Expeditor, Notes or DDE.
Here is a collection of JARs that might be needed as part of the classpath (depending on your Notes configuration, you need to modify the version numbers).
  • C:\Program files\IBM\Lotus\Notes\jvm\lib\ext\Notes.jar
  • C:\Program files\IBM\Lotus\Notes\framework\shared\eclipse\plugins\com.ibm.designer.lib.jsf_8.5.1.20090926-0124\lib\jsf-api.jar
  • C:\Program files\IBM\Lotus\Notes\framework\shared\eclipse\plugins\com.ibm.xsp.core_8.5.0.20100318-1445\lwpd.xsp.core.jar
  • C:\Program files\IBM\Lotus\Notes\framework\shared\eclipse\plugins\com.ibm.xsp.designer_8.5.0.20090926-0124\lwpd.xsp.designer.jar
  • C:\Program files\IBM\Lotus\Notes\framework\shared\eclipse\plugins\com.ibm.xsp.domino_8.5.1.20100318-1445\lwpd.xsp.domino.jar
  • C:\Program files\IBM\Lotus\Notes\framework\shared\eclipse\plugins\com.ibm.xsp.extsn_8.5.1.20100318-1445\lwpd.xsp.extsn.jar

Launching the XPages application
To launch the application, you can either choose an XPage in the Notes launch settings of the database or create a Composite Application, e.g. with one component that either shows the XPage itself or a component created for the XPage. Regarding the latter: there is an article in this blog with a demo video from IBM how to do it.

Image:XPages series #9: How to debug an XPages application
Choosing an XPages as launch option

Hijacking XPages
For every XPage displayed in the Notes Client, the Client starts a new local HTTP server instance that will be running until you close the XPage tab. That server is running on a randomly chosen port number and the Notes client uses a unique ID in the URL to authenticate the browser:

http://127.0.0.1:2711/xsp/path%5Cto%5Cdb.nsf/xpageName.xsp?SessionID=ID0-35c463d059feb800

Ever read that URL from JavaScript (document.location.href) and tried to use it in the system browser? Works like a charm.

So in case your XPages apps are not running well in the Notes Client, because its XPages viewer blocks popup dialogs or does not display things like rounded corners via CSS properly etc., you can also open that URL in any other browser. It will be served locally by the HTTP server instance of the running Lotus Notes client. The Notes Client acts like a Domino server (and you don't need to open up the ACL for anonymous access like you have to do for the XPages preview in DDE).

To make the process of opening a running XPages application in the system's default browser a lot easier, we have developed a small helper Eclipse plugin that shows up as a new toolbar icon in the Notes Client:

Image:XPages series #9: How to debug an XPages application
Toolbar icon to launch an XPage in the system browser

The code behind the toolbar action is actually very easy. It reads the currently displayed XPages url, strips a few query string parameters and calls an Eclipse method that opens the URL in the default browser.
Here is a ZIP file with an update site and the source code:
A word about security exceptions
You might see ECL security exceptions, if you are using "restricted" operations in your Java code, for example such dangerous things like XML parsing. ;-). This issue is discussed in another block article.
Remember that it's still the Notes Client that serves the XPages, although you are using them in the system browser.
As a temporary workaround, this can be solved by appending the following code to the java policy file located in C:\Program files\IBM\Lotus\Notes\java.policy:

grant {
      permission java.security.AllPermission;
};

This completely disables any security restriction that is active for XPages code (Eclipse plugins are not affected by the security manager anyway), so be careful with it!

Summary
The demonstrated approach is a workaround for debugging XPages backend Java code, for which there is no officially available solution from IBM yet. By launching the Lotus Notes client with enabled remote debugging, we were able to connect from an external Eclipse IDE and debug custom backend Java code of an XPages application.
Hopefully, IBM will someday provide a better solution, for example by transforming the Domino server into a standard Eclipse target platform that can be directly launched from Eclipse.

At Lotusphere 2010, IBM announced that XPages in the upcoming Lotus Notes release 8.5.2 can be extended with custom OSGi/Eclipse plugins, e.g .in order to split up the business logic of a large enterprise application into small extensible modules.
With some slight modifications, the demonstrated approach should also work in that scenario, but running a Domino server directly from Eclipse would further speed up the process of developing, deploying and testing code.

]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/20.07.2010094952KLEB7R.htm http://blog.mindoo.com/web/blog.nsf/dx/20.07.2010094952KLEB7R.htm?opendocument&comments Fast Notes view reading via C API Part 2: How to read views 99.7% faster than Notes.jar Sun, 25 Apr 2010 23:52:56 +0200 http://blog.mindoo.com/web/blog.nsf/dx/25.04.2010235255KLETNN.htm Notesdev Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/25.04.2010235255KLETNN.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/25.04.2010235255KLETNN.htm first one about using the C API to read Notes view data instead of the Notes Java API provided by the Notes.jar file.

Disclaimer
You will see some incredible numbers in this article. Be sure, that we double checked them. This is no fake, although it looks like one. :-)

Testing our approach on a server
In the first article, we compared the execution times of the C code with the Notes.jar performance in a test case of reading 15.000 view entries from a local database. The result was 0.93 seconds for the C version and 2.8 seconds for the Java API. Pretty nice. That's a third of the execution time of Notes.jar, but we discussed that this may only make sense in cases where you really have a lot to read, e.g. several thousands of view entries, because there is some initialization overhead for creating a second Notes session and opening the database and view.

So far, we only had done tests on the local machine and we were curious how well our code would work on a server database.
Our test server is one of our development machines, which is hosted at an internet service provider and has a 100 mbit connection to the internet. Our home office internet connection speed is 15224 kbit/s downstream and 1164 kbit/s upstream.

Reading all the view entries using Notes.jar gives us a good opportunity to look for some coffee. It takes 856735 ms, which is more than 14 minutes. There is no passthru server in between. The results were even slower when we were testing with a passthru server and a 1,5 mbit server connection.

Our code looks like this:

        Session session=NotesFactory.createSession();
        Database db=session.getDatabase(serverName, dbPath);
        View v=db.getView(viewName);
        v.setAutoUpdate(false);
                       
        ViewEntryCollection entryCol=v.getAllEntries();
        ViewEntry entry=entryCol.getFirstEntry();
        while (entry!=null) {
                if (entry.isValid()) {
                        Vector colValues=entry.getColumnValues();
                        //
                        //... code to dump the values to stdout
                        //
                }
                ViewEntry nextEntry=entryCol.getNextEntry();
                entry.recycle();
                entry=nextEntry;
        }
        session.recycle();

So let's see how long our C approach takes... With the implementation of our first article, it takes 433337 ms, which is half the time - 7 minutes. Not bad, but still enough time for coffee.

Reading more than one view entry at a time
We were really surprised when we saw that result. We had expected that IBM might have added some caching technologies to read more than one view entry at a time, to optimize throughput on the slow network connection. But our C code was still a lot faster than their approach, and it only read one entry, reported it to our Java code via JNI and then it read the next one.

But there was still some room for improvement in our solution.
The C API function NIFReadEntries that we are using to read the data has a parameter to tell the API how many rows should be returned, as long as the provided buffer size is sufficient (we let Notes choose the buffer size for now). Until now, we were using a fixed value of 1. In the next version, this parameter is configurable.

No time for coffee anymore :-)
So here are the results, all for reading 15.000 view entries via the C API on a server database with different NIFReadEntries parameter values.
Again, this is no fake. The numbers are absolutely reproducible:

Maximum entries to read in NIFReadEntries Duration
1 433337 ms
10 44801 ms
100 5960 ms
1000 2552 ms


We are down from 7 minutes to 2,5 seconds just by changing one single parameter in the NIFReadEntries call!

Performance gain for local environment
Reading more than one line at a time also speeds up the already fast local access times:

Maximum entries to read in NIFReadEntries Duration
1 968 ms
10 606 ms
100 587 ms
1000 573 ms


Reducing CPU load
We did some tests to search for memory leaks in our code, in which we read the view about 1000 times. We found out that the CPU load can be reduced from 50% to 5-8% just by doing a Thread.sleep(1) every 200 rows in the Java code. This increased the execution time from 0,5s to 1s.

Conclusion
We could not believe our eyes when we saw those results. How on earth can reading a view be 99,7% (335 times) faster using C instead of Notes.jar? 14 minutes used for ECL checks and synchronize blocks? That's impossible.

]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/25.04.2010235255KLETNN.htm http://blog.mindoo.com/web/blog.nsf/dx/25.04.2010235255KLETNN.htm?opendocument&comments Fast Notes view reading via C API: A comparison C vs. Notes.jar Wed, 31 Mar 2010 22:09:36 +0200 http://blog.mindoo.com/web/blog.nsf/dx/31.03.2010220936KLERN4.htm Notesdev Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/31.03.2010220936KLERN4.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/31.03.2010220936KLERN4.htm
About 1,5 weeks ago, Nathan Freeman wrote a blog posting about the hidden NAPI plugin in Lotus Notes 8.5.1 that IBM uses to speed up the XPages framework. NAPI is an unsupported and incomplete set of Java classes that use JNI technology (Java Native Interface) to leverage functions of the Notes C API, for example to read data from a Notes view.

According to Nathan's speed race video, the NAPI classes are much faster than using the classic Notes Java API inside the Notes.jar archive. To read 15.000 view entries, NAPI takes 1 second where Notes.jar is running for 6 seconds - a pretty impressive result.

Last week, inspired by his comparison, we decided to develop our own C/JNI code. Of course, we like nothing more than writing C and it was a question of honour not to use IBM's NAPI plugin. :-)

No, just kidding. Our use case was a bit different. NAPI is an Eclipse plugin, but we needed a solution that also runs in standalone Java applications.

A few days of fun with NIF'ty things like NIFOpenCollection, NIFGetCollectionData or NIFReadEntries later, we now have our own working solution.

The result
We took Nathans test database with 15.000 documents to measure the performance of the different solutions. Our test code is executed from the Eclipse IDE as a small standalone application, we did not build an Eclipse plugin for it yet.
The view looks like this:

Image:Fast Notes view reading via C API: A comparison C vs. Notes.jar

Three columns with text, one hidden sort column with the severity as number.

Traversing the view and reading all column values using Notes.jar takes 2.8 seconds on our desktop test machine (Intel Core2Duo, 3 GHz, 4 GB RAM. WinXP VM in Vista)
Please note that our test code is running exclusively in the JVM. This may explain the gap to Nathan's 6 seconds, his four test cases run in parallel which probably slows down I/O throughput, causes synchronization losses in the API and splits the CPU power.

Speed of our C/JNI solution
For the same scenario, the C/JNI approach only takes 0.93 seconds. You can even save more time by reducing the columns to be read. In contrast to Notes.jar, where you just have ViewEntry.getColumnValues(), which decodes all columns in a row, by using the C API you have to decode each column separately (e.g. to convert Notes LMBCS strings to Java's Unicode format).
For example, if you decide to only decode one column, let's say the last one, the duration drops to 0,8 seconds. If you are just interested in the sort order of documents, you might only read the Note ID and skip the column decoding, which results in 0,7 seconds.

Drawbacks
0,93 seconds instead of 2,8 sounds pretty dramatic, but we need to keep in mind that we are not reading 10 or 100 view entries, but 15.000. So for normal lookup operations, this solution is probably an overkill. Especially because in a hybrid scenario (where most operations are done in Notes.jar, but view reading in C/JNI) we need to create a second session and may open the database and view twice, which obviously consumes some time.

However, it looks like there is a good use case for the JNI approach in scenarios where a lot of processes access Notes data in parallel, for example on a Domino web server or in the Lotus Notes Standard Client with a lot of plugins that use Notes APIs.

In those cases, Notes.jar turns out to be a performance bottleneck, because it does not directly wrap the C API functions, but is based on the "Lotus Software Extension Backend (LSXBE)", which does not handle multithreading very well from a performance perspective.

Image:Fast Notes view reading via C API: A comparison C vs. Notes.jar

Click here to read the second article about C API vs. Notes.jar - how to speed up view reading by the factor 335.
]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/31.03.2010220936KLERN4.htm http://blog.mindoo.com/web/blog.nsf/dx/31.03.2010220936KLERN4.htm?opendocument&comments LS10/EC10 session sample #2: Adding custom properties to DDE design elements Thu, 11 Mar 2010 18:00:51 +0200 http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010180051KLEMY4.htm DDE Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010180051KLEMY4.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010180051KLEMY4.htm Lotusphere and Entwickercamp sessions is an add-on for Domino Designer on Eclipse.
(I changed the order of the samples, because we need to work on a few others before we can publish them)

As a long time web developer for the Notes/Domino platform, I have always missed one Designer feature a lot: There was obviously no easy way to get the pixel dimensions of image resources.
My workaround was to extract the image to disk, open it in an image viewer and write down the width and height. A real pain.

But now, that Domino Designer is based on the Eclipse platform, things have changed. Developers don't have to wait any more for IBM to implement a specific new feature. They can just create they own Designer add-ons!

By leveraging the Eclipse APIs and new Domino Designer extensibility APIs we were able to build a small helper plugin, that hooks directly into the properties pane of DDE:

Image:LS10/EC10 session sample #2: Adding custom properties to DDE design elements

There are no methods in the DDE API to add such a section. It's basically an API that lets you convert the standard Eclipse selection into Designer specific classes. It offers some basic set/get methods for design elements and refresh methods to notify DDE that the design has been changed, e.g. by a DXL import using the backend Notes classes.

But fortunately, IBM built DDE right on top of Eclipse and made use of standard Eclipse property panels for the design properties.
Those panels can be extended by plugins with the following XML code:

< extension point="org.eclipse.ui.views.properties.tabbed.propertySections" >
        < propertySections contributorId="com.ibm.designer.domino.navigator.panels" >
                < propertySection
                        afterSection="com.ibm.designer.domino.navigator.panels.image.basic"
                        enablesFor="1"
                        class="com.mindoo.dde.imageproperties.WebImageSizeSection"
                        filter="com.mindoo.dde.imageproperties.ImagePropFilter"
                        id="com.ibm.designer.domino.navigator.panels.image.websize"
                        tab="com.ibm.designer.domino.navigator.panels.file.basic" / >
        < /propertySections >
< /extension >

It adds a custom section to an existing property panel. In this case, we are adding it to the "basics" panel and use a filter to hide it if no image resource is selected:

package com.mindoo.dde.imageproperties;

import org.eclipse.core.resources.IResource;
import org.eclipse.jface.viewers.IFilter;

import com.ibm.designer.domino.ide.resources.extensions.DesignerDesignElement;
import com.ibm.designer.domino.ui.commons.extensions.DesignerResource;

public class ImagePropFilter implements IFilter {
        public boolean select(Object paramObject) {
                if (paramObject instanceof IResource) {
                        IResource resource=(IResource) paramObject;
                        DesignerDesignElement designElement=DesignerResource.getDesignElement(resource);
                        if (designElement!=null) {
                                String deType=designElement.getDesignElementType();
                                if (DesignerResource.TYPE_IMAGE.equals(deType))
                                        return true;
                        }
                }
                return false;
        }
}

When the selected image changes, the implementation class schedules a background job that grabs the DXL content of the image's design element. It converts the base64 encoded DXL content to a byte stream, uses Eclipse API methods to load the image, reads the width and height and displays them in the specific fields of the "Image size in px" area.
Since we are doing this in a background operation, the DDE UI is still responsive.

If you are asking yourself where to get those internal section IDs from, I highly recommend you to take a look at the plugin.xml file of the DDE plugin "com.ibm.designer.domino.navigator" in the "framework/shared subfolder" of your Notes program directory. :-)

Finally, here is the plugin source code and an update site to install from:

]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/11.03.2010180051KLEMY4.htm http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010180051KLEMY4.htm?opendocument&comments Entwickercamp 2010: our slides about add-ons for Notes Client and Domino Designer 8.5.1 Thu, 11 Mar 2010 12:42:31 +0200 http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010124229KLEFR6.htm Entwicklercamp 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010124229KLEFR6.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010124229KLEFR6.htm Julian Buss and Ulrich Krause already blogged, Entwicklercamp 2010 (developer camp), taking place this week from Monday to Wednesday, was a really well organized conference.
It was great to meet with other developers and business partners and there were a lot of high quality sessions, mainly focused on XPages for web and Notes Client and Java/JavaScript development. Good to see that more and more developers and end users get interested in the new possibilities.

Thanks to Rudi Knegt and his team for all their work organizing the event!

This blog posting contains the slides of my session about add-on development for Notes Client/Domino Designer, leveraging new Java APIs of Notes/Domino 8.5.1.

Actually, I did not only present the session once. I did three full session runs, one on Monday and two on Tuesday, because two Entwicklercamp participants had a conflict with other sessions, but were highly interested in the topic. So we had two additional one-on-one presentations including the whole demo show. The feedback for all three sessions was very positive. They even changed the room for the session (track 2 instead of track 4), because there were a lot more reservations for the session than expected.

Fortunately, I had more time to present than at Lotusphere in Orlando (90 minutes instead of only 60), so I could present all of the 10+x demos that we had developed. In Orlando, we had to skip a few of them.
The demos will be published one by one here in the blog. The first one is already posted: it's the bookmark tools plugin that adds context menus to the client's Open List.

So here are the slides in German language:

Image:Entwickercamp 2010: our slides about add-ons for Notes Client and Domino Designer 8.5.1


]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/11.03.2010124229KLEFR6.htm http://blog.mindoo.com/web/blog.nsf/dx/11.03.2010124229KLEFR6.htm?opendocument&comments LS10/EC10 session sample #1: Notes Bookmark tools Sat, 30 Jan 2010 15:43:12 +0200 http://blog.mindoo.com/web/blog.nsf/dx/30.01.2010154312KLEKA4.htm Entwicklercamp 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/30.01.2010154312KLEKA4.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/30.01.2010154312KLEKA4.htm Lotusphere session about the Java APIs of Lotus Notes 8.5.1. And it's already the first one that we did not  actually show at Lotusphere, because we ran out of session time in our rehearsals and felt the need to reduce the amount of live demos.

The sample plugin is called "com.mindoo.bookmarktools". It adds two actions to the Open List of Lotus Notes:

Image:LS10/EC10 session sample #1: Notes Bookmark tools

Locate on workspace
This action uses the methods NotesUIWorkspace.addDatabase(NotesDatabaseData) of the new UI API, but instead of adding databases to the client's workspace, it actually only leverages the fact that addDatabase selects already existing databases and opens the right workspace tab.
As you may know, we are the developers of the MindPlan application (mindmapping and project management based on Lotus Notes). That's why my Open List looks like this when I'm searching for the keyword "mindplan" in my bookmarks:

Image:LS10/EC10 session sample #1: Notes Bookmark tools

Sometimes you want to know where a specific database is located on your workspace. One way is to open the database in the client and then switch to the workspace, where in most cases the right database chicklet is selected. That takes a lot of time in case the database needs to be loaded from a server. And sometimes opening the database does not really help to find it on the workspace, for example if the database opens a frameset that displays a view of your mail database. In that case, it's the mail database that is selected on the workspace, not the database with the frameset.

This new action helps in this case.

Open as workspace
The second action "Open as workspace" is something that you might know from older Notes Clients, e.g. from version R7. You could right click on a bookmark and select "Open as workspace". This would open a new tab that displays the bookmark folder content as chicklets like this:

Image:LS10/EC10 session sample #1: Notes Bookmark tools

Well, although this feature has not been officially implemented in the 8.x Standard Client (the was some discussion whether it should return in 8.5.2, but IBM decided to keep it out of the Standard Client), there is a way to open the workspace view for a bookmark folder.

Actually, it's pretty simple:
You may know that the Notes URL "notes:///ClientBookmark?OpenWorkspace" opens the normal workspace tab.
All you have to do is add a query parameter "id" to that URL: "notes:///ClientBookmark?OpenWorkspace&id=0". That ID is the internal bookmark folder id. The id 0 tells the workspace viewpart to display the first level of your open list (e.g. with your mail, calendar and a chicklet to start Domino Designer).
I haven't found out so far where the other id's come from (just checked the design of the bookmark.nsf, but it's no obvious ID of the folders design elements). But by using some internal Notes functions, we are able to grab the folder id when you right click on an Open List entry and launch the corresponding Notes URL.

So, what to do with this second action? I don't know. :-)
My first thought was to use this special Notes URL in a Composite Application, something like my personal start page for the Notes Client. You can for example use the Notes Document Container to display this URL and send URL changes to the "SetNotesDocumentURL" action to switch between several workspace folders. In my first tests, quickly changing this URL did not appear very stable (the client crashed) and I did not look into this any further.

Anyway, here are the source code for this sample and an update site for the installation (please refer to this article if you don't know how to install from an update site). ]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/30.01.2010154312KLEKA4.htm http://blog.mindoo.com/web/blog.nsf/dx/30.01.2010154312KLEKA4.htm?opendocument&comments I will be presenting a session about the new Java APIs of Lotus Notes 8.5.1 at the German Entwicklercamp conference (Developer camp) Thu, 28 Jan 2010 07:30:23 +0200 http://blog.mindoo.com/web/blog.nsf/dx/28.01.2010073023KLE9N3.htm Entwicklercamp 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/28.01.2010073023KLE9N3.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/28.01.2010073023KLE9N3.htm The topic is Add-ons for Notes Client/Domino Designer based on new Java APIs of Lotus Notes 8.5.1 (track 4, session 5 in the session list).
It's similar to our Lotusphere session, so if you missed it at Lotusphere, make sure to not miss it again. :-)

The Entwicklercamp is an annual conference taking place from 8th to 10th of March in Gelsenkirchen, Germany, with a well known list of both national and international speakers and a lot of high-quality developer sessions.
You can find more information on the Entwicklercamp website. Unfortunately it's only available in German language, but maybe Google translator will help you out if your German needs some training. ]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/28.01.2010073023KLE9N3.htm http://blog.mindoo.com/web/blog.nsf/dx/28.01.2010073023KLE9N3.htm?opendocument&comments Our Lotusphere 2010 slides: BP203 - Leverage the New Java APIs in IBM Lotus Notes 8.5.1! Mon, 25 Jan 2010 00:41:24 +0200 http://blog.mindoo.com/web/blog.nsf/dx/25.01.2010004124KLEVSF.htm Lotusphere 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/25.01.2010004124KLEVSF.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/25.01.2010004124KLEVSF.htm All the feedback evaluations where either "Excellent" or "Good" and in addition, we also got personal feedback from 4-5 participants (even in the bus to the Hollywood studios on Wednesday) who especially liked the fact that we showed so many demos.

Well, to be honest, we even planned and developed more demos than we actually could show. We decided to remove some of them when we were doing a test run in the hotel room and easily exceeded the session limit of 60 minutes. :-)
If you look at the original BP203 slides that we submitted back in December and compare them to the presented slides, you will notice the missing pieces.

Since removing some of the demos was a last minute decision, all of them were already developed and running. So we plan to publish them in this blog in the next few weeks. Simply publishing the code would not help you much to learn about the Eclipse/Expeditor platform. That's why we will explain them in detail, each demo in its own blog article.

Let's start this demo article series with the session slides. Click on the image to download the PDF file:

Image:Our Lotusphere 2010 slides: BP203 - Leverage the New Java APIs in IBM Lotus Notes 8.5.1!


]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/25.01.2010004124KLEVSF.htm http://blog.mindoo.com/web/blog.nsf/dx/25.01.2010004124KLEVSF.htm?opendocument&comments Our LS10 session offering on Wednesday: BP203 - new Java APIs in 8.5.1 with up to 10 demos, 2 undocumented Notes functions and Lotusscript like you have never seen it before Wed, 20 Jan 2010 00:26:26 -0400 http://blog.mindoo.com/web/blog.nsf/dx/20.01.2010002624KLE8E3.htm Lotusphere 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/20.01.2010002624KLE8E3.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/20.01.2010002624KLE8E3.htm Instead of showing too many technical details, our plan is to focus on real-life scenarios for the new APIs.

We have created a collection of up to 10 demos for both APIs, including
  • a universal help system for the Notes sidebar that provides information for the current database, form and field
  • an integration of Mikkel Heisterberg's LotusScript.doc into Domino Designer
  • an alternative picture based address selection dialog for emails that can be used without modifying the mail template

and we'll demonstrate ways how LotusScript code can communicate with the Eclipse framework to leverage the new API functionality as well.
This will include an application that uses multithreaded LotusScript - a new technology to move your long running LotusScript tasks into the background in order to make your Notes applications snappier.

Come and join us on Wednesday from 3:00pm - 4:00pm in DL S. Hemisphere III !

And please also join us on Thursday from 7:00am - 8:00am in SW Toucan 1 to share our experiences with Application Architecture based on Composite Application (BOF206).
]]> http://blog.mindoo.com/web/blog.nsf/dxcomments/20.01.2010002624KLE8E3.htm http://blog.mindoo.com/web/blog.nsf/dx/20.01.2010002624KLE8E3.htm?opendocument&comments Lotusphere announcement: LS2Eclipse - Leverage Eclipse/Expeditor features in your Lotusscript code! Mon, 11 Jan 2010 13:53:17 +0200 http://blog.mindoo.com/web/blog.nsf/dx/11.01.2010135317KLEH5D.htm Lotusphere 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/11.01.2010135317KLEH5D.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/11.01.2010135317KLEH5D.htm
  • You have Notes applications and want to bring them to the 21st century without rewriting everything in Java/JavaScript?
  • Your users often sit at their desk waiting for your Notes application because of a long running Lotusscript operation?
  • Composite Application technology looks interesting, but the Lotusscript APIs are not dynamic / powerful enough?
  • As a Lotusscript developer, you always hated it to hear those Java guys saying "That's easy. All you have to do is call this Eclipse API..." :-)
    • During our own Notes/Domino development in the past years, we often needed Eclipse API functionality in places where it was not available, like a classic view action, a form or an agent.
    New features always got added to the "outside world", the Eclipse/Expeditor framework, but the classic Notes client and the Lotusscript language nearly stayed the same over the years.
    While Java development for Eclipse/Expeditor has many advantages compared to classic form/view development of Lotus Notes, it surely makes development more complex and you loose the rapid application development approach that Lotus Notes made so successful.
    In addition, long-time Notes users have an existing code base of thousands of lines of code, that they cannot simply rewrite in Java/JavaScript to create a new Java UI or XPages based application.


    We think that there is a missing piece between classic Notes and the Expeditor framework of Lotus Notes R8.x. This is our main use case for Mindoo LS2Eclipse.

    Mindoo LS2Eclipse is a bridging technology that makes Eclipse APIs accessible from Lotusscript code.

    The following image is a rough overview of the LS2Eclipse architecture:

    Image:Lotusphere announcement: LS2Eclipse - Leverage Eclipse/Expeditor features in your Lotusscript code!

    The installation kit contains an Eclipse plugin (packaged as a widget for easy deployment) and a set of Lotusscript libraries.
    Those libraries with a rich set of about 50 object-oriented Lotusscript classes give you access to many powerful Eclipse features, divided into the following 7 areas:

    JobTools
    The JobTools area is a key feature of the LS2Eclipse API. It is the key to running your application code in multiple threads, thus making it possible to keep the user interface responsive even if a long-running operation (e.g. storing an email in a CRM system on a Domino server) is active.
    Your Lotusscript code runs as a so called Eclipse Job, a background process that can optionally display a progress dialog with status/progress information.

    Feature overview:
    • Bridge between the Eclipse job framework and Notes agents
    • schedule the execution of an agent as an Eclipse background job
    • pass parameters to the job
    • jobs can report progress and can be cancelled on user request
    • Notes UI is responsive when job is running, job may change the UI during execution (e.g. to present the result)
    PlatformUI
    The PlatformUI area let's you read and interact with the Eclipse workbench, which is the graphical framework that is displaying the Lotus Notes client.

    Feature overview:
    • Read the structure of open windows, tabs and their contents (Eclipse views)
    • focus tabs, show/hide/minimize/maximize views
    • Access the side shelf, show/hide shelf views and toggle the shelf between collapsed, thin and expanded
    • show text in the status bar of the Notes client and show message boxes (e.g. to display information from a background agent job)
    ComponentTools
    The ComponentTools contain a set of tool classes to make Composite Applications more dynamic.

    Feature overview:
    • call Composite Application actions of components manually without a CA wire
    • dynamically create and show content like Notes data or a web browser view
    • modify the properties of components
    • read and modify the structure of a Composite Application (component/page preferences)
    • toggle between CA pages in your code (e.g. to create a custom navigator)
    • locate open views in the workbench based on their internal ids
    NotesUITools
    This area contains features of the new Java UI API in Lotus Notes 8.5.1. With it you can interact with the Notes client user interface, even if your code is running in a background job, where the standard NotesUIWorkspace is not available. In addition, you are no longer restricted to the active area of the screen to read/write data from/to a view or a document.

    Feature overview:
    • gives you access to the Notes UI even when your code is running in a background job
    • get a NotesUIDocument/NotesUIView handle for any area (IWorkbenchPart) of the screen, not just the active one
    • modify the NotesUIDocument's content, read the current selection from a NotesUIView
    • activate a view/document in the current page
    PerspectiveTools
    In the Notes client, an Eclipse perspective is the content of a main tab. The perspective tools give you access to all registered tabs in the system and they even allow for the creation of completely new tab layouts.

    Feature overview
    • get list of registered Eclipse perspectives (IPerspectiveRegistry)
    • clone existing perspectives
    • create and display your own Eclipse tab layouts (IPerspectiveFactory/IPageLayout etc.) on the fly
    ProgramTools
    The program tools contain platform independent APIs to registered file extensions in the OS.

    Feature overview
    • find associated programs by file extension
    • get list of registered file extensions in the system
    • launch files and urls
    ExtensionRegistryTools
    Experts can use the ExtensionRegistryTools to add new Eclipse extensions to the IExtensionRegistry of the Eclipse framework.

    How does the code look like?

    We tried to name the Lotusscript objects similar to their corresponding Eclipse API objects. That way, you already know most of the important Eclipse APIs if you start coding in Java later on and searching for code snippets on the internet is made easier.
    To get a feeling for the API, here is a small code snippet:

    To create a new API connection, you use this syntax:

    Dim connection As EclipseConnection
    Set connection=EclipseConnectionManager.createConnection()

    To access the PlatformUI, type in this:

    Dim platfUI As PlatformUI
    Set platfUI=PlatformUIFactory.getInstance(connection)

    The IPartService is a class to get the currently active area (IWorkbenchPart) of the screen:

    Dim partService As IPartService
    Dim part As IWorkbenchPart
    Dim vpart as IViewPart
    Dim classes as EclipseAPIClasses
    Dim partTitle as String
    Dim partId as String
    Dim partSecondaryId as String

    Set classes=connection.EclipseAPIClasses 'helper to cast an object to another API object
    Set partService=platfUI.getWorkbench().getActiveWorkbenchWindow().getPartService()
    Set part=partService.getActivePart()
    If classes.IViewPart.isInstance(part) then
            'part is a IViewPart; this gives us additional properties
            Set vpart=classes.IViewPart.cast(part)
            partTitle=vpart.getTitle()        
            partId=vpart.getId()
            partSecondaryId=vpart.getViewSite().getSecondaryId()
    End If


    Where to get the API

    The API is feature complete, but we still have some documentation to write. For example, I'm currently working on a database with test cases that may be handy to learn about the new features.
    It currently contains the following 12 cases:
    • Case 1 - Workbench information
    • Case 2 - PartService, get information about the active viewpart
    • Case 3 - Viewparts in the current page
    • Case 4 - Schedule background agent jobs
    • Case 5 - Change the UIDocument in another viewpart
    • Case 6 - Get the selection from a Notes view in another viewpart
    • Case 7 - Create new NSF viewparts in the current page
    • Case 8 - Create new NSF viewparts in a different tab
    • Case 9 - Manually call actions of CA components (change content of a document container)
    • Case 10 - Create a new Eclipse perspective layout with placeholders for new views
    • Case 11 - Compare selected documents in a new Eclipse perspective
    • Case 12 - Toggle the sidebar mode between collapsed/expanded/thin
    If you are interested and will be attending Lotusphere next week, come to our session about the new Java APIs of Lotus Notes 8.5.1 (BP203) on Wednesday from 3:00 until 4:00 pm or wake up early on Thursday to join us in our birds-of-a-feature session about "Application Architecture based on Composite Application technology" (BOF206) from 7:00 until 8:00 am.

    I will post an info in this blog, when a trial version of LS2Eclipse is available.
    ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/11.01.2010135317KLEH5D.htm http://blog.mindoo.com/web/blog.nsf/dx/11.01.2010135317KLEH5D.htm?opendocument&comments     Our Birds-of-a-Feather session has been selected by the Lotusphere attendees! Thu, 10 Dec 2009 16:32:54 +0200 http://blog.mindoo.com/web/blog.nsf/dx/10.12.2009163254KLEL95.htm Lotusphere 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/10.12.2009163254KLEL95.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/10.12.2009163254KLEL95.htm Our session is one of those that they would most like to see on the agenda.

    This is IBM's description for this kind of session:

    Audience: Any and all Lotusphere attendees
    Description: Come one, come all! Birds-of-a-Feather sessions are a popular feature of Lotusphere, bringing together communities and individuals with similar interests. These sessions are informal, interactive discussion groups for like-minded attendees to share ideas and experiences in an small group, open forum setting.


    And here is our session abstract:

    Application Architecture based on Composite Application technology


    Composite Application technology builds a bridge between several worlds. With it you can transfer information between programming languages like Java and Lotusscript, fill Symphony spreadsheets with the contents of a Notes view, sent commands to host applications and even automate Windows applications.
    With the introduction of XPages for the Notes client, CA technology gains additional momentum, because they are the way to go, if you need interaction between your XPages application and the surrounding Notes client platform.
    We would like to share our experiences with Composite Application technology and discuss how an application architecture based on Composite Application technology could look like if you start designing it from scratch.

    We are really looking forward to Lotusphere and are heavily working on cool demos for our session about the new Java API's of Lotus Notes 8.5.1. ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/10.12.2009163254KLEL95.htm http://blog.mindoo.com/web/blog.nsf/dx/10.12.2009163254KLEL95.htm?opendocument&comments     One Lotusphere 2010 session approved! Tue, 17 Nov 2009 20:38:06 +0200 http://blog.mindoo.com/web/blog.nsf/dx/17.11.2009203805KLER2D.htm Lotusphere 2010 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/17.11.2009203805KLER2D.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/17.11.2009203805KLER2D.htm The title is:

    Add-ons for Client/Designer leveraging new Java APIs of Lotus Notes 8.5.1


    This is really cool, because it's our favorite topic. Those new APIs can be used for many small useful Notes and DDE add-ons and I'm sure we will have some nice giveaways for the session.

    See you in Orlando!
    ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/17.11.2009203805KLER2D.htm http://blog.mindoo.com/web/blog.nsf/dx/17.11.2009203805KLER2D.htm?opendocument&comments     XPages series #8: Dynamically creating the UI of an XPage in Java Tue, 10 Nov 2009 23:11:23 +0200 http://blog.mindoo.com/web/blog.nsf/dx/10.11.2009231122KLEU27.htm XPages Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/10.11.2009231122KLEU27.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/10.11.2009231122KLEU27.htm XPages series is more or less a link to a great blog posting that was just published my Tommy Valand.

    It demonstrates how you can create a dynamic web user interface by leveraging JSF features in your XPages application.
    In his example, Tommy produces a data table UIComponent with a snippet of Java code that is executed with the click on a button.

    Image:XPages series #8: Dynamically creating the UI of an XPage in Java

    I'm currently working on something similar for a customer project, but unfortunately I cannot say much about technical details at the moment.
    Basically, it's about dynamic application UI creation based on an abstract UI description. The system produces a dual-output: it dynamically creates the UI of an XPage, but it also creates a Java UI (e.g. a set of Swing components) with a similar form layout.
    Write once, run anywhere. :-)

    The concept includes its own data layer that works independent from Lotus Notes and has some fancy features like transaction logging (even for storing in Lotus Notes databases).

    I recommend that you take a look at Tommys posting and start thinking about your personal use case for this. Anything is possible.

    In my next blog series posting I'm going to write about my own bean manager for managed beans that I needed as a workaround for security limitations when running an XPages application in the Lotus Notes client. ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/10.11.2009231122KLEU27.htm http://blog.mindoo.com/web/blog.nsf/dx/10.11.2009231122KLEU27.htm?opendocument&comments     Today Mindoo joined IBM’s Design Partner program for Quickr 8.5 Wed, 4 Nov 2009 13:42:02 +0200 http://blog.mindoo.com/web/blog.nsf/dx/04.11.2009134201KLEGWC.htm Quickr Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/04.11.2009134201KLEGWC.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/04.11.2009134201KLEGWC.htm
    We would like to thank IBM for letting us participate! ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/04.11.2009134201KLEGWC.htm http://blog.mindoo.com/web/blog.nsf/dx/04.11.2009134201KLEGWC.htm?opendocument&comments     Speaking at Notesusertage 2009 (Notes user days, German conference) on the 5th of November - register until the 25th of October! Thu, 22 Oct 2009 21:49:23 +0200 http://blog.mindoo.com/web/blog.nsf/dx/22.10.2009214922KLER9E.htm Notesusertage 2009 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/22.10.2009214922KLER9E.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/22.10.2009214922KLER9E.htm Haus Weilgut in a parallel customer track.
    The first one is a pretty large XPages application framework (about 10 Java projects combined into one NSF). Let's call it a "UI generator", but it's actually a lot more than that.
    The second application is a quite powerful relational reporting engine for Lotus Notes data. Something like "NotesSQL2". :-)

    The Notesusertage conference is an annual German Notes conference located in Karlsruhe, Germany.

    Registration is open until the 25th of October. Conference fee is 69 Euro.

    Here is the German conference description from the Notesusertage website:

    Warum in die Ferne schweifen, wo das Gute doch so nah.

    Erfahren Sie, wie Sie konsequent Ihre Lotus Notes- und Domino-Plattform im Unternehmen ausbauen und tauschen Sie sich mit Gleichgesinnten aus.

    Die Notes Usertage treffen den Nerv der Zeit:
    Anhand praktischer Beispiele aus großen und mittelständischen Unternehmen lernen Sie neue Erweiterungsmöglichkeiten kennen, mit denen Sie Investitionen in neue Systeme und Schnittstellen vermeiden. Dabei bringen Sie Ihre Infrastruktur auf den Stand, den die aktuelle Rechtslage erfordert.

    Mehrwert mit Lotus Notes, das bedeutet:
    • unternehmensweites CRM
    • Wissens- und Projektmanagement
    • wirtschaftliche und rechtskonforme Archivierung von E-Mails
    • Kopplung mit ERP-Systemen
    • Ressourcenplanung
    • Optimierung mit Blackberry
    • schneller Zugriff auf Informationen
    • Reporting, Business Intelligence
    • ... und vieles mehr!
    Neue Funktionen, Module und moderne Technologien machen Ihr Unternehmen leistungsfähiger und helfen Ihnen, vorhandene Ressourcen besser zu nutzen. ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/22.10.2009214922KLER9E.htm http://blog.mindoo.com/web/blog.nsf/dx/22.10.2009214922KLER9E.htm?opendocument&comments     XPages series #7: Running under a restricted Java context - or: Why doesn’t my XPages application work in the Notes Client?! Wed, 21 Oct 2009 14:25:51 +0200 http://blog.mindoo.com/web/blog.nsf/dx/21.10.2009142550KLEGL7.htm XPages Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/21.10.2009142550KLEGL7.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/21.10.2009142550KLEGL7.htm As long as they only contain program code in JavaScript and a few simple Java routines, you will probably have succeeded. Your application looks quite the same as on the web and you can now begin to tweak the UI with a client-specific theme and enhance the application features by integrating it into a Composite Application.

    Any visual issues?
    If there are any visual issues (for instance I heard about dojo dialog boxes not resizing as expected, but haven't tested yet), keep in mind that the 8.5.1 Notes Client uses Xulrunner version 1.8.1.3 to display the XPages, which is the render engine of Firefox 1.5 as far as I know. So make sure to have everything you do compatible with that "nearly recent" Firefox version. ;-)
    (the Xulrunner executable is located in the folder \framework\rcp\eclipse\plugins\com.ibm.rcp.xulrunner.runtime.win32.x86_6.2.1.20090925-1604\xulrunner)
    It should be possible to do that (1.5 was already quite powerful), although I'm a bit confused because this page says that the dijit widgets are only supported in Firefox 2+x. But I saw at least the dijit tabbedpane work without problems in one of my apps.

    Java execution errors?
    Let's say that you followed this blog series and did your homework. You have tried to use JSF managed beans in your application, understood the concept and like it.
    Well, then you may have already seen this Java exception thrown in a few methods, for example in those that call our JSF managed bean helper class:

    javax.faces.FacesException: java.lang.SecurityException: ECL Permission Denied
       com.sun.faces.application.ApplicationAssociate.createAndMaybeStoreManagedBeans(Unknown Source)
       com.sun.faces.el.VariableResolverImpl.resolveVariable(Unknown Source)
       com.ibm.xsp.el.VariableResolverImpl.resolveVariable(Unknown Source)
       com.sun.faces.el.impl.NamedValue.evaluate(Unknown Source)
       com.sun.faces.el.impl.ExpressionEvaluatorImpl.evaluate(Unknown Source)
       com.sun.faces.el.ValueBindingImpl.getValue(Unknown Source)
       com.sun.faces.el.ValueBindingImpl.getValue(Unknown Source)
       com.acme.tools.JSFUtil.getBindingValue(Unknown Source)

    When I first saw this, I yelled something comparable to "Interesting! How fascinating! A welcome challenge for me!". Ok, maybe less polite ;-).

    That was 2-3 days ago. Since then, I did some research and testing to find out what is causing this problem and how to deal with it.
    I'd like to share it with you.

    The Domino Server - a secure environment
    So far, we did our Xpages development on a Domino server. We were allowed to do this, because our administrator granted us developer rights on a database on the server, and he gave us the power to execute our code on that machine. He does not allow anybody to do this. He knows us and trusts us.

    Controlling access in the Notes Client
    It's a slightly different situation for the Notes client. A Notes user could download a Notes database with malicious code from anywhere on the internet.
    That's the reason why there is an Execution Control List (ECL) in the client to restrict what applications may do on the user's workstation. Critical operations like accessing the machine's filesystem need to be confirmed (trusted) by the user - and the administrator can prevent Notes users from easily trusting anyone.
    The ECL is not a new invention. It's been in the client for many years and controlled the program code of forms, views, agents and other design elements.

    For Eclipse plugins extending the Lotus Notes Standard client, there is no such thing as an ECL (because Eclipse does not have it), only the installation of plugins can be controlled by policy.
    This has produced a lot of discussion about the security of Eclipse plugins.

    Security for local Xpages
    For the first implementation of XPages in the Notes client, IBM chose a more conservative security model. The Java programming language has a built-in security system, called the SecurityManager, that IBM connected to the ECL system of Lotus Notes. Everything that is not connected to the ECL system of Lotus Notes, is considered insecure and is therefore denied.

    Java developers may already know the impact of the SecurityManager when they try to do restricted operations (like accessing files) in Java applets. They just don't work.

    So that's what happens behind the scenes in our method "JSFUtil.getBindingValue(String)". It calls JSF functions and deep in the calling tree, there is a restricted method and the JVM says "no".

    The good news
    The administrator does not have to worry about end users that download and open XPages applications from the web.

    The bad news
    The developers and ISVs have to worry about what their application code is allowed to do and how to deal with the restrictions.

    What is allowed?
    Here is a table with the available classes of allowed Java operations and their equivalent ECL levels in Notes 8.5.1:

    Java PermissionNote Client ECL Access (Workstation)
    java.util.PropertyPermissionEnvironment variables
    java.io.FilePermissionFile system
    java.net.SocketPermissionNetwork

    (plus using the Notes Java API)

    Calling a Java operation that needs one of these permissions results in a Notes ECL confirmation dialog if the XPage's signer is not trusted. Any other restricted Java operation that is not listed in the table will fail for Xpages in the Notes Client 8.5.1.

    What is not allowed?
    Ok, this is the "not so funny" part of this blog posting. I did a few tests. I don't have a complete list, but I have some of the things that hurt the most:
    • using java.net.URLConnection, e.g. to easily connect to a web server
    • XML parsing with javax.xml.parsers.DocumentBuilder
    • Loading Java resources with Class.getResourceAsStream()
    All three are prohibited because java.net.NetPermission is not connected to the ECL system.
    Regarding the URLConnection: Please note that you can use networking. I have a working demo of an XPages application in the client that downloads a HTML file from a web server (by using Java's Socket class and the HTTP protocol) and analyzes it in an XPages application in the client. Actually, at the moment, it's not 100% working any more, because I just upgraded to a new version of JTidy which now internally loads Java resources with Class.getResourceAsStream(). Ouch... ;-)

    Workaround for developers
    Add the grant command shown below to the java.policy file under the Notes directory and restart the client.

    grant {
         permission java.security.AllPermission;
    };

    This completely disables the security restrictions of the platform. That's why it's an extremely bad idea to do this on a user's machine. :-)
    But it makes it easy for you to work on your Java code and test it in the client.

    Workaround for customer installations
    This is not really a workaround. It's the only thing we have. ;-)

    You can put all your restricted code in a JAR file and store it in the jvm/lib/ext directory of the Notes Client. That code then has the right to run with a higher security level and may do the things that your XPages Java code is not allowed to.
    Please note that you need a special syntax in your code to ask Java for that higher privilege level:

    public class ExternalWorkaroundClass {
       public String tryWorkaround(final String anArgument) throws Exception {

           String result = AccessController.doPrivileged(
                   new PrivilegedExceptionAction() {
                       public String run() throws Exception {
                           String result=null;

                           //do some restricted operations here to compute result

                           return result,
                       }
                   }
           );
           return result;
       }

    How should I automatically deploy this to a few hundred customers???
    Don't ask me. Be creative. ;-). IBM dev is working on a better solution and more supported Java permissions in a future version (hopefully 8.5.2 or some kind of 8.5.1 fix pack).
    Looks like they thought that most of the XPages developers do not use those restricted (or any) Java classes at all. So the impact of this would not be too big.

    And they were probably right. But for us, this really hurts.

    What about managed Java beans?
    I guess the JSF method that produces the Java exception shown at the beginning of this article either wants to load the JSF configuration XML file faces-config.xml as a Java resource or it wants to parse it using the JVM's XML parser.
    But hey, remember I said something similar to "A welcome challenge for me!"? :-)

    I'm currently writing my own bean manager. The whole bean concept is about creating a bean, feeding it with default values and storing it in the right scope. Who needs the JSF bean manager for that? :-) ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/21.10.2009142550KLEGL7.htm http://blog.mindoo.com/web/blog.nsf/dx/21.10.2009142550KLEGL7.htm?opendocument&comments     Notes 8.5.1: The new Java UI classes and Domino Designer extensibility API Sun, 11 Oct 2009 17:46:06 +0200 http://blog.mindoo.com/web/blog.nsf/dx/11.10.2009174606KLELHE.htm Lotus Notes 8.5.1 Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/11.10.2009174606KLELHE.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/11.10.2009174606KLELHE.htm Disclaimer: IBM Lotus Notes/Domino 8.5.1 is prerelease code and there are no guarantees from IBM that the functionality presented or discussed will be in the final shipping product.


    I haven't read any blog articles yet about the new extensibility APIs that come with Lotus Notes 8.5.1. Since we participated in the discussion with IBM (at Lotusphere 2009 and later on in the Design Partner Program) about what needs to be part of a first official API version, I would like to give you some hints where to find these new APIs and what they are about.

    Two new extensibility APIs will ship with Lotus Notes 8.5.1:

    Domino Designer Extensibility API
    With this API, an experienced Eclipse Java developer is able to track the user's selection in DDE (e.g. the Note ID/Notes URL of the selected design elements) in order to apply his own design modifications (e.g. via DXL import) and let DDE catch up with the modified design elements afterwards.
    It contains functions to convert a standard Eclipse IProject into something called DesignerProject that provides additional information for a NSF database project in DDE. You get the basic NSF data like server/filepath/replica-id, some design related infos (template names, design hidden flag) and a few interaction methods, for example to open a database in DDE and to initialize/refresh the whole NSF project or single design elements in case you applied some changes to the backend Notes database.

    Notes Client Java UI API
    The Java UI API lets you get a handle on the currently opened UI document and UI view, called NotesUIDocument / NotesUIView:

    NotesUIWorkspace ws=new NotesUIWorkspace();
    NotesUIDocument uidoc=ws.getCurrentDocument();
    NotesUIView uiview=ws.getCurrentView();

    You do not have all the methods in Java yet that you know from the Lotusscript NotesUIDocument/NotesUIView, so don't expect too much for round nr 1. (But read on until the last paragraph to see why this is not a real problem)

    NotesUIDocument
    With the Java based NotesUIDocument you are able to modify fields in the backend document. It provides refresh methods to make those changes visible in the front end.
    Please note, that I said "modify fields", not "get the backend document". There are technical reasons (for example running in different threads and the Client's memory management) that make it impossible to get a full handle on the backend document, but the functionality of the API should be enough for most of the use cases.

    You can get information about the currently focused field (including tracking focus changes with a DocumentFieldListener), toggle edit mode on/off, cut/copy/paste/insert text in the UI and detect that a document has been modified.

    NotesUIView
    The NotesUIView class gives you access to the view's name/UNID/URL. There is a method to print the view.

    That not much for the NotesUIView, but by using the available Eclipse selection APIs you were already able to grab the selected documents in earlier Lotus Notes versions.

    NotesUIWorkspace
    In addition to the methods getCurrentDocument() and getCurrentView(), NotesUIWorkspace contains various methods to open Notes contents, like views, framesets or pages. There are also a few compose(...) methods that open a form to create a document in the Notes client. You can optionally specify a Document as an argument that contains fields that should be set as default field values in the form (this document can be a temporary document created with NotesUIWorkspace.getTemporaryDocument(Session)that is automatically deleted when the Notes client shuts down).
    NotesUIWorkspace.addDatabase(...) adds a database to the workspace of the Notes client.
    And finally, there is a NotesUIWorkspace.prompt(...) method that works like the corresponding method in Lotusscript. That means it displays different forms of selection dialogs with the style of the Notes client.

    Need more information?
    So, how do you know the exact syntax of the available classes and methods?
    You can find the complete Javadoc documentation for the two new APIs in the help system of the Lotus Notes client:

    Image:Notes 8.5.1: The new Java UI classes and Domino Designer extensibility API

    There is one more thing :-)
    Oh wait, I forgot one method. Actually, it's my favorit one.
    When we saw the first draft of the Java UI API at the end of last year, we thought of many things that we would like to add.
    But you know, you quickly realize that you can only concentrate on a few features or even a single one, that is the most important to you and needs to be available for round nr 1.

    Together with a few other design partners, we desperately asked/begged IBM to add one method, that is mission critical for the success of the API release.

    The basic question was: What would you do if a feature is not available in Java, but you know that it's there in Lotusscript? You write a Lotusscript agent and call it from Java.
    Something like

    Database db=session.getDatabase(server, filepath);
    Agent myAgent=db.getAgent("MyLotusscriptAgent");
    myAgent.run();

    That's nothing new. A standard function in the Notes Java API sind R5 or R6.

    Ever tried that with an agent that should do something in the UI, like changing a form's field values or open a selection dialog?
    It does not work.

    That's because Lotus Notes only executes that code in the backend, you do not have any UI access.

    Here is the solution:

    public void runAgent(NotesAgentData agentData, NotesDocumentDataCallback callback, boolean runOnUIContext)
    From the javadoc:
    Runs the agent represented by the agent data. Pass in false for runOnUIContext to run your agent on a temporary document. Pass in true for runOnUIContext to run your agent on the current selected document in the UI. Values added to the NotesAgentData object, using the addItem method, will be added to the temporary document. Also note with this method you can run an agent from one database on a completely different database. In other words, the agent you are running does not have to run on documents from the same database. While this gives the user more flexibility it also may break some assumptions of the agent, for example what fields are on the document.

    When running an agent on a temporary document it is recommended that you set the Target in the properties dialog of the agent to be 'None'. You can do this while editing the agent in Domino Designer. This allows you to run the agent without having anything selected in the UI. To access the temporary document from your agent, you can use Session.DocumentContext in LotusScript, or Session.getAgentContext().getDocumentContext() in Java. The note id of the temporary document is returned to you in the NotesDocumentDataCallback object.
    [...]
    Parameters:
    agentData - data about the agent to run
    callback - callback to run when agent is done running
    runOnUIContext - true to run the agent on the current UI context false to run the agent on the temporary document

    This new method is incredibly great.

    It means that you can put all the code that is missing in this first Java UI API release into a Lotusscript or formula agent and use NotesUIWorkspace.runAgent() to execute it -  in any database. And even better, there is a callback mechanism that you can use to get notified when the code is done to grab some results from a parameter document or the Notes.ini.


    Tomorrow is Notes 8.5.1 release day. Have fun playing with the new APIs!
    ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/11.10.2009174606KLELHE.htm http://blog.mindoo.com/web/blog.nsf/dx/11.10.2009174606KLELHE.htm?opendocument&comments     XPages in the client: How to use XPages as components in Composite Applications Mon, 14 Sep 2009 17:55:08 +0200 http://blog.mindoo.com/web/blog.nsf/dx/14.09.2009175508KLELNZ.htm Composite Application Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/14.09.2009175508KLELNZ.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/14.09.2009175508KLELNZ.htm Disclaimer: IBM Lotus Notes/Domino 8.5.1 is prerelease code and there are no guarantees from IBM that the functionality presented or discussed will be in the final shipping product.


    Today two interesting videos have been posted to the Domino Designer wiki that demonstrate how XPages in the Lotus Notes client 8.5.1 can be integrated with other components by using them as components of a Composite Application.

    Component definition for XPages
    The first video shows how to transform an XPage into a new design element type called Component, that can then be used in a Composite Application. For a Component, you can define your own properties in order to configure the referenced XPage for a specific use case.
    In the video, this is used to alter the theme of the XPage and to show and hide elements within the XPage's UI depending on the property value. By defining component properties, your XPages become much more reusable and configurable. The purpose is to reuse the same XPage in many different contexts (inside Composite Applications) without the need to change a line of code.

    Image:XPages in the client: How to use XPages as components in Composite Applications
    XPage of the discussion database as a component in a Composite Application (click to watch the video)


    Wiring XPages components to other components
    In the second video, the XPage is wired to a mail database component and a web browser component. They communicate in both directions by sending Composite Application properties:
    Clicking on links in the XPage changes the search query on the web and generates a new email with pre-filled fields. In the other direction, clicking on an email in the inbox opens the mail sender's article list in the XPage discussion database.

    Image:XPages in the client: How to use XPages as components in Composite Applications
    Composite Application of an XPage, a Notes Java view and a browser component (click to watch the video)

    The video contains pretty simple examples, but when you understand the idea behind the whole concept, a lot more can be achieved with this technology. It's a great opportunity to extend the functionality of "XPages in the client".
    In Lotus Notes 8.5.1, the pure XPages runtime will only provide basically the same as in the web browser. But by using Composite Application technology, you can easily add features to your application that are not yet available for XPages.

    Let's take a look at another use case:
    You could produce a formatted text in the code of your CRM XPages application (e.g. your own XML format from the user's selection) and publish it through a CA wire. Either you or any other developer can then build a CA component to receive and process this content.
    They could e.g. develop it in Lotusscript to produce some fancy Notes richtext output or write an Eclipse plugin in Java to automate the Symphony office suite that is build inside Lotus Notes to create a new document, like a letter or even a complete report spreadsheet.
    In this use case, the components that take care of the content output to richtext/Symphony, could also be hidden helper components without UI contribution to the Composite Application.

    Summary
    Although the first XPages implementation for the Lotus Notes client 8.5.1 is basically more or less a portable web application container, you can use Composite Application technology to add more functionality.

    The benefit of the Composite Application architecture is to mix a lot of technologies for the purpose of a business use case without the need to redevelop cross-technology interfaces over and over again. Composite Applications have a simple data exchange system: The CA components use simple strings to send and receive data to other components. Components are connected through so called Composite Application wires to exchange this data.

    Hopefully, the integration into the Notes client will be further improved in later Lotus Notes releases. The JSF technology that the XPages runtime is build upon, provides a technology called custom render kits. They can be used to create alternative output formats of a JSF application, e.g. native Java rendering in SWT or Swing or maybe solutions for mobile phone.
    Although developing a custom render kit is a lot of work, this might be a way to enrich the XPages experience with native controls (like Java views and the native Notes richtext editor) in a later Lotus Notes version. Another approach could be to extend the XULRunner that the XPages runtime uses in the client to render the UI.
    ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/14.09.2009175508KLELNZ.htm http://blog.mindoo.com/web/blog.nsf/dx/14.09.2009175508KLELNZ.htm?opendocument&comments     Augmented reality on the iPhone - a cool new concept with great potential Mon, 31 Aug 2009 13:52:02 +0200 http://blog.mindoo.com/web/blog.nsf/dx/31.08.2009135201KLEFX3.htm iPhone Karsten Lehmann http://blog.mindoo.com/web/blog.nsf/dx/31.08.2009135201KLEFX3.htm?opendocument&comments http://blog.mindoo.com/web/blog.nsf/dx/31.08.2009135201KLEFX3.htm
    Our main work at the moment has to do with a completely new MindPlan version for our partner Haus Weilgut. There already is a standalone MindPlan application on the market that stores its data in Lotus Notes and one version that is directly integrated into the Lotus Notes 8.x client as a Composite Application component.
    This new version is somehow different. Still using Notes/Domino technologies, but with a very innovative approach. Watch the MindPlan blog for announcements in the next weeks.

    I will continue the XPages development and blogging after the next vacation (had to concentrate on MindPlan to produce an alpha test version).

    For now, I've just come across a very cool new concept, called "Augmented reality" for the iPhone that I would like to share with you.

    Here is an article about a sample application that integrates tourist information into the camera image of an iPhone:
    The future is now? Augmented reality comes to the iPhone

    I think the technology has a great potential, not only for tourist information. I think of very funny geo caching and virtual reality shooter games when I the demo video.
    For example something like this on the iPhone: http://www.youtube.com/watch?v=Cix3Ws2sOsU  :-) ]]>     http://blog.mindoo.com/web/blog.nsf/dxcomments/31.08.2009135201KLEFX3.htm http://blog.mindoo.com/web/blog.nsf/dx/31.08.2009135201KLEFX3.htm?opendocument&comments