/*
* Copyright 2000-2001,2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jetspeed.portal.controls;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
// Jetspeed imports
import org.apache.jetspeed.om.registry.PortletControlEntry;
import org.apache.jetspeed.om.registry.MediaTypeEntry;
import org.apache.jetspeed.om.security.JetspeedUser;
import org.apache.jetspeed.portal.Portlet;
import org.apache.jetspeed.portal.PortletState;
import org.apache.jetspeed.portal.PortletConfig;
import org.apache.jetspeed.portal.PortletSet;
import org.apache.jetspeed.portal.PortletControl;
import org.apache.jetspeed.portal.PortletControlConfig;
import org.apache.jetspeed.portal.PortletController;
import org.apache.jetspeed.portal.PortletException;
import org.apache.jetspeed.portal.portlets.AbstractPortlet;
import org.apache.jetspeed.portal.security.portlets.PortletWrapper;
import org.apache.jetspeed.services.Registry;
import org.apache.jetspeed.services.JetspeedSecurity;
import org.apache.jetspeed.util.MimeType;
import org.apache.jetspeed.services.resources.JetspeedResources;
// Turbine imports
import org.apache.turbine.util.RunData;
// ECS imports
import org.apache.ecs.ElementContainer;
import org.apache.ecs.ConcreteElement;
import org.apache.ecs.StringElement;
/**
* The PortletControl acts both as a decoration around a Portlet or PortletSet
* and also as the window manager for the enclosed Portlet(Set).
* As such it controls the operation that may be performed on this portlet
* and whether the portlet content should be displayed or not.
* PortletControl also delegates all Portlet and PortletSet methods to its
* inner object and can thus be transparently cascaded or substituted to
* a simple portlet wherever in a PSML object tree.
*
* @author <a href="mailto:raphael@apache.org">Rapha�l Luta</a>
* @author <a href="mailto:sgala@apache.org">Santiago Gala</a>
* @version $Id: AbstractPortletControl.java,v 1.22 2004/03/29 21:16:27 taylor Exp $
*/
public abstract class AbstractPortletControl extends AbstractPortlet
implements PortletControl
{
public static final String COLOR = "#CCCCCC";
public static final String BACKGROUND_COLOR = "#FFFFFF";
public static final String TITLE_COLOR = "#DDDDDD";
public static final String WIDTH = "100%";
private Portlet portlet = null;
private PortletControlConfig conf = null;
// PortletControl specifc interface
/**
* @return the PortletControl specific configuration
*/
public PortletControlConfig getConfig()
{
return this.conf;
}
/**
* Sets the PortletControl specific configuration
* @param conf the new PortletControl configuration
*/
public void setConfig(PortletControlConfig conf)
{
this.conf=conf;
}
/**
* Sets the portlet to be managed by this control
*
* @param portlet the new portlet to be managed by the control
*/
public void setPortlet(Portlet portlet)
{
this.portlet=portlet;
}
/**
* Retrieves the portlet managed by this control
* @return the portlet object managed or null
*/
public Portlet getPortlet()
{
return this.portlet;
}
/**
* Initializes the control and associates it with a portlet
*
* @param portlet the portlet to be managed by this control
*/
public void init( Portlet portlet )
{
this.setPortlet( portlet );
}
/**
* Returns the color to use for displaying the portlet text
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @return the text color value in HTML format (#RRGGBB)
*/
public String getColor()
{
return getPortlet().getPortletConfig().getPortletSkin().getTextColor();
}
/**
* Sets the color to use for displaying the portlet text
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @param color the text color value in HTML format (#RRGGBB)
*/
public void setColor(String color)
{
getPortlet().getPortletConfig().getPortletSkin().setTextColor( color );
}
/**
* Returns the color to use for displaying the portlet background
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @return the text color value in HTML format (#RRGGBB)
*/
public String getBackgroundColor()
{
return getPortlet().getPortletConfig().getPortletSkin().getBackgroundColor();
}
/**
* Sets the color to use for displaying the portlet background
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @param backgroundColor the background color value in HTML format (#RRGGBB)
*/
public void setBackgroundColor(String backgroundColor)
{
getPortlet().getPortletConfig().getPortletSkin().setBackgroundColor( backgroundColor );
}
/**
* Returns the color to use for displaying the portlet title
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @return the text color value in HTML format (#RRGGBB)
*/
public String getTitleColor()
{
return getPortlet().getPortletConfig().getPortletSkin().getTitleBackgroundColor();
}
/**
* Sets the color to use for displaying the portlet title
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @param titleColor the title color value in HTML format (#RRGGBB)
*/
public void setTitleColor(String titleColor)
{
getPortlet().getPortletConfig().getPortletSkin().setTitleBackgroundColor( titleColor );
}
/**
* Returns the width of the managed portlet relative to the size of
* portlet control.
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @return the size value. May be expressed in percentages (eg, "80%")
*/
public String getWidth() {
return getPortlet().getPortletConfig().getSkin( "width", WIDTH );
}
/**
* Sets the width of the managed portlet relative to the size of
* portlet control.
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @param width the width of portlet. Must be a positive, non nul integer
*/
public void setWidth(int width)
{
getPortlet().getPortletConfig().setSkin( "width", String.valueOf(width) );
}
/**
* Sets the width of the managed portlet relative to the size of
* portlet control.
*
* This method is deprecated and is only useful for ECS
* based Control implementation
* @deprecated
* @param width the width of portlet. Must be parseable as a positive, non
* nul integer or a percentage
*/
public void setWidth(String width)
{
getPortlet().getPortletConfig().setSkin( "width", width );
}
// Portlet interface implementation, delegates everything
// to the managed portlet
/**
* @return the inner portlet config object
*/
public PortletConfig getPortletConfig()
{
if (getPortlet()==null) return null;
return getPortlet().getPortletConfig();
}
/**
* Updates the managed portlet config object
*
* @param portletConfig the new portet config object
*/
public void setPortletConfig(PortletConfig portletConfig)
{
if (getPortlet()==null) return;
getPortlet().setPortletConfig(portletConfig);
}
/**
* @return the inner portlet name
*/
public String getName()
{
if (getPortlet()==null) return null;
return getPortlet().getName();
}
/**
* Updates the managed portlet name
*
* @param name the new portet name
*/
public void setName(String name)
{
if (getPortlet()!=null) getPortlet().setName(name);
}
/**
* @return the inner portlet title
*/
public String getTitle()
{
if (getPortlet()==null) return null;
return getPortlet().getTitle();
}
/**
* Set the title for the inner portlet
*
* @param title the new portlet title
*/
public void setTitle( String title )
{
if (getPortlet()!=null) getPortlet().setTitle(title);
}
/**
* @return the inner portlet description
*/
public String getDescription()
{
if (getPortlet()==null) return null;
return getPortlet().getDescription();
}
/**
* Set the description for the inner portlet
*
* @param description the new portlet description
*/
public void setDescription( String description )
{
if (getPortlet()!=null) getPortlet().setDescription(description);
}
/**
* Inits the inner portlet
*/
public void init() throws PortletException
{
if (getPortlet()!=null) getPortlet().init();
}
/**
* Returns the content of inner portlet
*
* @param rundata the RunData for the request
*/
public ConcreteElement getContent(RunData rundata)
{
Portlet portlet = getPortlet();
if (portlet == null)
{
return new ElementContainer();
}
// Check to see if the portlet allows view
// If the current security context disallows view,
// do not display the portlet OR the control decorator
if (portlet instanceof PortletWrapper)
{
PortletWrapper wrapper = (PortletWrapper)portlet;
if (!wrapper.getAllowView(rundata))
{
if (JetspeedResources.getBoolean("defaultportletcontrol.hide.decorator", true))
{
return new StringElement("");
}
}
}
return portlet.getContent( rundata );
}
/**
@see Portlet#supportsType
*/
public boolean supportsType( MimeType mimeType )
{
boolean allowed = true;
if (getPortlet()!=null)
{
allowed = getPortlet().supportsType( mimeType );
}
// the inner portlet does not support the type, return immediately...
if (allowed)
{
// we now need to check that the control also supports the type...
PortletControlEntry entry =
(PortletControlEntry)Registry.getEntry(Registry.PORTLET_CONTROL,
getConfig().getName() );
String baseType = mimeType.toString();
if (entry!=null)
{
Iterator i = entry.listMediaTypes();
while(i.hasNext())
{
String name = (String)i.next();
MediaTypeEntry media = (MediaTypeEntry)Registry.getEntry(Registry.MEDIA_TYPE, name);
if (media != null)
{
if (baseType.equals(media.getMimeType()))
{
allowed = true;
break;
}
}
}
}
}
return allowed;
}
// delegate the portletSet interface to the stored PortletSet
// or emulate a 1-element portletSet
/**
* @return the size of the inner portletSet, 1 if the inner portlet
* is not a set, or 0 if there's no inner portlet
*/
public int size()
{
if (getPortlet() instanceof PortletSet)
return ((PortletSet)getPortlet()).size();
return ((getPortlet()==null)?0:1);
}
/**
* @return an array of portlet contained within the inner PortletSet
* or the inner portlet
*/
public Portlet[] toArray()
{
if (getPortlet() instanceof PortletSet)
return ((PortletSet)getPortlet()).toArray();
Portlet[] p = new Portlet[1];
p[0]=getPortlet();
return p;
}
/**
* Returns the Portlet at the given position if the control manages
* a PortletSet, else the inner portlet if the queried position is 0
*
* @param pos the queried position. Must be strictly smaller than the
* value of size()
* @return the portlet object stored at this position
*/
public Portlet getPortletAt(int pos)
{
if (getPortlet() instanceof PortletSet)
return ((PortletSet)getPortlet()).getPortletAt(pos);
if (pos==0)
return getPortlet();
else
return null;
}
/**
* Returns the elements contained within the inner PortletSet or the
* inner portlet
*
* @return an enumeration of portlets
*/
public Enumeration getPortlets()
{
if (getPortlet() instanceof PortletSet)
return ((PortletSet)getPortlet()).getPortlets();
Vector v = new Vector();
if (getPortlet()!=null) v.addElement(getPortlet());
return v.elements();
}
/**
* Adds a portlet to the inner portletSet
*
* @param portlet the portlet to add
*/
public synchronized void addPortlet(Portlet portlet)
{
if (getPortlet() instanceof PortletSet)
((PortletSet)getPortlet()).addPortlet(portlet);
}
/**
* Adds a portlet to the inner portletSet at the explicit position
*
* @param portlet the portlet to add
* @param position the position of the new portlet
*/
public synchronized void addPortlet(Portlet portlet, int position)
{
if (getPortlet() instanceof PortletSet)
((PortletSet)getPortlet()).addPortlet(portlet,position);
}
/**
* Adds a portlet to the inner portletSet within the given constraints
*
* @param portlet the portlet to add
* @param constraints the portlet layout constraints
*/
public synchronized void addPortlet(Portlet portlet, PortletSet.Constraints constraints)
{
if (getPortlet() instanceof PortletSet)
((PortletSet)getPortlet()).addPortlet(portlet,constraints);
}
/**
* Adds a portlet to the inner portletSet within the given constraints at the
* specific position
*
* @param portlet the portlet to add
* @param constraint the portlet layout constraints
* @param position the portlet required position
*/
public synchronized void addPortlet(Portlet portlet, PortletSet.Constraints constraint, int position)
{
if (getPortlet() instanceof PortletSet)
((PortletSet)getPortlet()).addPortlet(portlet,constraint,position);
}
/**
* @return the controller for the inner portletSet or null
*/
public PortletController getController()
{
if (getPortlet() instanceof PortletSet)
return ((PortletSet)getPortlet()).getController();
return null;
}
/**
* Sets the controller for the inner PortletSet. Has no effect if their
* is no inner portletSet
*
* @parama controller the new controller for the inner portletSet
*/
public synchronized void setController(PortletController controller)
{
if (getPortlet() instanceof PortletSet)
((PortletSet)getPortlet()).setController(controller);
}
// Delegate PortletState Interface
/**
* Implements the default close behavior: any authenticated user may
* remove a portlet from his page
*
* @param rundata the RunData object for the current request
*/
public boolean allowClose( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_CLOSE)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowClose(rundata);
}
}
return false;
}
/**
* Returns true if this portlet is currently closed
*/
public boolean isClosed(RunData rundata)
{
Portlet p = getPortlet();
if ( (p!=null) && (p instanceof PortletState) )
{
return ((PortletState)p).isClosed(rundata);
}
return false;
}
/**
* Toggles the portlet state between closed and normal
*
* @param minimized the new portlet state
* @param data the RunData for this request
*/
public void setClosed(boolean close, RunData rundata)
{
Portlet p = getPortlet();
if ( (p!=null) && (p instanceof PortletState) )
{
((PortletState)p).setClosed(close, rundata);
}
}
/**
* Implements the default info behavior: any authenticated user may
* get information on a portlet
*
* @param rundata the RunData object for the current request
*/
public boolean allowInfo( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_INFO)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowInfo(rundata);
}
}
return false;
}
/**
* Implements the default customize behavior: any authenticated user may
* customize a portlet
*
* @param rundata the RunData object for the current request
*/
public boolean allowCustomize( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_CUSTOMIZE)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowCustomize(rundata);
}
}
return false;
}
/**
* Implements the default maximize behavior: any authenticated user may
* maximize a portlet
*
* @param rundata the RunData object for the current request
*/
public boolean allowMaximize( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_MAXIMIZE)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowMaximize(rundata);
}
}
return false;
}
/**
* Implements the default info behavior: any authenticated user may
* minimize a portlet
*
* @param rundata the RunData object for the current request
*/
public boolean allowMinimize( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_MINIMIZE)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowMinimize(rundata);
}
}
return false;
}
/**
* Implements the default info behavior: any authenticated user may
* display portlet in print friendly format
*
* @param rundata the RunData object for the current request
*/
public boolean allowPrintFriendly( RunData rundata )
{
Portlet p = getPortlet();
if (p==null) return false;
if ((p instanceof PortletSet)
||(JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
p,
JetspeedSecurity.PERMISSION_PRINT_FRIENDLY)))
{
if (p instanceof PortletState)
{
return ((PortletState)p).allowPrintFriendly(rundata);
}
}
return false;
}
/**
* Returns true if this portlet is currently minimized
*/
public boolean isMinimized(RunData rundata)
{
Portlet p = getPortlet();
if ( (p!=null) && (p instanceof PortletState) )
{
return ((PortletState)p).isMinimized(rundata);
}
return false;
}
/**
Change the portlet visibility state ( minimized <-> normal )
@param minimize True if the portlet change to minimized
@param rundata A RunData object
*/
public void setMinimized( boolean minimize, RunData rundata )
{
Portlet p = getPortlet();
if ( (p!=null) && (p instanceof PortletState) )
{
((PortletState)p).setMinimized( minimize, rundata);
}
}
public String getID()
{
return this.portlet.getID();
}
public void setID(String id)
{
this.portlet.setID(id);
}
/**
Returns the Portlet with the given id
*/
public Portlet getPortletByID(String id)
{
Portlet p = getPortlet();
if (null == p)
return null;
if (p instanceof PortletSet)
{
Enumeration e = ((PortletSet)p).getPortlets();
Portlet portlet = null;
while ( e.hasMoreElements() )
{
portlet = (Portlet)e.nextElement();
if (portlet.getID().equals(id))
return portlet;
}
return portlet;
}
return null;
}
/**
Returns the Portlet with the given name
*/
public Portlet getPortletByName(String name)
{
Portlet p = getPortlet();
if (null == p)
return null;
if (p instanceof PortletSet)
{
Enumeration e = ((PortletSet)p).getPortlets();
Portlet portlet = null;
while ( e.hasMoreElements() )
{
portlet = (Portlet)e.nextElement();
if (portlet.getName().equals(name))
return portlet;
}
return portlet;
}
return null;
}
}