我需要开发一个Lotus Notes插件，为Lotus Notes主UI添加一些UI，并在用户创建＆amp;发送电子邮件：
这在Lotus Notes插件中是否可行？
谢谢＆amp;问候， Nadeem Ullah
答案 0 :(得分：1)
我认为你可以使用java lotus notes API来做到这一点。 从这里下载示例.. http://www.nsftools.com/tips/NotesTips.htm#javascraps 下载javascraps.zip文件..它有最大API的例子..
要完成你的工作，你需要在lotus notes中创建一个java代理，然后你需要使用java API根据你的要求编写java代码来完成任务..
答案 1 :(得分：1)
package com.ibm.NotesJava.agents;
import lotus.domino.*;
import java.io.File;
import java.io.FileInputStream;
import java.lang.*;
import java.util.*;
import java.awt.*;
import java.awt.List;
import java.awt.event.*;
import java.text.SimpleDateFormat;
public class MyJavaAgent extends AgentBase {
//Main metho which is called by lotus notes
public void NotesMain() {
try {
Session session = getSession();
AgentContext agentContext = session.getAgentContext();
// (Your code goes here)
Name n = session.createName(agentContext.getEffectiveUserName());
String st = n.getCommon();
Log log=session.createLog("JAVA_AGENT");
log.openFileLog("JAVA_AGENT.log");
MessageBox mb = new MessageBox();
try{
log.logAction("");
log.logAction("******************************Starting JAVA AGENT ************************");
log.logAction("Hello " + st + "!");
log.logAction("Executing JavaAgentTest with Agent: "+agentContext.getCurrentAgent().getName());
Database db = agentContext.getCurrentDatabase();
//System.out.println("Loading emaildetails.properties file from following location:C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
log.logAction("Loading emaildetails.properties file from following location:C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
Properties pro = new Properties();
File fil = new File("C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
//***********LOGIC*********
DocumentCollection coll=agentContext.getUnprocessedDocuments();
Document doc=coll.getFirstDocument();
//get input from user about the process area
}
}
/************************Library Code ***********************************/
/*
* The MessageBox class allows you to create simple message boxes
* using only the java.awt classes. All you have to do is create an instance
* of a MessageBox and use it to call the doOkCancelDialog or the
* doInputBox methods. You can use a single MessageBox instance to
* create multiple dialogs.
*
* This class has been implemented here as an inner class, but there's
* no reason why it couldn't be a class all by itself. The functionality to
* create buttons and messageboxes has been modularized, so it should
* be easy for you to add your own methods to this class, or make global
* modifications as you desire.
*
* The only really complicated/weird thing I had to do was to write and
* include the MultiLineLabel class, which is included towards the end
* of this class as an inner class. Read the comments associated with
* that class to see what's going on there.
*
* Make sure you import java.awt.* and java.awt.event.*
*
* Julian Robichaux -- http://www.nsftools.com
*/
class MessageBox {
public final int NO_ACTION = -1;
public final int CANCEL_ACTION = 0;
public final int OK_ACTION = 1;
int actionCode = NO_ACTION;
Frame parent;
Dialog msgbox;
MultiLineLabel msglabel; // our custom class, defined later
Panel buttons;
Button ok, cancel;
TextField textbox;
Choice dropdown;
List multilist;
public MessageBox () {
// this is the invisible Frame we'll be using to call all of our Dialogs
parent = new Frame();
}
public void dispose () {
// use this when you're ready to clean up
try { msgbox.dispose(); } catch (Exception e) {}
try { parent.dispose(); } catch (Exception e) {}
}
/*
* This method will create a simple dialog box with a title, a message,
* and Ok/Cancel buttons. It will halt execution of your program until
* one of the buttons is clicked, and it will return either OK_ACTION
* if the Ok button is clicked, or CANCEL_BUTTON if the Cancel
* button is clicked.
*/
public int doOkCancelDialog (String title, String message) {
actionCode = NO_ACTION;
try {
// create the messagebox
msgbox = new Dialog(parent, title, true);
msgbox.setLayout(new BorderLayout());
// create the label
initMsglabel(message);
msgbox.add("North", msglabel);
// create the OK and Cancel buttons
buttons = new Panel();
buttons.setLayout(new FlowLayout());
initOkButton();
buttons.add(ok);
initCancelButton();
buttons.add(cancel);
msgbox.add("South", buttons);
// display everything (the system will wait until a button is pressed
// before returning)
displayMsgbox();
msgbox.dispose(); // just in case the ActionListeners didn't fire...
} catch (Exception e) {
}
return actionCode;
}
/*
* This method will create a dialog box that allows the user to enter
* text into a field. It also has a title, a message, and Ok/Cancel buttons,
* and will halt execution of your program until one of the buttons is
* clicked or the user enters text into the field and presses "Enter".
* If the user clicks the Ok button or enters text and presses "Enter",
* then the text in the field will be returned; otherwise, this method will
* return null (which usually indicates that the user clicked Cancel).
*/
public String doInputBox (String title, String message, String defaultText) {
actionCode = NO_ACTION;
try {
// create the messagebox
msgbox = new Dialog(parent, title, true);
msgbox.setLayout(new BorderLayout());
// create the label
initMsglabel(message);
msgbox.add("North", msglabel);
// create the text field
initTextbox(defaultText);
msgbox.add("Center", textbox);
// create the OK and Cancel buttons
buttons = new Panel();
buttons.setLayout(new FlowLayout());
initOkButton();
buttons.add(ok);
initCancelButton();
buttons.add(cancel);
msgbox.add("South", buttons);
// display everything (the system will wait until a button is pressed
// before returning)
displayMsgbox();
msgbox.dispose(); // just in case the ActionListeners didn't fire...
} catch (Exception e) {
}
if (actionCode == OK_ACTION)
return textbox.getText();
else
return null;
}
/*
* This method will create a dialog box that allows the user to select from
* a dropdown list. It also has a title, a message, and Ok/Cancel buttons,
* and will halt execution of your program until one of the buttons is
* clicked. If the user clicks the Ok button then the text in the field will be
* returned; otherwise, this method will return null (which usually indicates
* that the user clicked Cancel).
*/
public String doDropdownBox (String title, String message, String[] selections) {
actionCode = NO_ACTION;
try {
// create the messagebox
msgbox = new Dialog(parent, title, true);
msgbox.setLayout(new BorderLayout());
// create the label
initMsglabel(message);
msgbox.add("North", msglabel);
// create the dropdown box
initDropdown(selections);
msgbox.add("Center", dropdown);
// create the OK and Cancel buttons
buttons = new Panel();
buttons.setLayout(new FlowLayout());
initOkButton();
buttons.add(ok);
initCancelButton();
buttons.add(cancel);
msgbox.add("South", buttons);
// display everything (the system will wait until a button is pressed
// before returning)
displayMsgbox();
msgbox.dispose(); // just in case the ActionListeners didn't fire...
} catch (Exception e) {
}
if (actionCode == OK_ACTION)
return dropdown.getSelectedItem();
else
return null;
}
/*
* This method will create a dialog box that allows the user to select from
* a list of options (use the allowMultiSelect parameter to indicate whether
* the user can select multiple items from the list [true] or just one [false]).
* It also has a title, a message, and Ok/Cancel buttons, and will halt
* execution of your program until one of the buttons is clicked. If the user
* clicks the Ok button then the text in the field will be returned; otherwise,
* this method will return null (which usually indicates that the user clicked
* Cancel or didn't select anything).
*/
public String[] doMultilistBox (String title, String message, String[] selections, boolean allowMultiSelect) {
actionCode = NO_ACTION;
try {
// create the messagebox
msgbox = new Dialog(parent, title, true);
msgbox.setLayout(new BorderLayout());
// create the label
initMsglabel(message);
msgbox.add("North", msglabel);
// create the multilist field
initMultilist(4, allowMultiSelect, selections);
msgbox.add("Center", multilist);
// create the OK and Cancel buttons
buttons = new Panel();
buttons.setLayout(new FlowLayout());
initOkButton();
buttons.add(ok);
initCancelButton();
buttons.add(cancel);
msgbox.add("South", buttons);
// display everything (the system will wait until a button is pressed
// before returning)
displayMsgbox();
msgbox.dispose(); // just in case the ActionListeners didn't fire...
} catch (Exception e) {
}
if ((actionCode == OK_ACTION) &&
(java.lang.reflect.Array.getLength(multilist.getSelectedItems()) > 0))
return multilist.getSelectedItems();
else
return null;
}
/*
* The private methods below are simply reusable modular functions for
* creating various elements that may appear in a MessageBox dialog.
* They make it easier to write new public methods that create different
* kinds of dialogs, and also allow you to make global changes to all your
* dialog components pretty easily.
*/
private void initMsglabel (String message) {
// the actual message in the MessageBox (using the custom
// MultiLineLabel class, included below)
msglabel = new MultiLineLabel(message);
}
private void initOkButton () {
// the OK button
ok = new Button("OK");
ok.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
actionCode = OK_ACTION;
msgbox.dispose();
}
} );
}
private void initCancelButton () {
// the Cancel button
cancel = new Button("Cancel");
cancel.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
actionCode = CANCEL_ACTION;
msgbox.dispose();
}
} );
}
private void initTextbox (String defaultText) {
// the field that allows a user to enter text in an InputBox
textbox = new TextField(defaultText, 40);
// the ActionListener here will get called if the user presses "Enter"
textbox.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
actionCode = OK_ACTION;
msgbox.dispose();
}
} );
}
private void initDropdown (String[] selections) {
// a dropdown box that allows a user to select from a list of
// multiple items
dropdown = new Choice();
for (int i = 0; i < java.lang.reflect.Array.getLength(selections); i++)
dropdown.add(selections[i]);
}
private void initMultilist (int numOfLines, boolean allowMultiSelect, String[] selections) {
// a multiple selection box that allows a user to select one or
// more items. numOfLines indicates how many lines should be
// visible at a time, allowMultiSelect is a boolean value indicating
// whether or not the user should be allowed to select more than
// one item from the list, and selections is an array of Strings that
// is used to populate the selection box
multilist = new List(numOfLines, allowMultiSelect);
for (int i = 0; i < java.lang.reflect.Array.getLength(selections); i++)
multilist.add(selections[i]);
}
private void displayMsgbox () {
// once all of the components have been added to a dialog,
// use this method to display it
Dimension d = msgbox.getToolkit().getScreenSize();
msgbox.setLocation(d.width/3, d.height/3); // center the dialog (sort of)
msgbox.pack(); // organize all its components
msgbox.setResizable(false); // make sure the user can't resize it
msgbox.toFront(); // give it focus
msgbox.setVisible(true); // and display it
}
/*
* Okay, this is a pain, but java.awt doesn't natively have a Label-type class
* that allows you to display text that's more than one line. So I had to write one
* myself. The class below is a modification of some code from the fantastic
* book, "Java in a Nutshell".
*
* The big change I made was to allow this multi-line label to have a fixed width,
* so the Label wouldn't fly off the screen if you had a big paragraph of text to
* display. The width is specified in "columns", which I defined as the width of
* the letter "X" in whatever font is being used. The text that you add to the label
* is automatically split into chunks that are no longer than the number of columns
* specified (you'll see the code to do this in the parseLabel method).
*
* This sample implementation is an inner class of the MessageBox class, although
* it could also be a separate class all by itself. I made it an inner class to make it
* easier to copy and paste everything from one agent to another.
*
* Julian Robichaux -- http://www.nsftools.com
*/
class MultiLineLabel extends Canvas {
// a custom class that will display a text label at a fixed width across
// multiple lines
// (modification of MultiLineLabel class from "Java in a Nutshell")
String label;
String[] lines;
int rows = 1;
int cols = 40;
int margin = 6;
int rowHeight;
int lineAscent;
int maxWidth;
public MultiLineLabel (String text) {
// create a label with the default width
label = text;
}
public MultiLineLabel (String text, int columns) {
// create a label with the specified number of "columns" (where a column
// is the width of "X" in the font that we're using)
if (columns > 0)
cols = columns;
label = text;
}
protected void measure () {
// get the global values we use in relation to our current font
FontMetrics fm = this.getFontMetrics(this.getFont());
if (fm == null)
return;
rowHeight = fm.getHeight();
lineAscent = fm.getAscent();
maxWidth = fm.stringWidth("X") * cols;
}
private int stringWidth (String text) {
// calculate the width of a String using our current font
FontMetrics fm = this.getFontMetrics(this.getFont());
if (fm == null)
return 0;
return fm.stringWidth(text);
}
public Font getFont () {
// return the font that we're currently using
return super.getFont();
}
public void setFont (Font f) {
// change the font that we're currently using, and redraw the
// label with the new font
super.setFont(f);
repaint();
}
public void addNotify () {
// automatically invoked after our label/Canvas is created but
// before it's displayed (FontMetrics aren't available until
// super.addNotify() has been called)
super.addNotify();
measure();
}
public Dimension getPreferredSize () {
// called by the LayoutManager to find out how big we want to be
if (lines == null)
setText(label);
return new Dimension(maxWidth + (2 * margin), (rows * rowHeight) + (2 * margin));
}
public Dimension getMinimumSize () {
// called by the LayoutManager to find out what our bare minimum
// size requirements are
if (lines == null)
setText(label);
return new Dimension(maxWidth, (rows * rowHeight));
}
public void setText (String text) {
// change the text we're using for this label
label = text;
parseLabel();
}
private void parseLabel () {
// parses the text we want to display in the label, so that the lines[]
// variable contains lines of text that are no wider than maxWidth
String token, word;
StringBuffer msg = new StringBuffer("");
StringBuffer line = new StringBuffer("");
// do an initial measurement, to make sure we have maxWidth
measure();
rows = 0;
// we'll be tokenizing the label String twice, first at every end-of-line
// character ('\n') and then at every space (if the lines are too long),
// in order to generate an StringBuffer of proper length lines, all
// separated by \n
java.util.StringTokenizer st1 = new java.util.StringTokenizer(label, "\n", false);
while (st1.hasMoreTokens()) {
token = st1.nextToken();
if (stringWidth(token) <= maxWidth) {
// if the whole line is shorter than the maxWidth allowed, we can
// just add this line to the buffer and get the next one
rows++;
msg.append(token + "\n");
} else {
// if the line was too long, we'll have to break it up manually by
// tokenizing the line at every space and adding words together
// one by one until we have a line that's greater than maxWidth;
// then we can add that shorter line to the buffer and keep doing
// that until we're out of words
java.util.StringTokenizer st2 = new java.util.StringTokenizer(token, " ", false);
while (st2.hasMoreTokens()) {
word = st2.nextToken();
if ((stringWidth(line.toString()) + stringWidth(word)) > maxWidth) {
rows++;
msg.append(line.toString() + "\n");
line.setLength(0);
line.append(word + " ");
} else {
line.append(word + " ");
}
}
// after we've run out of words, add any remaining text to the buffer, too
if (line.length() > 0) {
rows++;
msg.append(line.toString() + "\n");
}
}
}
// once we're done, split the buffer into the lines[] array
java.util.StringTokenizer st = new java.util.StringTokenizer(msg.toString(), "\n");
lines = new String[rows];
for (int i = 0; i < rows; i++)
lines[i] = st.nextToken();
}
public void paint (Graphics g) {
// draw the actual label to the screen, with space around the edges
// based on the margins we've specified (for some reason, we have to
// call setLabel instead of just parseText here in order to get the size
// right, which is a little redundant, but whatever works...)
int y;
setText(label);
Dimension d = this.getSize();
y = lineAscent + (d.height - (rows * rowHeight)) / 2;
for (int i = 0; i < rows; i++, y += rowHeight)
g.drawString(lines[i], margin, y);
}
}
}// end of the MultiLineLabel class