001: /*
002: * @author <a href="mailto:novotny@gridsphere.org">Jason Novotny</a>
003: * @author <a href="mailto:wehren@aei.mpg.de">Oliver Wehrens</a>
004: * @version $Id: PortletFrameLayout.java 6387 2007-10-30 12:50:24Z wehrens $
005: */
006: package org.gridsphere.layout;
007:
008: import org.gridsphere.layout.event.PortletComponentEvent;
009: import org.gridsphere.layout.event.PortletFrameEvent;
010: import org.gridsphere.portletcontainer.GridSphereEvent;
011:
012: import javax.portlet.PortletRequest;
013: import java.io.Serializable;
014: import java.util.ArrayList;
015: import java.util.Collections;
016: import java.util.Iterator;
017: import java.util.List;
018:
019: /**
020: * The abstract <code>PortletFrameLayout</code> acts a container for the layout of portlet frame
021: * components and handles PortletFrame events.
022: * <p/>
023: * The <code>PortletTableLayout</code> is a concrete implementation of the <code>PortletFrameLayout</code>
024: * that organizes portlets into a grid with a provided number of rows and columns.
025: *
026: * @see PortletFrame
027: * @see PortletFrameEvent
028: */
029: public abstract class PortletFrameLayout extends BasePortletComponent
030: implements Serializable, PortletLayout, Cloneable {
031:
032: protected List<PortletComponent> components = new ArrayList<PortletComponent>();
033:
034: protected boolean hasFrameMaximized = false;
035:
036: public boolean hasFrameMaximized() {
037: return hasFrameMaximized;
038: }
039:
040: /**
041: * Initializes the portlet component. Since the components are isolated
042: * after Castor unmarshalls from XML, the ordering is determined by a
043: * passed in List containing the previous portlet components in the tree.
044: *
045: * @param list a list of component identifiers
046: * @return a list of updated component identifiers
047: * @see ComponentIdentifier
048: */
049: public List<ComponentIdentifier> init(PortletRequest req,
050: List<ComponentIdentifier> list) {
051: list = super .init(req, list);
052: ComponentIdentifier compId = new ComponentIdentifier();
053: compId.setPortletComponent(this );
054: compId.setComponentID(list.size());
055: compId.setComponentLabel(label);
056: compId.setClassName(this .getClass().getName());
057: list.add(compId);
058: Iterator it = components.iterator();
059:
060: PortletComponent p;
061: while (it.hasNext()) {
062: p = (PortletComponent) it.next();
063: if (!p.getRequiredRole().equals("")
064: && (!req.isUserInRole(p.getRequiredRole()))) {
065: it.remove();
066: } else {
067: p.setCanModify(canModify);
068: // invoke init on each component
069: list = p.init(req, list);
070: p.addComponentListener(this );
071: p.setParentComponent(this );
072: }
073: }
074: return list;
075: }
076:
077: protected void customActionPerformed(GridSphereEvent event) {
078:
079: }
080:
081: public void doRender(GridSphereEvent event) {
082: super .doRender(event);
083: }
084:
085: public void actionPerformed(GridSphereEvent event) {
086:
087: super .actionPerformed(event);
088:
089: PortletComponentEvent compEvt = event.getLastRenderEvent();
090: if ((compEvt != null) && (compEvt instanceof PortletFrameEvent)) {
091: PortletFrameEvent frameEvent = (PortletFrameEvent) compEvt;
092: handleFrameEvent(frameEvent);
093: }
094:
095: customActionPerformed(event);
096: Iterator it = listeners.iterator();
097: PortletComponent comp;
098: while (it.hasNext()) {
099: comp = (PortletComponent) it.next();
100: event.addNewRenderEvent(compEvt);
101: comp.actionPerformed(event);
102: }
103: }
104:
105: public void remove(PortletComponent pc) {
106: components.remove(pc);
107: /*
108: if (getPortletComponents().isEmpty()) {
109: parent.remove(this);
110: }
111: */
112: }
113:
114: /**
115: * Destroys this portlet component
116: */
117: public void destroy() {
118: }
119:
120: /**
121: * Performed when a frame maximized event has been received
122: *
123: * @param event a portlet frame event
124: */
125: public void handleFrameMaximized(PortletFrameEvent event) {
126: //System.err.println("in frame layout: frame has been maximized");
127: Iterator it = components.iterator();
128: PortletComponent p;
129: int id = event.getID();
130: while (it.hasNext()) {
131: p = (PortletComponent) it.next();
132: // check for the frame that has been maximized, set to 101%, means maximized
133: if (p.getComponentID() == id) {
134: p.setWidth("101%");
135: } else {
136: // If this is not the right frame, make it invisible
137: p.setVisible(false);
138: }
139: }
140: }
141:
142: /**
143: * Performed when a frame minimized event has been received
144: *
145: * @param event a portlet frame event
146: */
147: public void handleFrameMinimized(PortletFrameEvent event) {
148: //System.err.println("in PortletFrameLayout Minimized");
149: List scomponents = Collections.synchronizedList(components);
150: synchronized (scomponents) {
151: Iterator it = scomponents.iterator();
152: PortletComponent p;
153: int id = event.getID();
154: while (it.hasNext()) {
155: p = (PortletComponent) it.next();
156: if (p.getComponentID() == id) {
157: p.setWidth("");
158: }
159: p.setWidth(p.getDefaultWidth());
160: p.setVisible(true);
161: }
162: }
163: }
164:
165: /**
166: * Performed when a frame restore event has been received
167: *
168: * @param event a portlet frame event
169: */
170: public void handleFrameRestore(PortletFrameEvent event) {
171: //System.err.println("in PortletFrameLayout Resized");
172: List scomponents = Collections.synchronizedList(components);
173: synchronized (scomponents) {
174: Iterator it = scomponents.iterator();
175: PortletComponent p;
176: int id = event.getID();
177: while (it.hasNext()) {
178: p = (PortletComponent) it.next();
179: if (p.getComponentID() == id) {
180: if (p instanceof PortletFrame) {
181: PortletFrame f = (PortletFrame) p;
182: f.setWidth(event.getOriginalWidth());
183: } else {
184: p.setWidth(p.getDefaultWidth());
185: }
186: } else {
187: p.setVisible(true);
188: }
189: }
190: }
191: }
192:
193: /**
194: * Performed when a frame close event has been received
195: *
196: * @param event a portlet frame event
197: */
198: public void handleFrameClosed(PortletFrameEvent event) {
199: //System.err.println("Portlet FrameLAyout: in frame closed");
200: List scomponents = Collections.synchronizedList(components);
201: synchronized (scomponents) {
202: Iterator it = scomponents.iterator();
203: PortletComponent p;
204: int id = event.getID();
205: while (it.hasNext()) {
206: p = (PortletComponent) it.next();
207: // check for the frame that has been closed
208: if (p.getComponentID() == id) {
209: if (p instanceof PortletFrame) {
210: it.remove();
211: }
212: } else {
213: p.setVisible(true);
214: }
215: }
216: }
217: }
218:
219: /**
220: * Performed when a frame event has been received
221: *
222: * @param event a portlet frame event
223: */
224: public void handleFrameEvent(PortletFrameEvent event) {
225: if (event.getAction() == PortletFrameEvent.FrameAction.FRAME_MAXIMIZED) {
226: hasFrameMaximized = true;
227: handleFrameMaximized(event);
228: } else if (event.getAction() == PortletFrameEvent.FrameAction.FRAME_MINIMIZED) {
229: hasFrameMaximized = false;
230: handleFrameMinimized(event);
231: } else if (event.getAction() == PortletFrameEvent.FrameAction.FRAME_RESTORED) {
232: hasFrameMaximized = false;
233: handleFrameRestore(event);
234: } else if (event.getAction() == PortletFrameEvent.FrameAction.FRAME_CLOSED) {
235: hasFrameMaximized = false;
236: handleFrameClosed(event);
237: }
238: }
239:
240: /**
241: * Adds a new portlet component to the layout
242: *
243: * @param component a portlet component
244: */
245: public void addPortletComponent(PortletComponent component) {
246: components.add(component);
247: }
248:
249: /**
250: * Removes a new portlet component to the layout
251: *
252: * @param component a portlet component
253: */
254: public void removePortletComponent(PortletComponent component) {
255: components.remove(component);
256: }
257:
258: /**
259: * Sets the list of new portlet component to the layout
260: *
261: * @param components an ArrayList of portlet components
262: */
263: public void setPortletComponents(List<PortletComponent> components) {
264: this .components = components;
265: }
266:
267: /**
268: * Returns a list containing the portlet components in this layout
269: *
270: * @return a list of portlet components
271: */
272: public List<PortletComponent> getPortletComponents() {
273: return components;
274: }
275:
276: public Object clone() throws CloneNotSupportedException {
277: PortletFrameLayout f = (PortletFrameLayout) super .clone();
278: f.components = new ArrayList<PortletComponent>(components
279: .size());
280: for (int i = 0; i < components.size(); i++) {
281: PortletComponent comp = (PortletComponent) components
282: .get(i);
283: f.components.add((PortletComponent) comp.clone());
284: }
285: return f;
286: }
287:
288: public String toString() {
289: StringBuffer sb = new StringBuffer();
290: sb.append(super .toString());
291: for (int i = 0; i < components.size(); i++) {
292: sb.append(components.toString());
293: }
294: return sb.toString();
295: }
296:
297: }
|