/** @author zobo */
public class UpdateSphereEmailsHandler extends AbstractOldActionBuilder {

  @SuppressWarnings("unused")
  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(UpdateSphereEmailsHandler.class);

  private final DialogsMainCli cli;

  public UpdateSphereEmailsHandler(DialogsMainCli cli) {
    this.cli = cli;
  }

  public String getProtocol() {
    return SSProtocolConstants.UPDATE_SPHERES_EMAILS;
  }

  @SuppressWarnings("unchecked")
  public void handleUpdateSphereEmails(final SphereEmail sphereEmail) {
    Hashtable update = new Hashtable();
    update.put(SC.SPHERES_EMAIS, sphereEmail.getEmailNames().getSingleStringEmails());
    update.put(SC.SPHERE_ID, sphereEmail.getSphereId());
    update.put(SC.SPHERE_EMAILS_ENABLED, new Boolean(sphereEmail.getEnabled()));
    update.put(SC.ADD_ROUTING_DEFAULT, new Boolean(sphereEmail.getIsMessageIdAdd()));
    update.put(SessionConstants.PROTOCOL, SSProtocolConstants.UPDATE_SPHERES_EMAILS);
    this.cli.sendFromQueue(update);
  }
}
/** @author zobo */
public class EmailControlPanelComposeListener implements SelectionListener {

  private static final Logger logger = SSLogger.getLogger(EmailControlPanelComposeListener.class);

  private MessagesPane mb = null;

  private Hashtable session;

  public EmailControlPanelComposeListener(MessagesPane mb, Hashtable session) {
    super();
    this.mb = mb;
    this.session = session;
  }

  public void widgetSelected(SelectionEvent arg0) {
    logger.info("Clicked item Compose Email");
    (new EmailController(this.mb, this.session)).clickedComposeEmail(null);
  }

  public void widgetDefaultSelected(SelectionEvent arg0) {}
}
/** @author zobo */
public class NewContactConnectActionListener implements Listener {
  private NewContact newContact;
  private Logger logger = SSLogger.getLogger(this.getClass());

  /** @param newContact */
  public NewContactConnectActionListener(NewContact newContact) {
    super();
    this.newContact = newContact;
  }

  public void handleEvent(Event event) {
    String sphereURL =
        this.newContact
            .getOrigDoc()
            .getRootElement()
            .element("home_sphere")
            .attributeValue("value");

    this.logger.info("Sphere URL : " + sphereURL);
    try {
      String reciprocalLogin =
          this.newContact
              .getOrigDoc()
              .getRootElement()
              .element("reciprocal_login")
              .attributeValue("value");
      String cname = NameTranslation.createContactNameFromContactDoc(this.newContact.getOrigDoc());
      String systemName = this.newContact.getClient().getVerifyAuth().getSystemName(cname);

      SupraSphereFrame.INSTANCE.startConnection(
          null, this.newContact.getSession(), sphereURL, reciprocalLogin, systemName);

    } catch (NullPointerException npe) {

    }

    NewContact.getSShell().dispose();
  }
}
/**
 * @deprecated
 * @author dankosedin
 *     <p>TODO:#member-refactoring Not used. Previosly used in ss.client.ui.viewer.NewSphere //
 *     mp.client.publishTerse(session,doc); //
 *     mp.client.registerSphereWithMembers(registermembers,doc.getRootElement().attributeValue("system_name"),doc.getRootElement().attributeValue("display_name"));
 *     <p>NewSphere.this.mp.client.openSphereForMembers( called XmldbUtils.registerSphereWithMembers
 *     but this method also called by OpenSphereForMembersHandler
 */
public class RegisterSphereWithMembersHandlerClient implements ProtocolHandler {

  private DialogsMainCli cli;

  @SuppressWarnings("unused")
  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(RegisterSphereWithMembersHandlerClient.class);

  /**
   * @deprecated
   * @param cli
   */
  public RegisterSphereWithMembersHandlerClient(DialogsMainCli cli) {
    this.cli = cli;
  }

  public String getProtocol() {
    return SSProtocolConstants.REGISTER_SPHERE_WITH_MEMBERS;
  }

