Creating a ToolTip Managed bean

Question

This is a followup to my previous post at ToolTip Performance in XPages I have got the code to do it written (not tested) so I can't seem to get my Managed Bean to get called properly. My config contians the following:

<managed-bean id="ToolTip">
<managed-bean-name>WFSToolTip</managed-bean-name>
<managed-bean-class>ca.workflo.wfsToolTip.ToolTipText</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

and I have stripped my code down to the bare minimum:

package ca.workflo.wfsToolTip;

public class ToolTipText   {

    public String getToolTipText(String key){
        return key;
    }
}

My class is in the build path. I have a simple XPage with one filed on it and a tool tip for that field. The code for the tooltip is:

<xe:tooltip id="tooltip1" for="inputText1">
<xe:this.label>
<![CDATA[#{javascript:WFSToolTip.getToolTipText("More Stuff");}]]>
</xe:this.label>
</xe:tooltip>

When I load the test XPage in the browser I get an error that:

Error while executing JavaScript computed expression Script interpreter error, line=1, col=12: Error calling method 'getToolTipText(string)' on java class 'ca.workflo.wfsToolTip.ToolTipText'

JavaScript code

1: WFSToolTip.getToolTipText("More Stuff");

I can't figure out why the call to getToolTipText would fail.

Can anyone see where I'm going wrong. This is my first Managed Bean and at the moment it is managing me rather than the other way around.

Thanks.

Answer 1

You need to: - implement Serializable which boils down to state it and provide a version - implement Map ... a little more work

Then you use Expression Language instead of SSJS. It would look like #{WFSToolTip["More Stuff"]}

This is how such a class would look like. You need to:

• adjust the view name to reflect the name you want
• the view needs to be flat, column 1 = tooltip name, column 2 = tooltip text
• somewhere (on an admin/config page) you need to call WFSToolTip.clear(); (in SSJS) after you update the values in the configuration.

The example doesn't lazyload since running though a view navigator once is really fast. No point to do all these lookups.

Here you go:

package com.notessensei.xpages;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import lotus.domino.Base;
import lotus.domino.Database;
import lotus.domino.NotesException;
import lotus.domino.View;
import lotus.domino.ViewEntry;
import lotus.domino.ViewEntryCollection;

import com.ibm.xsp.extlib.util.ExtLibUtil;

public class Parameters implements Serializable, Map<String, String> {

    private final static String       CONFIG_VIEW      = "keywords";

    private static final long         serialVersionUID  = 1L;
    private final Map<String, String>   internalMap    = new HashMap<String, String>();

    public Parameters() {
        this.populateParameters(internalMap);
    }

    private void populateParameters(Map<String, String> theMap) {

        Database d = ExtLibUtil.getCurrentDatabase();
        try {
            View v = d.getView(CONFIG_VIEW);
            ViewEntryCollection vec = v.getAllEntries();
            ViewEntry ve = vec.getFirstEntry();
            ViewEntry nextVe = null;

            while (ve != null) {
                nextVe = vec.getNextEntry(ve);
                // Load the parameters, column 0 is the key, column 0 the value
                Vector colVal = ve.getColumnValues();
                theMap.put(colVal.get(0).toString(), colVal.get(1).toString());
                // Cleanup
                this.shred(ve);
                ve = nextVe;
            }
            // recycle, but not the current database!!!
            this.shred(ve, nextVe, vec, v); 
        } catch (NotesException e) {
            e.printStackTrace();
        }
    }

    public void clear() {
        this.internalMap.clear();
        this.populateParameters(this.internalMap);
    }

    public boolean containsKey(Object key) {
        return this.internalMap.containsKey(key);
    }

    public boolean containsValue(Object value) {
        return this.internalMap.containsValue(value);
    }

    public Set<java.util.Map.Entry<String, String>> entrySet() {
        return this.internalMap.entrySet();
    }

    public String get(Object key) {
        return this.internalMap.get(key);
    }

    public boolean isEmpty() {
        return this.internalMap.isEmpty();
    }

    public Set<String> keySet() {
        return this.internalMap.keySet();
    }

    public String put(String key, String value) {
        return this.internalMap.put(key, value);
    }

    public void putAll(Map<? extends String, ? extends String> m) {
        this.internalMap.putAll(m);
    }

    public String remove(Object key) {
        return this.internalMap.remove(key);
    }

    public int size() {
        return this.internalMap.size();
    }

    public Collection<String> values() {
        return this.internalMap.values();
    }

    private void shred(Base... morituri) {

        for (Base obsoleteObject : morituri) {
            if (obsoleteObject != null) {
                try {
                    obsoleteObject.recycle();
                } catch (NotesException e) {
                    // We don't care we want go get
                    // rid of it anyway
                } finally {
                    obsoleteObject = null;
                }
            }
        }

    }
}

The difference to a regular HashMap is only the constructor that populates it. Hope that clarifies it.