/**
* Returns the index of the source contact, in the list of recent messages.
*
* @param messageSourceContact
* @return
*/
int getIndex(MessageSourceContact messageSourceContact) {
synchronized (recentMessages) {
for (int i = 0; i < recentMessages.size(); i++)
if (recentMessages.get(i).equals(messageSourceContact)) return i;
return -1;
}
}
private static AttachingConnector getAttachingConnectorFor(String transport) {
List acs = Bootstrap.virtualMachineManager().attachingConnectors();
AttachingConnector ac;
int i, k = acs.size();
for (i = 0; i < k; i++)
if ((ac = (AttachingConnector) acs.get(i)).transport().name().equals(transport)) return ac;
return null;
}
/**
* Searches for entries in cached recent messages in history.
*
* @param provider the provider which contact messages we will search
* @param isStatusChanged is the search because of status changed
* @return entries in cached recent messages in history.
*/
private List<ComparableEvtObj> getCachedRecentMessages(
ProtocolProviderService provider, boolean isStatusChanged) {
String providerID = provider.getAccountID().getAccountUniqueID();
List<String> recentMessagesContactIDs =
getRecentContactIDs(
providerID, recentMessages.size() < numberOfMessages ? null : oldestRecentMessage);
List<ComparableEvtObj> cachedRecentMessages = new ArrayList<ComparableEvtObj>();
for (String contactID : recentMessagesContactIDs) {
Collection<EventObject> res =
messageHistoryService.findRecentMessagesPerContact(
numberOfMessages, providerID, contactID, isSMSEnabled);
processEventObjects(res, cachedRecentMessages, isStatusChanged);
}
return cachedRecentMessages;
}
/**
* A provider has been removed.
*
* @param provider the ProtocolProviderService that has been unregistered.
*/
void handleProviderRemoved(ProtocolProviderService provider) {
// lets remove the recent messages for this provider, and update
// with recent messages for the available providers
synchronized (recentMessages) {
if (provider != null) {
List<ComparableEvtObj> removedItems = new ArrayList<ComparableEvtObj>();
for (ComparableEvtObj msc : recentMessages) {
if (msc.getProtocolProviderService().equals(provider)) removedItems.add(msc);
}
recentMessages.removeAll(removedItems);
if (!recentMessages.isEmpty())
oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
else oldestRecentMessage = null;
if (recentQuery != null) {
for (ComparableEvtObj msc : removedItems) {
recentQuery.fireContactRemoved(msc);
}
}
}
// handleProviderRemoved can be invoked due to stopped
// history service, if this is the case we do not want to
// update messages
if (!this.messageHistoryService.isHistoryLoggingEnabled()) return;
// lets do the same as we enable provider
// for all registered providers and finally fire events
List<ComparableEvtObj> contactsToAdd = new ArrayList<ComparableEvtObj>();
for (ProtocolProviderService pps : messageHistoryService.getCurrentlyAvailableProviders()) {
contactsToAdd.addAll(getCachedRecentMessages(pps, true));
}
addNewRecentMessages(contactsToAdd);
}
}
/**
* Gets the <tt>Content</tt>s of this <tt>Conference</tt>.
*
* @return the <tt>Content</tt>s of this <tt>Conference</tt>
*/
public Content[] getContents() {
synchronized (contents) {
return contents.toArray(new Content[contents.size()]);
}
}
/**
* Handles new events.
*
* @param obj the event object
* @param provider the provider
* @param id the id of the source of the event
*/
private void handle(EventObject obj, ProtocolProviderService provider, String id) {
// check if provider - contact exist update message content
synchronized (recentMessages) {
ComparableEvtObj existingMsc = null;
for (ComparableEvtObj msc : recentMessages) {
if (msc.getProtocolProviderService().equals(provider)
&& msc.getContactAddress().equals(id)) {
// update
msc.update(obj);
updateRecentMessageToHistory(msc);
existingMsc = msc;
}
}
if (existingMsc != null) {
Collections.sort(recentMessages);
oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
if (recentQuery != null) {
recentQuery.updateContact(existingMsc, existingMsc.getEventObject());
recentQuery.fireContactChanged(existingMsc);
}
return;
}
// if missing create source contact
// and update recent messages, trim and sort
MessageSourceContact newSourceContact =
new MessageSourceContact(obj, MessageSourceService.this);
newSourceContact.initDetails(obj);
// we have already checked for duplicate
ComparableEvtObj newMsg = new ComparableEvtObj(obj);
recentMessages.add(newMsg);
Collections.sort(recentMessages);
oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
// trim
List<ComparableEvtObj> removedItems = null;
if (recentMessages.size() > numberOfMessages) {
removedItems =
new ArrayList<ComparableEvtObj>(
recentMessages.subList(numberOfMessages, recentMessages.size()));
recentMessages.removeAll(removedItems);
}
// save
saveRecentMessageToHistory(newMsg);
// no query nothing to fire
if (recentQuery == null) return;
// now fire
if (removedItems != null) {
for (ComparableEvtObj msc : removedItems) {
recentQuery.fireContactRemoved(msc);
}
}
recentQuery.addQueryResult(newSourceContact);
}
}
/**
* Add the ComparableEvtObj, newly added will fire new, for existing fire update and when trimming
* the list to desired length fire remove for those that were removed
*
* @param contactsToAdd
*/
private void addNewRecentMessages(List<ComparableEvtObj> contactsToAdd) {
// now find object to fire new, and object to fire remove
// let us find duplicates and fire update
List<ComparableEvtObj> duplicates = new ArrayList<ComparableEvtObj>();
for (ComparableEvtObj msgToAdd : contactsToAdd) {
if (recentMessages.contains(msgToAdd)) {
duplicates.add(msgToAdd);
// save update
updateRecentMessageToHistory(msgToAdd);
}
}
recentMessages.removeAll(duplicates);
// now contacts to add has no duplicates, add them all
boolean changed = recentMessages.addAll(contactsToAdd);
if (changed) {
Collections.sort(recentMessages);
if (recentQuery != null) {
for (ComparableEvtObj obj : duplicates)
recentQuery.updateContact(obj, obj.getEventObject());
}
}
if (!recentMessages.isEmpty())
oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
// trim
List<ComparableEvtObj> removedItems = null;
if (recentMessages.size() > numberOfMessages) {
removedItems =
new ArrayList<ComparableEvtObj>(
recentMessages.subList(numberOfMessages, recentMessages.size()));
recentMessages.removeAll(removedItems);
}
if (recentQuery != null) {
// now fire, removed for all that were in the list
// and now are removed after trim
if (removedItems != null) {
for (ComparableEvtObj msc : removedItems) {
if (!contactsToAdd.contains(msc)) recentQuery.fireContactRemoved(msc);
}
}
// fire new for all that were added, and not removed after trim
for (ComparableEvtObj msc : contactsToAdd) {
if ((removedItems == null || !removedItems.contains(msc)) && !duplicates.contains(msc)) {
MessageSourceContact newSourceContact =
new MessageSourceContact(msc.getEventObject(), MessageSourceService.this);
newSourceContact.initDetails(msc.getEventObject());
recentQuery.addQueryResult(newSourceContact);
}
}
// if recent messages were changed, indexes have change lets
// fire event for the last element which will reorder the whole
// group if needed.
if (changed) recentQuery.fireContactChanged(recentMessages.get(recentMessages.size() - 1));
}
}
private static void addSeparator(List<Action> actions) {
int n = actions.size();
if (n > 0 && actions.get(n - 1) != null) {
actions.add(null);
}
}
@Override
public Action[] getActions(boolean context) {
if (actions == null) {
List<Action> actions = new ArrayList<Action>(20);
RADComponent topComp = component.getFormModel().getTopRADComponent();
if (component.isReadOnly()) {
if (component == topComp) {
actions.add(SystemAction.get(TestAction.class));
actions.add(null);
}
Event[] events = component.getKnownEvents();
for (int i = 0; i < events.length; i++) {
if (events[i].hasEventHandlers()) {
actions.add(SystemAction.get(EventsAction.class));
actions.add(null);
break;
}
}
actions.add(SystemAction.get(CopyAction.class));
} else {
if (InPlaceEditLayer.supportsEditingFor(component.getBeanClass(), false)) {
actions.add(SystemAction.get(InPlaceEditAction.class));
}
if (javax.swing.JTable.class.isAssignableFrom(component.getBeanClass())) {
actions.add(SystemAction.get(CustomizeTableAction.class));
}
if (component != topComp) {
actions.add(SystemAction.get(ChangeVariableNameAction.class));
} else {
actions.add(SystemAction.get(TestAction.class));
}
if (FormEditor.getBindingSupport(component.getFormModel()) != null) {
// zxb:删除掉绑定菜单项。
// actions.add(SystemAction.get(BindAction.class));
}
actions.add(SystemAction.get(EventsAction.class));
actions.add(null);
java.util.List actionProps = component.getActionProperties();
Iterator iter = actionProps.iterator();
while (iter.hasNext()) {
final RADProperty prop = (RADProperty) iter.next();
Action action = PropertyAction.createIfEditable(prop);
if (action != null) {
actions.add(action);
}
}
addSeparator(actions);
if (component instanceof ComponentContainer) {
addContainerActions(actions);
addLayoutActions(actions);
} else {
addLayoutActions(actions);
addContainerActions(actions);
}
if (component != topComp) {
actions.add(SystemAction.get(MoveUpAction.class));
actions.add(SystemAction.get(MoveDownAction.class));
}
if (component instanceof ComponentContainer) {
actions.add(SystemAction.get(ReorderAction.class));
}
addSeparator(actions);
if (component != topComp) {
actions.add(SystemAction.get(CutAction.class));
}
actions.add(SystemAction.get(CopyAction.class));
if (component instanceof ComponentContainer) {
actions.add(SystemAction.get(PasteAction.class));
}
if (component != topComp) {
actions.add(SystemAction.get(DuplicateAction.class));
actions.add(SystemAction.get(DeleteAction.class));
}
actions.add(null);
// zxb:删除掉自定义代码菜单项。
// actions.add(SystemAction.get(CustomCodeAction.class));
}
actions.add(null);
javax.swing.Action[] superActions = super.getActions(context);
for (int i = 0; i < superActions.length; i++) actions.add(superActions[i]);
this.actions = new Action[actions.size()];
actions.toArray(this.actions);
}
return actions;
}