  public void handle(Hashtable update) {
    // to-server-only handler
  }

  @SuppressWarnings("unchecked")
  public void registerSphereWithMembers(Vector members, String system_name, String display_name) {
    Hashtable toSend = (Hashtable) this.cli.session.clone();
    toSend.remove(SessionConstants.PASSPHRASE);
    Hashtable update = new Hashtable();
    update.put(SessionConstants.PROTOCOL, SSProtocolConstants.REGISTER_SPHERE_WITH_MEMBERS);

    update.put(SessionConstants.MEMBERS, members);
    update.put(SessionConstants.SYSTEM_NAME, system_name); // RC
    update.put(SessionConstants.DISPLAY_NAME, display_name);
    update.put(SessionConstants.SESSION, toSend);
    this.cli.sendFromQueue(update);
  }
}
public class GetPrivateDomainNamesHandler
    extends AbstractGetterCommandHandler<GetPrivateDomainNamesCommand, Vector<String>> {

  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(GetPrivateDomainNamesHandler.class);

  /** @param peer */
  public GetPrivateDomainNamesHandler(DialogsMainPeer peer) {
    super(GetPrivateDomainNamesCommand.class, peer);
  }

  private static final String HTTP_PATTERN =
      "(http:\\/\\/([\\w-]+\\.)+[\\w-]+)(\\/[\\w- .\\/?%=]*)?";

  private static final String WWW_PATTERN = "(www\\.([\\w-]+\\.)+[\\w-]+)(\\/[\\w- .\\/?%=]*)?";

  /* (non-Javadoc)
   * @see ss.common.networking2.RespondentCommandHandler#evaluate(ss.common.networking2.Command)
   */
  @Override
  protected Vector<String> evaluate(GetPrivateDomainNamesCommand command)
      throws CommandHandleException {
    String filter = command.getStringArg(SC.FILTER);
    String loginName = (String) (command.getSessionArg()).get(SC.USERNAME);
    String homeSphereId = this.peer.getVerifyAuth().getPersonalSphereFromLogin(loginName);
    logger.info("sphere=" + homeSphereId);
    logger.info("filter=" + filter);
    Vector<Document> filteredBookmarks =
        this.peer.getXmldb().getBookmarksForHomeSphere(homeSphereId, filter.toLowerCase());

    Vector<String> domains = new Vector<String>();
    for (Document doc : filteredBookmarks) {
      String url = doc.getRootElement().element("address").attributeValue("value");
      logger.info("url=" + url);
      String domain = getDomain(url);
      if ((domain != null) && !VariousUtils.vectorContains(domain, domains)) {
        domains.add(domain);
      }
    }
    return domains;
  }

  private String getDomain(String url) {
    PatternMatcher matcher = new Perl5Matcher();
    PatternCompiler compiler = new Perl5Compiler();
    PatternMatcherInput input = new PatternMatcherInput(url);
    Pattern pattern = null;

    String patternString = HTTP_PATTERN;
    try {
      pattern = compiler.compile(patternString);
    } catch (MalformedPatternException e) {
      logger.error("Incorrect pattern: " + patternString, e);
    }
    while (matcher.contains(input, pattern)) {
      MatchResult result = matcher.getMatch();
      String sResult = result.group(1);
      logger.info("Match: " + sResult);
      return sResult;
    }
    patternString = WWW_PATTERN;
    try {
      pattern = compiler.compile(patternString);
    } catch (MalformedPatternException e) {
      logger.error("Incorrect pattern: " + patternString, e);
    }
    while (matcher.contains(input, pattern)) {
      MatchResult result = matcher.getMatch();
      String sResult = result.group(1);
      logger.info("Match: " + sResult);
      return sResult;
    }
    return null;
  }
}
public class SupraSphereShellController {

  @SuppressWarnings("unused")
  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(SupraSphereShellController.class);

  private final SupraSphereFrame supra;

  private final ShellListener shellListener;

  private Shell shell;

  public SupraSphereShellController(SupraSphereFrame supraFrame) {
    super();
    this.supra = supraFrame;
    this.shellListener = new SupraFrameShellListener();
  }

