connectioncontext.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 2,389 行 · 第 1/5 页

    return 
      windowContext == null 
      ? null 
      : windowContext.getWindow().getRenderer();
  }

  protected Invocation getInvocation()
  {
    Invocation invocation = _windowContext.getInvocation();

    if (invocation == null)
      throw new UnsupportedOperationException("operation requires a namespace");
    
    return invocation;
  }

  protected Invocation getInvocation(String namespace)
  {
    return _invocationFactory.getInvocation(namespace);
  }

  protected void forbidRedirectIfInActionStage()
  {
    if (_stage == STAGE_ACTION)
      setForbidRedirect();
  }

  // -- Invocation - WindowState/PortletMode

  public Set<WindowState> getWindowStatesUsed()
  {
    return getInvocationFactory().getWindowStatesUsed();
  }

  public Set<PortletMode> getPortletModesUsed()
  {
    return getInvocationFactory().getPortletModesUsed();
  }

  protected boolean isPortletModeAllowed( Window window,
                                          PortletMode portletMode)
  {
    PortletRequest portletRequest = getPortletRequest();


    boolean allowed = true;

    Renderer renderer = window.getRenderer();

    if (renderer != null)
      allowed = renderer.isPortletModeAllowed(portletRequest, portletMode);

    if (allowed && window != null)
      allowed = window.isPortletModeAllowed(portletRequest, portletMode);

    if (allowed)
      allowed = getPortal().isPortletModeAllowed(portletRequest, portletMode);

    return allowed;
  }

  protected void setPortletMode( Window window,
                                 String namespace,
                                 Invocation invocation,
                                 PortletMode portletMode)
    throws PortletModeException
  {
    if (!isPortletModeAllowed(window, portletMode))
      throw new PortletModeException(
          "PortletMode `" + portletMode 
          + "' not allowed for namespace `" + namespace + "'",
          portletMode);

    forbidRedirectIfInActionStage();

    invocation.setPortletMode(portletMode);
  }


  public boolean isPortletModeAllowed(PortletMode portletMode)
  {
    return isPortletModeAllowed( getWindow(), getPortletMode());
  }

  public boolean isPortletModeAllowed( String namespace, 
                                       PortletMode portletMode)
  {
    return isPortletModeAllowed( getWindow(namespace), 
                                 getPortletMode(namespace));
  }

  public PortletMode getPortletMode()
  {
    return getInvocation().getPortletMode();
  }

  public PortletMode getPortletMode(String namespace)
  {
    return getInvocation(namespace).getPortletMode();
  }

  public void setPortletMode(PortletMode portletMode)
    throws PortletModeException
  {
    setPortletMode( getWindow(),
                    getNamespace(),
                    getInvocation(),
                    portletMode);
  }

  public void setPortletMode(String namespace, PortletMode portletMode)
    throws PortletModeException
  {
    checkWindowMutable(namespace);

    setPortletMode( getWindow(namespace),
                    namespace,
                    getInvocation(namespace),
                    portletMode);
  }

  protected boolean isWindowStateAllowed( Window window,
                                          WindowState windowState)
  {
    PortletRequest portletRequest = getPortletRequest();

    boolean allowed = true;

    Renderer renderer = window.getRenderer();

    if (renderer != null)
      allowed = renderer.isWindowStateAllowed(portletRequest, windowState);

    if (allowed && window != null)
      allowed = window.isWindowStateAllowed(portletRequest, windowState);

    if (allowed)
      allowed = getPortal().isWindowStateAllowed(portletRequest, windowState);

    return allowed;
  }

  protected void setWindowState( Window window,
                                 String namespace,
                                 Invocation invocation,
                                 WindowState windowState )
    throws WindowStateException
  {
    if (!isWindowStateAllowed(window, windowState))
      throw new WindowStateException(
          "WindowState `" + windowState 
          + "' not allowed for namespace `" + namespace + "'",
          windowState);

    forbidRedirectIfInActionStage();

    invocation.setWindowState(windowState);
  }

  public boolean isWindowStateAllowed(WindowState windowState)
  {
    return isWindowStateAllowed( getWindow(), 
                                 windowState );
  }

  public boolean isWindowStateAllowed( String namespace, 
                                       WindowState windowState)
  {
    return isWindowStateAllowed( getWindow(namespace), 
                                 windowState );
  }

  public WindowState getWindowState()
  {
    return getInvocation().getWindowState();
  }

  public WindowState getWindowState(String namespace)
  {
    return getInvocation(namespace).getWindowState();
  }

  public void setWindowState(WindowState windowState)
    throws WindowStateException
  {
    setWindowState( getWindow(),
                    getNamespace(),
                    getInvocation(),
                    windowState );
  }

  public void setWindowState(String namespace, WindowState windowState)
    throws WindowStateException
  {
    checkWindowMutable(namespace);

    setWindowState( getWindow(namespace),
                    namespace,
                    getInvocation(namespace),
                    windowState );
  }


  // -- Invocation - parameters


  public Map<String, String[]> getActionParameterMap()
  {
    Map<String, String[]> actionMap = _windowContext.getActionMap();

    if (actionMap == null)
      throw new IllegalStateException(
          "namespace `" + getNamespace() + "' is not target of action");

    return actionMap;
  }

  public Map<String, String[]> getRenderParameterMap()
  {
    return getInvocation().getParameterMap();
  }

  public Map<String, String[]> getRenderParameterMap(String namespace)
  {
    return getInvocation(namespace).getParameterMap();
  }

  private void checkNullName(String name)
  {
    if (name == null)
      throw new IllegalArgumentException("parameter name cannot be null");
  }

  private void checkNullValue(Object value)
  {
    if (value == null)
      throw new IllegalArgumentException("parameter value cannot be null");
  }

  protected String getParameter(Map<String, String[]> map, String name)
  {
    checkNullName(name);

    String values[] = map.get(name);

    return values == null || values.length == 0 ? null : values[0];
  }

  protected String[] getParameterValues( Map<String, String[]> map, 
                                         String name)
  {
    checkNullName(name);
    return map.get(name);
  }

  protected Enumeration getParameterNames(Map<String, String[]> map)
  {
    return Collections.enumeration(map.keySet());
  }

  protected void setParameter( Map<String, String[]> map, 
                               String name, 
                               String value)
  {
    checkNullName(name);
    checkNullValue(value);

    map.put(name, new String[] { value });
  }

  protected void setParameters( Map<String, String[]> destMap, 
                                Map<String, String[]> srcMap)
  {
    checkNullValue(srcMap);
    destMap.clear();

    Iterator<Map.Entry<String, String[]>> iter 
      = srcMap.entrySet().iterator();

    while (iter.hasNext()) 
    {
      Map.Entry<String, String[]> entry = iter.next();

      setParameter(destMap, entry.getKey(), entry.getValue());
    }
  }

  protected void setParameter( Map<String, String[]> map, 
                               String name, 
                               String[] values)
  {
    checkNullName(name);
    checkNullValue(values);

    if (values.length == 0)
      map.remove(name);
    else
      map.put(name, values);
  }


  public String getActionParameter(String name)
  {
    return getParameter(getActionParameterMap(), name);
  }

  public String[] getActionParameterValues(String name)
  {
    return getParameterValues(getActionParameterMap(), name);
  }

  public Enumeration getActionParameterNames()
  {
    return getParameterNames(getActionParameterMap());
  }


  public String getRenderParameter(String name)
  {
    return getParameter(getRenderParameterMap(), name);
  }

  public String[] getRenderParameterValues(String name)
  {
    return getParameterValues(getRenderParameterMap(), name);
  }

  public Enumeration getRenderParameterNames()
  {
    return getParameterNames(getRenderParameterMap());
  }

  public void setRenderParameters(Map<String, String[]> srcMap)
  {
    forbidRedirectIfInActionStage();

    setParameters(getRenderParameterMap(), srcMap);
  }

  public void setRenderParameter(String name, String value)
  {
    forbidRedirectIfInActionStage();

    setParameter(getRenderParameterMap(), name, value);
  }

  public void setRenderParameter(String name, String[] values)
  {
    forbidRedirectIfInActionStage();

    setParameter(getRenderParameterMap(), name, values);
  }



  public String getRenderParameter(String namespace, String name)
  {
    return getParameter(getRenderParameterMap(namespace), name);
  }

  public String[] getRenderParameterValues(String namespace, String name)
  {
    return getParameterValues(getRenderParameterMap(namespace), name);
  }

  public Enumeration getRenderParameterNames(String namespace)
  {
    return getParameterNames(getRenderParameterMap(namespace));
  }

  public void setRenderParameters(String namespace, Map<String,String[]> srcMap)
  {
    checkWindowMutable(namespace);

    forbidRedirectIfInActionStage();

    setParameters(getRenderParameterMap(namespace), srcMap);
  }

  public void setRenderParameter(String namespace, String name, String value)
  {
    checkWindowMutable(namespace);

    forbidRedirectIfInActionStage();

    setParameter(getRenderParameterMap(namespace), name, value);
  }

  public void setRenderParameter(String namespace, String name, String[] values)
  {
    checkWindowMutable(namespace);

    forbidRedirectIfInActionStage();

    setParameter(getRenderParameterMap(namespace), name, values);
  }


  // -- Invocation - urls

  protected PortalURL createURL(InvocationURL url)
  {
    return new PortalURL(this, url);
  }

  protected PortalURL createRenderURL( Invocation invocation, 
                                       boolean keepParameters )
  {
    PortalURL url =  createURL(invocation.createRenderURL());

    if (keepParameters)
      url.setParameters(invocation.getParameterMap());

    return url;
  }

  protected PortalURL createActionURL( Invocation invocation,
                                       boolean keepParameters )
  {
    PortalURL url =  createURL(invocation.createActionURL());

    if (keepParameters)
      url.setParameters(invocation.getParameterMap());

    return url;
  }

  public PortalURL createRenderURL()
  {
    return createRenderURL(getInvocation(), false);
  }

  public PortalURL createActionURL()
  {
    return createActionURL(getInvocation(), false);
  }

  public PortalURL createRenderURL(String namespace, boolean keepParameters)
  {
    return createRenderURL(getInvocation(namespace), keepParameters);
  }

  public PortalURL createActionURL(String namespace, boolean keepParameters)
  {
    return createActionURL(getInvocation(namespace), keepParameters);
  }

  // -- Preferences

  public PortletPreferences getPreferences()
  {
    if (_windowContext.getPreferences() == null) {
      PreferencesStore store = getPreferencesStore();

      Window window = getWindow();

      PortletPreferences defaultPreferences
        = window == null 
          ? null 
          : window.getDefaultPreferences();

      ArrayList<PreferencesValidator> validators 
        = window == null 
          ? null 
          : window.getPreferencesValidators();

      try {
        Map<String, String[]> storeMap =
          store.getPreferencesMap(getPortletRequest(), getNamespace());

        // XXX: pool these
        LinkingPortletPreferences pref = new LinkingPortletPreferences();
        pref.start(defaultPreferences, validators, storeMap);

        _windowContext.setPreferences(pref);
      }
      catch (IOException ex) {
        throw new RuntimeException(ex);