  public void init(Shell supraFrameShell) {
    this.shell = supraFrameShell;
    //        String fsep = System.getProperty("file.separator");
    //        String bdir = System.getProperty("user.dir");
    try {
      Image im;
      im =
          new Image(
              Display.getDefault(), getClass().getResource(ImagesPaths.SUPRA_ICON).openStream());
      this.shell.setImage(im);
    } catch (IOException ex) {
      logger.error("can't create supra icon", ex);
    }

    setupListeners();
  }

  /** @author roman */
  private final class SupraFrameShellListener extends ShellAdapter {
    private SupraSphereShellController shellController = SupraSphereShellController.this;

    public void shellMinimized(ShellEvent e) {

      logger.info("IT minimized here");

      this.shellController.supra.getTrayItem().setBlinkPossible(true);
    }

    public void shellClosed(ShellEvent e) {
      e.doit = false;
      UiUtils.swtBeginInvoke(
          new Runnable() {
            private SupraSphereShellController shellController = SupraSphereShellController.this;

            public void run() {
              new ExitDialog(this.shellController.supra);
            }
          });
    }

    public void shellIconified(ShellEvent e) {

      BalloonsController.INSTANCE.setShown(false);
    }

    public void shellDeiconified(ShellEvent e) {

      BalloonsController.INSTANCE.setShown(true);

      this.shellController.supra.getTrayItem().endBlink();
    }

    public void shellDeactivated(ShellEvent e) {
      // logger.info("deactivated");
      this.shellController.supra.getTrayItem().setBlinkPossible(true);
      /*
       * if (bw!=null) { bw.showOrHide(false); }
       */

    }

    public void shellActivated(ShellEvent e) {
      if (this.shellController.supra.tabbedPane != null) {
        if (this.shellController.supra.getShell().isFocusControl()) {
          this.shellController.supra.setFocusToSendField();
        }
      }
      this.shellController.supra.getTrayItem().setBlinkPossible(false);
      this.shellController.supra.getTrayItem().endBlink();
    }

    public void shellResized(ShellEvent e) {}

    public void shellMaximized(ShellEvent e) {
      logger.info("IT MAXIMIZED here");
      this.shellController.supra.getTrayItem().endBlink();
    }
  }

  /** */
  private void setupListeners() {
    this.shell.addMouseListener(
        new MouseListener() {

          private SupraSphereShellController shell = SupraSphereShellController.this;

          public void mouseDoubleClick(MouseEvent arg0) {
            this.shell.supra.getTrayItem().endBlink();
          }

          public void mouseDown(MouseEvent arg0) {
            this.shell.supra.getTrayItem().endBlink();
          }

          public void mouseUp(MouseEvent arg0) {
            this.shell.supra.getTrayItem().endBlink();
          }
        });

    this.shell.addControlListener(
        new ControlAdapter() {
          // private SupraSphereShellController shellController = SupraSphereShellController.this;

          public void controlResized(ControlEvent e) {

            // mainEmbedComp.setBounds(mainEmbedComp.getClientArea());
            // shell was maximized so undo it
            /*if (this.shellController.shell.getMaximized()) {
                logger.info("IT MAXIMIZED");

            }
            logger.warn("E SOURCDE: " + e.getSource());
            if (this.shellController.shell.getMinimized()) {
                logger.warn("IT MINIMIZED");

            }
            */

          }
        });

    this.shell.addFocusListener(
        new FocusListener() {

          private SupraSphereShellController shellController = SupraSphereShellController.this;

          public void focusGained(FocusEvent e) {

            if (this.shellController.supra.tabbedPane != null) {
              this.shellController.supra.setFocusToSendField();
            }

            this.shellController.supra.getTrayItem().setBlinkPossible(false);
            this.shellController.supra.getTrayItem().endBlink();
          }

          public void focusLost(FocusEvent e) {

            this.shellController.supra.getTrayItem().setBlinkPossible(true);
          }
        });
  }

  /** @return the shellListener */
  public ShellListener getShellListener() {
    return this.shellListener;
  }
}
/** @author dankosedin */
public class GetRecentQueries {

  @SuppressWarnings("unused")
  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(GetRecentQueries.class);

  private static final String RESPONSE_ID = "response_id";

  private static final String LAST_UPDATED = "last_updated";

  private static final String MOMENT = "moment";

  private static final String CURRENT_SPHERE = "current_sphere";

  private static final String CONFIRMED = "confirmed";

  private static final String STATUS = "status";

  private static final String MESSAGE_ID = "message_id";

  private static final String THREAD_TYPE = "thread_type";

  private static final String KEYWORDS = "keywords";

  private static final String TYPE = "type";

  private static final String GIVER = "giver";

  private static final String VALUE = "value";

  private final DialogsMainCli cli;

  public GetRecentQueries(DialogsMainCli cli) {
    this.cli = cli;
  }

  @SuppressWarnings("unchecked")
  private void preprocessQueries(Vector<Element> queries, String messageId, String localSphereId) {
    for (Element query : queries) {
      String subject = query.attributeValue(VALUE);
      Document genericDoc = GenericXMLDocument.XMLDoc(subject, "", query.attributeValue(GIVER));
      genericDoc.getRootElement().addElement(TYPE).addAttribute(VALUE, KEYWORDS);
      genericDoc.getRootElement().addElement(THREAD_TYPE).addAttribute(VALUE, KEYWORDS);
      genericDoc
          .getRootElement()
          .addElement(MESSAGE_ID)
          .addAttribute(VALUE, new Long(GenericXMLDocument.getNextTableId()).toString());
      genericDoc.getRootElement().addElement(STATUS).addAttribute(VALUE, CONFIRMED);
      genericDoc.getRootElement().addElement(CONFIRMED).addAttribute(VALUE, "true");
      genericDoc
          .getRootElement()
          .addElement(CURRENT_SPHERE)
          .addAttribute(VALUE, (String) this.cli.session.get(SessionConstants.SPHERE_ID2));
      String moment = query.attributeValue(MOMENT);
      if (moment == null) {
        Date current = new Date();
        moment =
            DateFormat.getTimeInstance(DateFormat.LONG).format(current)
                + " "
                + DateFormat.getDateInstance(DateFormat.MEDIUM).format(current);
      }
      genericDoc.getRootElement().addElement(MOMENT).addAttribute(VALUE, moment);
      genericDoc.getRootElement().addElement(LAST_UPDATED).addAttribute(VALUE, moment);
      genericDoc.getRootElement().addElement(RESPONSE_ID).addAttribute(VALUE, messageId);
      if (logger.isDebugEnabled()) {
        logger.debug("doc : " + XmlDocumentUtils.toPrettyString(genericDoc));
      }
      Hashtable newUpdate = new Hashtable();
      newUpdate.put(SessionConstants.DOCUMENT, genericDoc);
      newUpdate.put(SessionConstants.SPHERE, localSphereId);
      newUpdate.put(SessionConstants.IS_UPDATE, "true");
      this.cli.callInsert(new PostponedUpdate(newUpdate));
    }
  }

  @SuppressWarnings("unchecked")
  public Vector getRecentQueries(
      Hashtable session, String homeSphereId, String homeMessageId, String localSphereId) {
    logger.info(
        "Start recentqueires: " + homeSphereId + " : " + homeMessageId + " : " + localSphereId);
    GetRecentQueriesCommand command = new GetRecentQueriesCommand();
    command.putSessionArg(session);
    command.putArg(SessionConstants.HOME_SPHERE_ID, homeSphereId);
    command.putArg(SessionConstants.HOME_MESSAGE_ID, homeMessageId);
    Vector<Element> queries = command.execute(this.cli, Vector.class);
    preprocessQueries(queries, homeMessageId, localSphereId);
    return queries;
  }
}
public final class ApplicationUpdater {

  @SuppressWarnings("unused")
  private static org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(ApplicationUpdater.class);

  private final InstallationDescriptionManager installationDescriptionManager =
      InstallationDescriptionManager.INSTANCE;

  private final String applicationFolder;

  private final UpdateProcessListener updateProcessListener;

  private final IUpdateProtocolFactory protocolFactory;

  private final IFilesDownloader filesDownloader;

  private boolean actualClientCanWorkWithServer = false;

  /**
   * @param updateResultListener
   * @param protocolFactory
   * @param filesDownloader
   */
  public ApplicationUpdater(
      UpdateProcessListener updateProcessListener,
      IUpdateProtocolFactory protocolFactory,
      IFilesDownloader filesDownloader) {
    super();
    if (updateProcessListener == null) {
      throw new ArgumentNullPointerException("updateProcessListener");
    }
    if (protocolFactory == null) {
      throw new ArgumentNullPointerException("protocolFactory");
    }
    if (filesDownloader == null) {
      throw new ArgumentNullPointerException("filesDownloader");
    }
    this.updateProcessListener = updateProcessListener;
    this.protocolFactory = protocolFactory;
    this.filesDownloader = filesDownloader;
    this.applicationFolder = FolderUtils.getApplicationFolder();
    if (this.applicationFolder == null) {
      throw new NullPointerException("Application folder is null");
    }
  }

  public void start() {
    ThreadUtils.start(
        new Runnable() {
          public void run() {
            safeUpdate();
          }
        },
        getClass());
  }

  void safeUpdate() {
    try {
      update();
    } catch (CantCreateUpdateProtocolException ex) {
      logger.error("Cant update application. Continue normal run", ex);
      continueApplictionIsUpToDate();
    } catch (CantUpdateApplicationException ex) {
      final String message = DebugUtils.toSignificantMessage(ex);
      logger.error(message, ex);
      cantUpdate(message);
    } catch (Throwable ex) {
      final String message = "Unexpected update error: " + DebugUtils.toSignificantMessage(ex);
      logger.error(message, ex);
      cantUpdate(message);
    }
  }
  /**
   * @param runnable
   * @throws IOException
   * @throws CommandExecuteException
   * @throws CantUpdateApplicationException
   */
  void update() throws CantUpdateApplicationException {
    final InstallationDescription localInstallationDescription = getLocalInstallationDescription();
    final UpdateResponse serverResponse =
        getServerResponse(localInstallationDescription.getApplicationVersionObj());
    this.actualClientCanWorkWithServer = serverResponse.isActualClientCanWorkWithServer();
    if (serverResponse.getInstallationStatus() == InstallationStatus.UP_TO_DATE) {
      continueApplictionIsUpToDate();
    } else if (serverResponse.getInstallationStatus() == InstallationStatus.OUT_OF_DATE) {
      runUpdate(localInstallationDescription, serverResponse.getInstallationDescription());
    } else if (serverResponse.getInstallationStatus() == InstallationStatus.UNKNOWN) {
      logger.warn(
          "Cant update application server response is unknown. Cause: "
              + serverResponse.getMessage());
      if (serverResponse.isActualClientCanWorkWithServer()) {
        continueApplictionIsUpToDate();
      } else {
        cantUpdate(serverResponse.getMessage());
      }
    } else {
      cantUpdate(serverResponse.getMessage());
    }
  }

  /** @param message */
  private void cantUpdate(String message) {
    try {
      this.updateProcessListener.cantUpdate(message, this.actualClientCanWorkWithServer);
    } catch (Throwable ex) {
      logger.error("Can't notify about update fails: " + message, ex);
    }
  }

  /**
   * @param message
   * @param installationDescription
   * @param description
   * @throws CantUpdateApplicationException
   */
  private void runUpdate(InstallationDescription current, InstallationDescription target)
      throws CantUpdateApplicationException {
    if (!askUserToProceed()) {
      this.cantUpdate("You can't login with old application version.");
    } else {
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Create update builder from "
                + current.getApplicationVersionObj()
                + " to "
                + target.getApplicationVersionObj());
      }
      final UpdateBuilder builder = new UpdateBuilder(current, target);
      final Update update = builder.getResult();
      if (logger.isDebugEnabled()) {
        logger.debug("Update created " + update);
      }
      UpdateResult result = update.perform(this.filesDownloader);
      this.updateProcessListener.updated(result);
    }
  }

  /** @return */
  private boolean askUserToProceed() {
    return this.updateProcessListener.askUserToProceedUpdate();
  }

  /** */
  private void continueApplictionIsUpToDate() {
    this.updateProcessListener.applicationIsUpToDate();
  }

  /**
   * @param applicationVersionObj
   * @return
   */
  private UpdateResponse getServerResponse(QualifiedVersion applicationVersionObj)
      throws CantUpdateApplicationException {
    final Protocol protocol = this.protocolFactory.create();
    try {
      protocol.start(ClientProtocolManager.INSTANCE);
      final UpdateHelloCommand helloCommand = new UpdateHelloCommand(applicationVersionObj);
      final UpdateResponse response = helloCommand.execute(protocol, UpdateResponse.class);
      if (response == null) {
        throw new CantUpdateApplicationException("Update response is null");
      }
      return response;
    } catch (CommandExecuteException ex) {
      throw new CantUpdateApplicationException("Can't fetch update response", ex);
    } finally {
      protocol.beginClose();
    }
  }

  /** */
  private InstallationDescription getLocalInstallationDescription() {
    if (this.installationDescriptionManager.hasInstallationDescription(this.applicationFolder)) {
      try {
        final InstallationDescription description =
            this.installationDescriptionManager.loadFromApplicationFolder(this.applicationFolder);
        description.verifyAndFixOsName();
        return description;
      } catch (CantLoadInstallationDescriptionException ex) {
        logger.error("Can't load application description. Try to generate it", ex);
      }
    } else {
      logger.warn("Can' find application description. Try to generate it");
    }
    final InstallationDescription blank = this.installationDescriptionManager.createBlank();
    try {
      this.installationDescriptionManager.saveToApplicationFolder(this.applicationFolder, blank);
    } catch (CantSaveInstallationDescriptionException ex) {
      logger.error("Can't save application installation description", ex);
    }
    return blank;
  }
}
Example #9
0
/** @author zobo */
public class Deliverer {

  private class BlockedPane {
    MessagesPane pane = null;

    private LinkedList<AbstractDeliveringElement> blockedList =
        new LinkedList<AbstractDeliveringElement>();

    public BlockedPane(MessagesPane specificPane) {
      this.pane = specificPane;
    }

    void put(AbstractDeliveringElement element) {
      this.blockedList.offer(element);
    }

    LinkedList<AbstractDeliveringElement> get() {
      return this.blockedList;
    }
  }

  @SuppressWarnings("unused")
  private static final org.apache.log4j.Logger logger =
      ss.global.SSLogger.getLogger(Deliverer.class);

  private final List<MessagesPane> panes;

  private final List<BlockedPane> blockedPanes;

  private final String sphereId;

  private final Thread deliver;

  private final MessagesLine messagesQueue;

  private boolean blocked = true;

  private boolean alive = true;

  Deliverer(String sphereId) {
    if (logger.isDebugEnabled()) {
      logger.debug("Deliverer started for: " + sphereId);
    }
    this.sphereId = sphereId;
    this.panes = new ArrayList<MessagesPane>();
    this.messagesQueue = new MessagesLine();
    this.blockedPanes = new ArrayList<BlockedPane>();
    this.deliver =
        new Thread() {
          @Override
          public void run() {
            while (Deliverer.this.alive) {
              if (Deliverer.this.blocked) {
                try {
                  sleep(100);
                } catch (InterruptedException ex) {
                  logger.error("Interrupted");
                }
              } else {
                processNext();
              }
            }
          }
        };
    ThreadUtils.startDemon(this.deliver, "Messages deliverer for sphereId: " + sphereId);
  }

  private void processNext() {

    AbstractDeliveringElement element = this.messagesQueue.take();
    List<MessagesPane> localPanes = null;
    AtomicReference<LinkedList<AbstractDeliveringElement>> releasedList =
        new AtomicReference<LinkedList<AbstractDeliveringElement>>();
    synchronized (this.panes) {
      localPanes = getPanes(element, releasedList);
    }
    if (releasedList.get() == null) {
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Suggesting to pocessing element " + DeliverersManager.FACTORY.getLogInfo(element));
      }
      DeliverProcessor.process(element, localPanes);
    } else {
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Processing with released list element "
                + DeliverersManager.FACTORY.getLogInfo(element));
      }
      DeliverProcessor.process(element, localPanes);
      for (AbstractDeliveringElement el : releasedList.get()) {
        if (logger.isDebugEnabled()) {
          logger.debug(
              "Processing as element from release list element "
                  + DeliverersManager.FACTORY.getLogInfo(el));
        }
        DeliverProcessor.process(el, localPanes);
      }
    }
  }

  private ArrayList<MessagesPane> getPanes(
      final AbstractDeliveringElement element,
      final AtomicReference<LinkedList<AbstractDeliveringElement>> releasedList) {
    if (element.getSpecific() != null) {
      ArrayList<MessagesPane> toRet = new ArrayList<MessagesPane>();
      if (isMessagesPane(element.getSpecific())) {
        synchronized (this.blockedPanes) {
          BlockedPane blockedPane = releaseBlocked(element.getSpecific());
          toRet.add(element.getSpecific());
          if (blockedPane != null) {
            if (logger.isDebugEnabled()) {
              logger.debug("Setting release list size: " + blockedPane.get().size());
            }
            releasedList.set(blockedPane.get());
          }
        }
      }
      return toRet;
    } else {
      synchronized (this.blockedPanes) {
        if (this.blockedPanes.isEmpty()) {
          return new ArrayList<MessagesPane>(this.panes);
        } else {
          ArrayList<MessagesPane> toRet = new ArrayList<MessagesPane>();
          for (MessagesPane pane : this.panes) {
            if (!processIsBlocked(element, pane)) {
              toRet.add(pane);
            }
          }
          return toRet;
        }
      }
    }
  }

  /** @param specific */
  private BlockedPane releaseBlocked(MessagesPane specific) {
    BlockedPane toDel = null;
    for (BlockedPane bpane : this.blockedPanes) {
      if (bpane.pane == specific) {
        toDel = bpane;
        break;
      }
    }
    if (toDel != null) {
      this.blockedPanes.remove(toDel);
    }
    return toDel;
  }

  private boolean processIsBlocked(AbstractDeliveringElement element, MessagesPane pane) {
    for (BlockedPane blockedPane : this.blockedPanes) {
      if (blockedPane.pane == pane) {
        if (logger.isDebugEnabled()) {
          logger.debug("Adding to block list " + DeliverersManager.FACTORY.getLogInfo(element));
        }
        blockedPane.put(element);
        return true;
      }
    }
    return false;
  }

  void deliver(AbstractDeliveringElement element) {
    this.messagesQueue.put(element);
  }

  void stop() {
    this.deliver.interrupt();
  }

  /** @param pane */
  void addMessagesPane(MessagesPane pane) {
    synchronized (this.panes) {
      if (pane != null) {
        this.panes.add(pane);
        if (this.blocked) {
          this.blocked = false;
        }
      }
    }
  }

  void removeMessagesPane(MessagesPane pane) {
    synchronized (this.panes) {
      if (pane != null) {
        this.panes.remove(pane);
      }
    }
  }

  String getSphereId() {
    return this.sphereId;
  }

  boolean isEmptyMessagesPanes() {
    return this.panes.isEmpty();
  }

  /** @param pane */
  boolean isMessagesPane(MessagesPane pane1) {
    synchronized (this.panes) {
      for (MessagesPane pane : this.panes) {
        if (pane == pane1) {
          return true;
        }
      }
      return false;
    }
  }

  /**
   * @param element
   * @param pane
   */
  void deliver(AbstractDeliveringElement element, MessagesPane pane) {
    synchronized (this.blockedPanes) {
      element.setSpecific(pane);
      this.messagesQueue.put(element);
    }
  }

  /** @param specificPane */
  void block(MessagesPane specificPane) {
    synchronized (this.blockedPanes) {
      BlockedPane p = new BlockedPane(specificPane);
      this.blockedPanes.add(p);
    }
  }

  /** */
  void kill() {
    this.alive = false;
    this.deliver.interrupt();
  }
}