0001: /*
0002: * TemplateTableContainerProvider.java
0003: *
0004: * Copyright 2002 Sun Microsystems, Inc. All
0005: * rights reserved. Use of this product is subject
0006: * to license terms. Federal Acquisitions:
0007: * Commercial Software -- Government Users
0008: * Subject to Standard License Terms and
0009: * Conditions.
0010: *
0011: * Sun, Sun Microsystems, the Sun logo, and Sun ONE
0012: * are trademarks or registered trademarks of Sun Microsystems,
0013: * Inc. in the United States and other countries.
0014: */
0015:
0016: package com.sun.portal.providers.containers.template.table;
0017:
0018: import java.util.Collections;
0019: import java.util.List;
0020: import java.util.Map;
0021: import java.util.HashMap;
0022: import java.util.Hashtable;
0023: import java.util.ResourceBundle;
0024: import java.util.logging.Level;
0025: import java.util.logging.LogRecord;
0026: import java.util.logging.Logger;
0027: import java.net.URL;
0028: import java.net.URLEncoder;
0029:
0030: import javax.servlet.http.HttpServletRequest;
0031: import javax.servlet.http.HttpServletResponse;
0032:
0033: import com.sun.portal.providers.Provider;
0034: import com.sun.portal.providers.ProviderWidths;
0035: import com.sun.portal.providers.ProviderException;
0036: import com.sun.portal.providers.InvalidEditFormDataException;
0037: import com.sun.portal.providers.context.ProviderContext;
0038: import com.sun.portal.providers.context.ProviderContextException;
0039: import com.sun.portal.providers.context.ContainerProviderContext;
0040: import com.sun.portal.providers.context.Theme;
0041: import com.sun.portal.providers.containers.template.TemplateContainerProvider;
0042:
0043: import com.sun.portal.providers.containers.ProviderWindowStates;
0044: import com.sun.portal.providers.containers.UnsupportedWindowStateException;
0045:
0046: import com.sun.portal.providers.util.Layout;
0047: import com.sun.portal.providers.util.ProviderOrder;
0048: import com.sun.portal.providers.util.ProviderCommands;
0049: import com.sun.portal.providers.util.PropertyUtil;
0050: import com.sun.portal.log.common.PortalLogger;
0051:
0052: /*
0053: * Template table provider constructs the front page which includes desktop
0054: * sample channels.
0055: *
0056: */
0057: public class TemplateTableContainerProvider extends
0058: TemplateContainerProvider {
0059:
0060: private static Map templateMap = null;
0061:
0062: private static int[] supportedStates = new int[3];
0063: private static Logger logger = PortalLogger
0064: .getLogger(TemplateTableContainerProvider.class);
0065:
0066: static {
0067: //
0068: // init map from int template type to string template file key
0069: //
0070: templateMap = new HashMap();
0071:
0072: templateMap.put(Integer.toString(Layout.LAYOUT_THIN_THICK),
0073: LAYOUT1_TEMPLATE);
0074: templateMap.put(Integer.toString(Layout.LAYOUT_THICK_THIN),
0075: LAYOUT2_TEMPLATE);
0076: templateMap.put(
0077: Integer.toString(Layout.LAYOUT_THIN_THICK_THIN),
0078: LAYOUT3_TEMPLATE);
0079: templateMap.put(Integer.toString(Layout.LAYOUT_THIN_THIN_THIN),
0080: LAYOUT4_TEMPLATE);
0081:
0082: supportedStates[0] = ProviderWindowStates.MINIMIZE;
0083: supportedStates[1] = ProviderWindowStates.NORMAL;
0084: supportedStates[2] = ProviderWindowStates.MAXIMIZE;
0085:
0086: }
0087:
0088: public TemplateTableContainerProvider() {
0089: }
0090:
0091: /*
0092: * getContent implementation of the front provider
0093: *
0094: * @param req the HttpServletReqeust passed from servlet
0095: * @param res the HttpServletResponse passed from servlet
0096: * @return a StringBuffer that contains the content for this
0097: * provider
0098: */
0099: public StringBuffer getContent(HttpServletRequest req,
0100: HttpServletResponse res) throws ProviderException {
0101:
0102: ProviderContext pc = getProviderContext();
0103: StringBuffer ob = new StringBuffer();
0104: List userProviders = getSelectedChannels();
0105:
0106: // Front Provider is going to handle the pop-up action.
0107: String channelAction = req.getParameter(getName()
0108: + ".channelAction");
0109:
0110: if (channelAction == null) {
0111: if (!userProviders.isEmpty()) {
0112: ob = buildPage(req, res);
0113: } else {
0114: ob = buildEmptyPage(req);
0115: }
0116: } else if (channelAction.equals("popup")) {
0117: ob = getPopupProviderContents(req, res);
0118: } else {
0119: if (logger.isLoggable(Level.FINE))
0120: logger.log(Level.FINE, "PSDT_CSPPCTTL0001",
0121: channelAction);
0122: }
0123:
0124: return ob;
0125: }
0126:
0127: /*
0128: * Build the front page
0129: *
0130: * @param req the HttpServletRequest
0131: * @param res the HttpServletResponse
0132: * @return a StringBuffer which contains content for the front page
0133: *
0134: */
0135: protected StringBuffer buildPage(HttpServletRequest req,
0136: HttpServletResponse res) throws ProviderException {
0137:
0138: StringBuffer leftContent = new StringBuffer();
0139: StringBuffer centerContent = new StringBuffer();
0140: StringBuffer rightContent = new StringBuffer();
0141: StringBuffer fullTopContent = new StringBuffer();
0142: StringBuffer fullBottomContent = new StringBuffer();
0143: StringBuffer detachedContent = new StringBuffer(128);
0144: ContainerProviderContext cpc = getContainerProviderContext();
0145: ProviderContext pc = getProviderContext();
0146: ResourceBundle bundle = getResourceBundle();
0147:
0148: String charset = pc.getCharset();
0149:
0150: HashMap completedProviderContent = new HashMap();
0151: int timeout = 1800;
0152:
0153: timeout = getIntegerProperty(TIMEOUT);
0154:
0155: //
0156: // get content for all channels
0157: //
0158:
0159: Map pContent = new HashMap();
0160: Hashtable tags = getStandardTags(req);
0161: String desktopURL = pc.getDesktopURL(req);
0162: String sContext = pc.getStaticContentPath();
0163:
0164: boolean dFramed = true;
0165:
0166: String selectedTabName = (String) req
0167: .getAttribute("selectedTabName");
0168: if (selectedTabName != null && selectedTabName.length() != 0) {
0169: tags.put(SELECTED_TAB_NAME, pc
0170: .encodeURLParameter(selectedTabName));
0171: } else {
0172: tags.put(SELECTED_TAB_NAME, "");
0173: }
0174: tags.put(FRONT_CONTAINER_NAME, getName());
0175: Map channelsHasFrame = getMapProperty(CHANNELS_HAS_FRAME);
0176: Map channelsBackgroundColor = getMapProperty(CHANNELS_BACKGROUND_COLOR);
0177: Map channelsIsDetached = getMapProperty(CHANNELS_IS_DETACHED);
0178: Map channelsIsDetachable = getMapProperty(CHANNELS_IS_DETACHABLE);
0179: Map channelsIsMinimized = getMapProperty(CHANNELS_IS_MINIMIZED);
0180: Map channelsIsMinimizable = getMapProperty(CHANNELS_IS_MINIMIZABLE);
0181: Map channelsIsMaximizable = Collections.EMPTY_MAP;
0182: String maximizedChannel = "";
0183: boolean dIsMaximizable = false;
0184: try {
0185: if (pc.getProviderVersion(getName()) > 1) {
0186: channelsIsMaximizable = getMapProperty(CHANNELS_IS_MAXIMIZABLE);
0187: maximizedChannel = getStringProperty(MAXIMIZED_CHANNEL);
0188: dIsMaximizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MAXIMIZABLE);
0189: }
0190: } catch (ProviderContextException pce) {
0191: if (logger.isLoggable(Level.WARNING))
0192: logger.log(Level.WARNING, "PSDT_CSPPCTTL0002", pce);
0193: }
0194: Map channelsIsRemovable = getMapProperty(CHANNELS_IS_REMOVABLE);
0195: Map borderlessChannels = getMapProperty(BORDERLESS_CHANNELS);
0196:
0197: boolean dIsMinimizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MINIMIZABLE);
0198: boolean dIsMinimized = getBooleanProperty(DEFAULT_CHANNEL_IS_MINIMIZED);
0199: boolean dIsDetachable = getBooleanProperty(DEFAULT_CHANNEL_IS_DETACHABLE);
0200: boolean dIsDetached = getBooleanProperty(DEFAULT_CHANNEL_IS_DETACHED);
0201: boolean dIsRemovable = getBooleanProperty(DEFAULT_CHANNEL_IS_REMOVABLE);
0202: boolean dBorderlessChannel = getBooleanProperty(DEFAULT_BORDERLESS_CHANNEL);
0203:
0204: detachedContent = genDetachedContent(req, channelsIsDetached,
0205: dIsDetached);
0206:
0207: tags.put(FRONT_CONTAINER_NAME, getName());
0208:
0209: //get default value for hasFrame
0210: dFramed = getBooleanProperty(DEFAULT_CHANNEL_HAS_FRAME);
0211:
0212: //get default background color and images from Theme
0213: String bgColor = null;
0214: Map themeMap = null;
0215: try {
0216: themeMap = Theme.getMap(getName(), pc, Theme
0217: .getSelectedName(getName(), pc));
0218: } catch (ProviderContextException pce) {
0219: throw new ProviderException(
0220: "TemplateTableContainerProvider.buildPage(): failed to get theme related attribute",
0221: pce);
0222: }
0223:
0224: String dBgColor = (String) themeMap.get(BG_COLOR);
0225: String dBorderwidth = (String) themeMap.get(BORDER_WIDTH);
0226: String normalizeImage = (String) themeMap.get(NORMALIZE_IMAGE);
0227: String maximizeImage = (String) themeMap.get(MAXIMIZE_IMAGE);
0228: String minimizeImage = (String) themeMap.get(MINIMIZE_IMAGE);
0229: String helpImage = (String) themeMap.get(HELP_IMAGE);
0230: String editImage = (String) themeMap.get(EDIT_IMAGE);
0231: String removeImage = (String) themeMap.get(REMOVE_IMAGE);
0232: String attachImage = (String) themeMap.get(ATTACH_IMAGE);
0233: String detachImage = (String) themeMap.get(DETACH_IMAGE);
0234:
0235: List userProviders = getSelectedChannels();
0236: boolean hasMaximizedChannel = (maximizedChannel != null
0237: && maximizedChannel.length() != 0 && userProviders
0238: .contains(maximizedChannel));
0239: if (hasMaximizedChannel) {
0240: userProviders.clear();
0241: userProviders.add(maximizedChannel);
0242: pContent.put(maximizedChannel, cpc.getContent(req, res,
0243: getName(), maximizedChannel));
0244: } else {
0245: List nonMinimizedList = getSelectedChannels();
0246: //generate a minimized channels content, and update the nonMinimizedList
0247: //pc.debugError("TemplateTableContainerProvider.buildPage:nonMinimizedList1=" + nonMinimizedList);
0248: genMinimizedContent(channelsIsMinimized, nonMinimizedList,
0249: pContent, dIsMinimized);
0250: //get unminimized content and put them in the map
0251: pContent.putAll(cpc.getContent(req, res, getName(),
0252: nonMinimizedList, timeout));
0253: userProviders = getSelectedChannels();
0254: }
0255:
0256: //
0257: // loop through providers and build content for thin, full and wide
0258: // provider separately
0259: //
0260: for (int i = 0; i < userProviders.size(); i++) {
0261: String provider = (String) userProviders.get(i);
0262:
0263: // Check if the selected channel is also in the available list
0264: if (!checkSelChannelInAvailList(provider)) {
0265: continue;
0266: }
0267:
0268: // Need to find if channel specific background color is specified
0269: // Migration requirement
0270: if (!channelsBackgroundColor.isEmpty()) {
0271: bgColor = (String) channelsBackgroundColor
0272: .get(provider);
0273: }
0274: if (PropertyUtil.getBooleanValueFromMap(borderlessChannels,
0275: provider, dBorderlessChannel)) {
0276: tags.put(BORDER_WIDTH, "0");
0277: } else {
0278: tags.put(BORDER_WIDTH, dBorderwidth);
0279: }
0280:
0281: StringBuffer populatedProviderWrapper = new StringBuffer();
0282: StringBuffer provider_cmds = new StringBuffer();
0283: StringBuffer providerContent = null;
0284: Provider p = null;
0285:
0286: if (pContent.containsKey(provider)) {
0287: providerContent = (StringBuffer) pContent.get(provider);
0288: } else {
0289: //if the content is not found in the map, skip this channel
0290: if (bundle != null) {
0291: providerContent = new StringBuffer(bundle
0292: .getString("error_channel_timedout"));
0293: } else {
0294: providerContent = new StringBuffer(
0295: "ERROR:Channel Timed Out");
0296: }
0297: }
0298:
0299: //if the content for the channel is null, display content not availabe error message
0300: if (providerContent == null) {
0301: //see if we can get the cached content
0302: providerContent = cpc.getCachedContent(provider);
0303: //if not dispaly an error message
0304: if (providerContent == null) {
0305: providerContent = buildErrorMsg("error_content_not_available");
0306: }
0307: }
0308: boolean isMinimized = PropertyUtil.getBooleanValueFromMap(
0309: channelsIsMinimized, provider, dIsMinimized);
0310: boolean isDetached = PropertyUtil.getBooleanValueFromMap(
0311: channelsIsDetached, provider, dIsDetached);
0312: p = cpc.getProvider(req, getName(), provider);
0313:
0314: if (p != null && !isDetached && p.isPresentable(req)) {
0315: String title = null;
0316: try {
0317: title = p.getTitle();
0318: } catch (Throwable t) {
0319: if (logger.isLoggable(Level.SEVERE)) {
0320: LogRecord rec = new LogRecord(Level.SEVERE,
0321: "PSDT_CSPPCTTL0003");
0322: rec.setLoggerName(logger.getName());
0323: String[] params = { provider };
0324: rec.setParameters(params);
0325: rec.setThrown(t);
0326: logger.log(rec);
0327: }
0328: StringBuffer msg = buildErrorMsg("error_missing_property");
0329: providerContent = msg.append(providerContent);
0330: title = "";
0331: }
0332:
0333: boolean framed = PropertyUtil.getBooleanValueFromMap(
0334: channelsHasFrame, provider, dFramed);
0335: if (title != null) {
0336: tags.put(TITLE, title);
0337: }
0338:
0339: Hashtable tagtable = ProviderCommands
0340: .getProviderCommands(p, getName(), cpc, req,
0341: bundle, desktopURL, sContext,
0342: channelsIsDetachable,
0343: channelsIsDetached,
0344: channelsIsMinimizable,
0345: channelsIsMaximizable,
0346: maximizedChannel, channelsIsMinimized,
0347: channelsIsRemovable, dIsDetachable,
0348: dIsDetached, dIsMinimizable,
0349: dIsMaximizable, dIsMinimized,
0350: dIsRemovable, normalizeImage,
0351: maximizeImage, minimizeImage,
0352: helpImage, editImage, removeImage,
0353: attachImage, detachImage);
0354:
0355: tags.put(PROVIDER_CMDS, getTemplate(
0356: "providerCommands.template", tagtable));
0357:
0358: tags.put(CONTENT, providerContent.toString());
0359: tags.put(SIZE, "100%");
0360: if (bgColor != null)
0361: tags.put(BG_COLOR, bgColor);
0362: else
0363: tags.put(BG_COLOR, dBgColor);
0364:
0365: String wrapper = null;
0366:
0367: if (framed) {
0368: if (providerContent.length() != 0 && (!isMinimized)) {
0369: wrapper = PROVIDER_WRAPPER_TEMPLATE;
0370: } else {
0371: // use minimized template, with empty content
0372: wrapper = MINIMIZED_TEMPLATE;
0373: }
0374: } else {
0375: wrapper = BARE_PROVIDER_WRAPPER_TEMPLATE;
0376: }
0377:
0378: StringBuffer thePopulatedProviderWrapper = getTemplate(
0379: wrapper, tags);
0380:
0381: populatedProviderWrapper
0382: .append(thePopulatedProviderWrapper.toString());
0383:
0384: completedProviderContent.put(provider,
0385: populatedProviderWrapper);
0386: }
0387: }
0388: StringBuffer ob = null;
0389: if (hasMaximizedChannel) {
0390: if (!completedProviderContent.containsKey(maximizedChannel)) {
0391: if (logger.isLoggable(Level.WARNING))
0392: logger.log(Level.WARNING, "PSDT_CSPPCTTL0004",
0393: maximizedChannel);
0394: } else {
0395: StringBuffer content = (StringBuffer) completedProviderContent
0396: .get(maximizedChannel);
0397: tags.put("MaximizedContent", content);
0398: }
0399: tags.put("detachedContent", detachedContent.toString());
0400: tags.put(HELP_LINK, getHelpLink("frontPage", req));
0401:
0402: tags.put(LAUNCH_POPUP, getTemplate(LAUNCH_POPUP_JS));
0403:
0404: ob = getTemplate(MAXIMIZED_TEMPLATE, tags);
0405: } else {
0406: List providerOrder = ProviderOrder.order(
0407: getSelectedChannels(), getName(), cpc, req);
0408:
0409: Map channelsColumn = null;
0410:
0411: int layout = -1;
0412:
0413: layout = getIntegerProperty(LAYOUT);
0414: channelsColumn = getMapProperty(CHANNELS_COLUMN);
0415:
0416: for (int i = 0; i < providerOrder.size(); i++) {
0417: String providerName = (String) providerOrder.get(i);
0418:
0419: if (!checkSelChannelInAvailList(providerName)) {
0420: continue;
0421: }
0422:
0423: Provider p = null;
0424:
0425: p = cpc.getProvider(req, getName(), providerName);
0426:
0427: if (p == null || !p.isPresentable(req))
0428: continue;
0429:
0430: if (!completedProviderContent.containsKey(providerName)) {
0431: if (logger.isLoggable(Level.WARNING))
0432: logger.log(Level.WARNING, "PSDT_CSPPCTTL0004",
0433: maximizedChannel);
0434: continue;
0435:
0436: }
0437:
0438: StringBuffer completed = (StringBuffer) completedProviderContent
0439: .get(providerName);
0440:
0441: int column = 1;
0442: int width = 1;
0443: String defaultChannelColumn = getStringProperty(DEFAULT_CHANNEL_COLUMN);
0444:
0445: try {
0446: width = p.getWidth();
0447: column = Integer
0448: .parseInt(PropertyUtil
0449: .getStringValueFromMap(
0450: channelsColumn,
0451: providerName,
0452: defaultChannelColumn));
0453: } catch (NumberFormatException e) {
0454: if (logger.isLoggable(Level.WARNING))
0455: logger.log(Level.WARNING, "PSDT_CSPPCTTL0005",
0456: providerName);
0457: completed = buildErrorMsg("error_missing_property");
0458: completed
0459: .append((StringBuffer) completedProviderContent
0460: .get(providerName));
0461:
0462: } catch (Throwable t) {
0463: if (logger.isLoggable(Level.WARNING))
0464: logger.log(Level.WARNING, "PSDT_CSPPCTTL0006",
0465: providerName);
0466: completed = buildErrorMsg("error_missing_property");
0467: completed
0468: .append((StringBuffer) completedProviderContent
0469: .get(providerName));
0470: }
0471:
0472: if (width != -1) {
0473: switch (width) {
0474: case ProviderWidths.WIDTH_FULL_TOP:
0475: fullTopContent.append(completed);
0476: break;
0477: case ProviderWidths.WIDTH_FULL_BOTTOM:
0478: fullBottomContent.append(completed);
0479: break;
0480: case ProviderWidths.WIDTH_THIN:
0481: switch (layout) {
0482: case Layout.LAYOUT_THIN_THICK:
0483: leftContent.append(completed);
0484: break;
0485: case Layout.LAYOUT_THICK_THIN:
0486: rightContent.append(completed);
0487: break;
0488: case Layout.LAYOUT_THIN_THICK_THIN:
0489: if (column == 1) {
0490: leftContent.append(completed);
0491: } else {
0492: rightContent.append(completed);
0493: }
0494: break;
0495: case Layout.LAYOUT_THIN_THIN_THIN:
0496: if (column == 2) {
0497: rightContent.append(completed);
0498: } else if (column == 1) {
0499: leftContent.append(completed);
0500: } else {
0501: centerContent.append(completed);
0502: }
0503: break;
0504:
0505: default:
0506: if (logger.isLoggable(Level.WARNING)) {
0507: String[] pramas = { "" + layout,
0508: providerName };
0509: logger.log(Level.WARNING,
0510: "PSDT_CSPPCTTL0007",
0511: providerName);
0512: }
0513: break;
0514: }
0515: break;
0516:
0517: case ProviderWidths.WIDTH_THICK:
0518: switch (layout) {
0519: case Layout.LAYOUT_THIN_THICK:
0520: rightContent.append(completed);
0521: break;
0522: case Layout.LAYOUT_THICK_THIN:
0523: leftContent.append(completed);
0524: break;
0525: case Layout.LAYOUT_THIN_THICK_THIN:
0526: centerContent.append(completed);
0527: break;
0528: case Layout.LAYOUT_THIN_THIN_THIN:
0529: break;
0530: }
0531: break;
0532:
0533: default:
0534: if (logger.isLoggable(Level.WARNING))
0535: logger.log(Level.WARNING,
0536: "PSDT_CSPPCTTL0008", "" + width);
0537: break;
0538: }
0539: }
0540: }
0541:
0542: int centerWidth = 0;
0543: int rightWidth = 0;
0544: int leftWidth = 0;
0545:
0546: switch (layout) {
0547: case Layout.LAYOUT_THIN_THICK:
0548: leftWidth = 30;
0549: rightWidth = 70;
0550: break;
0551: case Layout.LAYOUT_THICK_THIN:
0552: rightWidth = 30;
0553: leftWidth = 70;
0554: break;
0555: case Layout.LAYOUT_THIN_THICK_THIN:
0556: rightWidth = 25;
0557: centerWidth = 50;
0558: leftWidth = 25;
0559: break;
0560: case Layout.LAYOUT_THIN_THIN_THIN:
0561: rightWidth = 33;
0562: centerWidth = 33;
0563: leftWidth = 33;
0564: break;
0565: }
0566:
0567: if (logger.isLoggable(Level.FINEST)) {
0568: logger.log(Level.FINEST, "center width {0}", ""
0569: + leftWidth);
0570: logger.log(Level.FINEST, "center content {0}", ""
0571: + leftContent.toString());
0572: }
0573:
0574: tags.put("fullTopContent", fullTopContent);
0575: tags.put("leftWidth", Integer.toString(leftWidth));
0576: tags.put("leftContent", leftContent);
0577: tags.put("centerWidth", Integer.toString(centerWidth));
0578: tags.put("centerContent", centerContent);
0579: tags.put("rightWidth", Integer.toString(rightWidth));
0580: tags.put("rightContent", rightContent);
0581: tags.put("fullBottomContent", fullBottomContent);
0582:
0583: tags.put("detachedContent", detachedContent.toString());
0584: tags.put(HELP_LINK, getHelpLink("frontPage", req));
0585:
0586: tags.put(LAUNCH_POPUP, getTemplate(LAUNCH_POPUP_JS));
0587:
0588: ob = getTemplate(USER_TEMPLATE, tags);
0589: }
0590:
0591: return (ob);
0592:
0593: }
0594:
0595: private StringBuffer genDetachedContent(HttpServletRequest req,
0596: Map channelsIsDetached, boolean dIsDetached)
0597: throws ProviderException {
0598: StringBuffer detachedContent = new StringBuffer();
0599: List selected = getSelectedChannels();
0600: for (int i = 0; i < selected.size(); i++) {
0601: String provider = (String) selected.get(i);
0602:
0603: if (!checkSelChannelInAvailList(provider)) {
0604: continue;
0605: }
0606:
0607: boolean isDetached = PropertyUtil.getBooleanValueFromMap(
0608: channelsIsDetached, provider, dIsDetached);
0609: if (isDetached) {
0610: Provider p = null;
0611:
0612: p = getContainerProviderContext().getProvider(req,
0613: getName(), provider);
0614:
0615: if (p == null || !p.isPresentable(req))
0616: continue;
0617: int width = 1;
0618: int pwidth = 0;
0619: int pheight = 0;
0620: try {
0621: width = p.getWidth();
0622: } catch (Throwable t) {
0623: //let the page build using width 1, and in the process loop this will be handled
0624: }
0625: if (width != -1) {
0626: switch (width) {
0627: case ProviderWidths.WIDTH_FULL_TOP:
0628: pwidth = getIntegerProperty(FULLWIDTH_POPUP_WIDTH);
0629: pheight = getIntegerProperty(FULLWIDTH_POPUP_HEIGHT);
0630: break;
0631: case ProviderWidths.WIDTH_FULL_BOTTOM:
0632: pwidth = getIntegerProperty(FULLWIDTH_POPUP_WIDTH);
0633: pheight = getIntegerProperty(FULLWIDTH_POPUP_HEIGHT);
0634: break;
0635: case ProviderWidths.WIDTH_THIN:
0636: pwidth = getIntegerProperty(THIN_POPUP_WIDTH);
0637: pheight = getIntegerProperty(THIN_POPUP_HEIGHT);
0638: break;
0639: case ProviderWidths.WIDTH_THICK:
0640: pwidth = getIntegerProperty(THICK_POPUP_WIDTH);
0641: pheight = getIntegerProperty(THICK_POPUP_HEIGHT);
0642: break;
0643: default:
0644: logger.log(Level.INFO, "PSDT_CSPPCTTL0008", ""
0645: + width);
0646: break;
0647: }
0648: }
0649: String window_name = getName() + p.getName();
0650: String new_window_name = PropertyUtil
0651: .replaceChannelName(URLEncoder
0652: .encode(window_name));
0653:
0654: Map pathInfo = new HashMap();
0655: pathInfo.put("action", "content");
0656: pathInfo.put("provider", getName());
0657: pathInfo.put(getName() + ".channelAction", "popup");
0658: pathInfo
0659: .put(getName() + ".targetProvider", p.getName());
0660: pathInfo.put("last", "false");
0661:
0662: String desktopURL = getProviderContext().getDesktopURL(
0663: req, null, pathInfo);
0664:
0665: detachedContent.append(
0666: "<script language=\"JavaScript\">\n").append(
0667: "launchPopup(").append("'").append(desktopURL)
0668: .append("' ,'").append(new_window_name).append(
0669: "', ").append(pwidth).append(", ")
0670: .append(pheight).append(");\n").append(
0671: "</script>\n");
0672:
0673: }
0674:
0675: }
0676: return detachedContent;
0677: }
0678:
0679: private void genMinimizedContent(Map channelsIsMinimized,
0680: List nonMinimizedList, Map content, boolean dIsMinimized)
0681: throws ProviderException {
0682: List pList = getSelectedChannels();
0683: for (int i = 0; i < pList.size(); i++) {
0684: String provider = (String) pList.get(i);
0685:
0686: if (!checkSelChannelInAvailList(provider)) {
0687: continue;
0688: }
0689:
0690: boolean isMinimized = PropertyUtil.getBooleanValueFromMap(
0691: channelsIsMinimized, provider, dIsMinimized);
0692: if (isMinimized) {
0693: nonMinimizedList.remove(provider);
0694: content.put(provider, new StringBuffer(""));
0695: }
0696:
0697: }
0698: }
0699:
0700: protected StringBuffer buildEmptyPage(HttpServletRequest req)
0701: throws ProviderException {
0702: Hashtable tags = getStandardTags(req);
0703: StringBuffer content = new StringBuffer();
0704: ResourceBundle bundle = getResourceBundle();
0705: ContainerProviderContext cpc = getContainerProviderContext();
0706: String warning = null;
0707:
0708: if (bundle != null) {
0709: warning = bundle
0710: .getString("warning_no_providers_available");
0711: }
0712:
0713: content
0714: .append("<TABLE WIDTH=100% BGCOLOR=\"#333366\" BORDER=0 CELLPADDING=2 CELLSPACING=0><TR><TD VALIGN=TOP><CENTER>");
0715: content.append("<FONT COLOR=\"#FFFFFF\">");
0716: content.append("<B>").append(warning).append("</B></FONT>");
0717: content.append("</CENTER></TD></TR></TABLE>");
0718:
0719: tags.put(FRONT_CONTAINER_NAME, getName());
0720: tags.put(CONTENT, content.toString());
0721: tags.put(EMPTY_PROVIDER_CONTENT, warning);
0722: try {
0723: tags.put(HELP_LINK, getHelpLink("frontPage", req));
0724: } catch (ProviderException pe) {
0725: tags.put(HELP_LINK, "");
0726: }
0727:
0728: tags.put(LAUNCH_POPUP, getTemplate(LAUNCH_POPUP_JS));
0729:
0730: StringBuffer ob = getTemplate(USER_TEMPLATE, tags);
0731:
0732: return (ob);
0733:
0734: }
0735:
0736: protected StringBuffer buildErrorPage(HttpServletRequest req,
0737: String err, String container, String key)
0738: throws ProviderException {
0739: Hashtable tags = getStandardTags(req);
0740: StringBuffer content = new StringBuffer();
0741: ResourceBundle bundle = getResourceBundle();
0742: ContainerProviderContext cpc = getContainerProviderContext();
0743: String error_msg1 = null;
0744: String error_msg2 = null;
0745:
0746: if (bundle != null) {
0747: error_msg1 = bundle.getString(key);
0748: error_msg2 = bundle
0749: .getString("error_property_not_defined2");
0750: }
0751:
0752: content.append(error_msg1).append(err).append(error_msg2)
0753: .append(container).append("</TR>");
0754: content.append("</B></FONT></CENTER></TD></TR></TABLE>");
0755:
0756: tags.put(FRONT_CONTAINER_NAME, getName());
0757: tags.put(CONTENT, content.toString());
0758: tags.put(LAUNCH_POPUP, getTemplate(LAUNCH_POPUP_JS));
0759:
0760: StringBuffer ob = getTemplate(USER_TEMPLATE, tags);
0761:
0762: return (ob);
0763:
0764: }
0765:
0766: protected StringBuffer buildErrorMsg(String key)
0767: throws ProviderException {
0768: StringBuffer content = new StringBuffer();
0769: ResourceBundle bundle = getResourceBundle();
0770:
0771: String error_msg = bundle.getString(key);
0772: content.append(error_msg).append("</B></FONT>");
0773: content.append("</CENTER></TD></TR></TABLE>");
0774:
0775: return content;
0776: }
0777:
0778: public StringBuffer getEdit(HttpServletRequest req,
0779: HttpServletResponse res) throws ProviderException {
0780: ContainerProviderContext cpc = getContainerProviderContext();
0781: String containerEdit = req.getParameter(getName()
0782: + ".containerEdit");
0783: if (containerEdit.equals("option")) {
0784: return (getOptionsEdit(req, res));
0785: } else if (containerEdit.equals("content")) {
0786: return (getContentEdit(req, res));
0787: } else if (containerEdit.equals("layout")) {
0788: return (getLayoutEdit(req, res));
0789: }
0790:
0791: StringBuffer b = new StringBuffer("option");
0792: return b;
0793:
0794: }
0795:
0796: public URL processEdit(HttpServletRequest req,
0797: HttpServletResponse res) throws ProviderException {
0798: Map channelsIsDetached = new HashMap();
0799: Map channelsIsMinimized = new HashMap();
0800:
0801: Map channelsIsMinimizable = getMapProperty(CHANNELS_IS_MINIMIZABLE);
0802: Map channelsIsMaximizable = getMapProperty(CHANNELS_IS_MAXIMIZABLE);
0803: Map channelsIsDetachable = getMapProperty(CHANNELS_IS_DETACHABLE);
0804: Map channelsIsRemovable = getMapProperty(CHANNELS_IS_REMOVABLE);
0805: boolean dIsMinimizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MINIMIZABLE);
0806: boolean dIsMaximizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MAXIMIZABLE);
0807: boolean dIsDetachable = getBooleanProperty(DEFAULT_CHANNEL_IS_DETACHABLE);
0808: boolean dIsRemovable = getBooleanProperty(DEFAULT_CHANNEL_IS_REMOVABLE);
0809:
0810: ContainerProviderContext cpc = getContainerProviderContext();
0811: ProviderContext pc = getProviderContext();
0812:
0813: // For Popup provider
0814: String channelAction = req.getParameter(getName()
0815: + ".channelAction");
0816: String targetProvider = req.getParameter(getName()
0817: + ".targetProvider");
0818: if (channelAction != null) {
0819: channelsIsDetached = getMapProperty(CHANNELS_IS_DETACHED);
0820: channelsIsMinimized = getMapProperty(CHANNELS_IS_MINIMIZED);
0821: if (channelAction.equals("detach")) {
0822: // Channel is detached, turn the flag to true
0823: boolean shouldDetach = PropertyUtil
0824: .getBooleanValueFromMap(channelsIsDetachable,
0825: targetProvider, dIsDetachable);
0826: if (shouldDetach) {
0827: Boolean detach_value = new Boolean(true);
0828: channelsIsDetached
0829: .put(targetProvider, detach_value);
0830: setMapProperty(CHANNELS_IS_DETACHED,
0831: channelsIsDetached);
0832: }
0833: } else if (channelAction.equals("attach")) {
0834: // Channel is attached back, turn the flag to false
0835: //only if its detachable, it can be attached. so use DETACHABLE PROPERTY
0836: boolean shouldDetach = PropertyUtil
0837: .getBooleanValueFromMap(channelsIsDetachable,
0838: targetProvider, dIsDetachable);
0839: if (shouldDetach) {
0840: Boolean detach_value = new Boolean(false);
0841: channelsIsDetached
0842: .put(targetProvider, detach_value);
0843: setMapProperty(CHANNELS_IS_DETACHED,
0844: channelsIsDetached);
0845: }
0846: } else if (channelAction.equals("minimize")) {
0847: boolean shouldMinimize = PropertyUtil
0848: .getBooleanValueFromMap(channelsIsMinimizable,
0849: targetProvider, dIsMinimizable);
0850: if (shouldMinimize)
0851: setWindowState(targetProvider,
0852: ProviderWindowStates.MINIMIZE);
0853: } else if (channelAction.equals("maximize")) {
0854: setWindowState(targetProvider,
0855: ProviderWindowStates.NORMAL);
0856: } else if (channelAction.equals("truemaximize")) {
0857: // same as maximize
0858: boolean shouldMaximize = PropertyUtil
0859: .getBooleanValueFromMap(channelsIsMaximizable,
0860: targetProvider, dIsMaximizable);
0861: if (shouldMaximize) {
0862: setWindowState(targetProvider,
0863: ProviderWindowStates.MAXIMIZE);
0864: }
0865: } else if (channelAction.equals("remove")) {
0866: boolean shouldRemove = PropertyUtil
0867: .getBooleanValueFromMap(channelsIsRemovable,
0868: targetProvider, dIsRemovable);
0869: if (shouldRemove) {
0870: List userProviders = getSelectedChannels();
0871: int size = userProviders.size();
0872: for (int i = 0; i < size; i++) {
0873: String provider = (String) userProviders.get(i);
0874:
0875: if (!checkSelChannelInAvailList(provider)) {
0876: continue;
0877: }
0878:
0879: if (provider.equals(targetProvider)) {
0880: userProviders.remove(provider);
0881: break;
0882: }
0883: }
0884: setSelectedChannels(userProviders);
0885: //make sure that maximized is not set to the removed channel.
0886: try {
0887: if (getProviderContext().getProviderVersion(
0888: getName()) > 1) {
0889: String maximizedChannel = getStringProperty(MAXIMIZED_CHANNEL);
0890: if (maximizedChannel
0891: .equalsIgnoreCase(targetProvider)) {
0892: setStringProperty(MAXIMIZED_CHANNEL, "");
0893: }
0894: }
0895: } catch (ProviderContextException pce) {
0896: logger.log(Level.WARNING, "PSDT_CSPPCTTL0009",
0897: pce);
0898: }
0899: }
0900: }
0901: return null;
0902: }
0903:
0904: // For Options and layout provider
0905: String containerEdit = req.getParameter(getName()
0906: + ".containerEdit");
0907: if (containerEdit.equals("option")) {
0908: String editArgs = req.getParameter("editArgs");
0909: URL next = null;
0910: try {
0911: return (processOptionsEdit(req, res));
0912: } catch (InvalidEditFormDataException ide) {
0913: String error = pc.encodeURLParameter(ide.getMessage());
0914: StringBuffer args = new StringBuffer(64);
0915: int errIndex = editArgs.indexOf("&error=");
0916: if (errIndex > -1) {
0917: args.append(pc.getDesktopURL(req)).append(
0918: editArgs.substring(0, errIndex)).append(
0919: "&error=").append(error);
0920: } else {
0921: args.append(pc.getDesktopURL(req)).append(editArgs)
0922: .append("&error=").append(error);
0923: }
0924: try {
0925: next = new URL(args.toString());
0926: } catch (java.net.MalformedURLException m) {
0927: throw new ProviderException(
0928: "TemplateContainerProvider.processEdit()",
0929: m);
0930: }
0931: return next;
0932: }
0933: } else if (containerEdit.equals("content")) {
0934: return (processContentEdit(req, res));
0935: } else if (containerEdit.equals("layout")) {
0936: return (processLayoutEdit(req, res));
0937: }
0938: return null;
0939: }
0940:
0941: public StringBuffer getOptionsEdit(HttpServletRequest req,
0942: HttpServletResponse res) throws ProviderException {
0943: String oneChecked = "";
0944: String twoChecked = "";
0945: String threeChecked = "";
0946: String fourChecked = "";
0947:
0948: int layout = -1;
0949:
0950: layout = getIntegerProperty(LAYOUT);
0951:
0952: switch (layout) {
0953: case Layout.LAYOUT_THIN_THICK: {
0954: oneChecked = "CHECKED";
0955: break;
0956: }
0957: case Layout.LAYOUT_THICK_THIN: {
0958: twoChecked = "CHECKED";
0959: break;
0960: }
0961: case Layout.LAYOUT_THIN_THICK_THIN: {
0962: threeChecked = "CHECKED";
0963: break;
0964: }
0965: case Layout.LAYOUT_THIN_THIN_THIN: {
0966: fourChecked = "CHECKED";
0967: break;
0968: }
0969: }
0970:
0971: Hashtable tags = getStandardTags(req);
0972: ContainerProviderContext cpc = getContainerProviderContext();
0973: tags.put(FRONT_CONTAINER_NAME, getName());
0974: StringBuffer args = new StringBuffer(64);
0975: args.append("?").append(req.getQueryString());
0976: tags.put("editArgs", args.toString());
0977: tags.put("help_link", getHelpLink("optionsPage", req));
0978: tags.put("layoutOneChecked", oneChecked);
0979: tags.put("layoutTwoChecked", twoChecked);
0980: tags.put("layoutThreeChecked", threeChecked);
0981: tags.put("layoutFourChecked", fourChecked);
0982:
0983: tags.put("serviceTimeout", getIntegerProperty(TIMEOUT) + "");
0984:
0985: StringBuffer ob = getTemplate(OPTIONS_TEMPLATE, tags);
0986:
0987: return (ob);
0988: }
0989:
0990: public URL processOptionsEdit(HttpServletRequest req,
0991: HttpServletResponse res) throws ProviderException {
0992: ResourceBundle bundle = getResourceBundle();
0993: String serviceTimeout = req.getParameter("serviceTimeout");
0994: String layout = req.getParameter("layout");
0995:
0996: int timeout = 0;
0997: try {
0998: timeout = Integer.parseInt(serviceTimeout);
0999:
1000: if (timeout < 0) {
1001: req.setAttribute("containerEdit", "option");
1002: String err = bundle
1003: .getString("error_timeout_lessthan_zero");
1004: throw new InvalidEditFormDataException(err);
1005: }
1006: } catch (NumberFormatException e) {
1007: String err = bundle.getString("error_timeout_notnumber");
1008: req.setAttribute("containerEdit", "option");
1009: throw new InvalidEditFormDataException(err);
1010: }
1011: setIntegerProperty(TIMEOUT, timeout);
1012:
1013: int new_layout = 0;
1014: try {
1015: new_layout = Integer.parseInt(layout);
1016: } catch (NumberFormatException e) {
1017: String err = "Please enter a valid layout value";
1018: throw new InvalidEditFormDataException(err);
1019: }
1020: setIntegerProperty(LAYOUT, new_layout);
1021:
1022: return null;
1023: }
1024:
1025: public URL processContentEdit(HttpServletRequest req,
1026: HttpServletResponse res) throws ProviderException {
1027: ProviderContext pc = getProviderContext();
1028: List allProviders = getAvailableChannels();
1029: List userProviders = getSelectedChannels();
1030: Map channelsRemovable = null;
1031: boolean defaultIsRemovable = false;
1032:
1033: channelsRemovable = getMapProperty(CHANNELS_IS_REMOVABLE);
1034: defaultIsRemovable = getBooleanProperty(DEFAULT_CHANNEL_IS_REMOVABLE);
1035: int numProviders = allProviders.size();
1036:
1037: for (int i = 0; i < numProviders; i++) {
1038: String provider = (String) allProviders.get(i);
1039:
1040: if (!PropertyUtil.getBooleanValueFromMap(channelsRemovable,
1041: provider, defaultIsRemovable)) {
1042: continue;
1043: }
1044:
1045: String checkBoxValue = req.getParameter(provider);
1046:
1047: if (checkBoxValue == null) {
1048: userProviders.remove(provider);
1049: } else if (checkBoxValue.equals("1")) {
1050: if (!userProviders.contains(provider)) {
1051: userProviders.add(provider);
1052: }
1053: }
1054: }
1055:
1056: setSelectedChannels(userProviders);
1057:
1058: return null;
1059: }
1060:
1061: public StringBuffer getContentEdit(HttpServletRequest req,
1062: HttpServletResponse res) throws ProviderException {
1063: ProviderContext pc = getProviderContext();
1064: ContainerProviderContext cpc = getContainerProviderContext();
1065: ResourceBundle bundle = getResourceBundle();
1066:
1067: String charset = pc.getCharset();
1068: Map channelsRemovable = new HashMap();
1069: boolean defaultIsRemovable = false;
1070:
1071: channelsRemovable = getMapProperty(CHANNELS_IS_REMOVABLE);
1072: defaultIsRemovable = getBooleanProperty(DEFAULT_CHANNEL_IS_REMOVABLE);
1073:
1074: StringBuffer wideProviders = new StringBuffer();
1075: StringBuffer thinProviders = new StringBuffer();
1076: StringBuffer fullProviders = new StringBuffer();
1077:
1078: List allProviders = getAvailableChannels();
1079: List userProviders = getSelectedChannels();
1080:
1081: int numProviders = allProviders.size();
1082:
1083: for (int i = 0; i < numProviders; i++) {
1084: String provider = (String) allProviders.get(i);
1085:
1086: Provider theProvider = null;
1087: theProvider = cpc.getProvider(req, getName(), provider);
1088:
1089: if (theProvider == null) {
1090: logger.log(Level.INFO, "PSDT_CSPPCTTL0010", provider);
1091: continue;
1092: }
1093:
1094: int width = theProvider.getWidth();
1095: String title = theProvider.getTitle();
1096: String description = theProvider.getDescription();
1097: boolean remove = PropertyUtil.getBooleanValueFromMap(
1098: channelsRemovable, provider, defaultIsRemovable);
1099: boolean presentable = theProvider.isPresentable(req);
1100:
1101: int layout = getIntegerProperty(LAYOUT);
1102:
1103: String checked = "";
1104:
1105: if (userProviders.contains(provider)) {
1106: checked = "CHECKED";
1107: }
1108:
1109: //
1110: // only add removable channels to the content page
1111: //
1112:
1113: if (remove && presentable) {
1114: if (width == ProviderWidths.WIDTH_THIN) {
1115: thinProviders
1116: .append("<INPUT TYPE=CHECKBOX NAME=\"")
1117: .append(provider).append("\" VALUE=1 ")
1118: .append(checked).append("><B>").append(
1119: title).append("</B><BR>\n").append(
1120: description).append("<P>");
1121: } else if (width == ProviderWidths.WIDTH_THICK) {
1122: if (layout != Layout.LAYOUT_THIN_THIN_THIN) {
1123: wideProviders.append(
1124: "<INPUT TYPE=CHECKBOX NAME=\"").append(
1125: provider).append("\" VALUE=1 ").append(
1126: checked).append("><B>").append(title)
1127: .append("</B><BR>\n").append(
1128: description).append("<P>");
1129: }
1130: } else if ((width == ProviderWidths.WIDTH_FULL_TOP)
1131: || (width == ProviderWidths.WIDTH_FULL_BOTTOM)) {
1132: fullProviders
1133: .append("<INPUT TYPE=CHECKBOX NAME=\"")
1134: .append(provider).append("\" VALUE=1 ")
1135: .append(checked).append("><B>").append(
1136: title).append("</B><BR>\n").append(
1137: description).append("<P>");
1138: }
1139: }
1140: }
1141:
1142: //
1143: // for thin and wide, check and see if there was any. if not, insert
1144: // some notice of this.
1145: //
1146:
1147: if (thinProviders.length() == 0) {
1148: thinProviders.append(bundle.getString("emptyMsg"));
1149: }
1150:
1151: //
1152: // now that we checked if it's empty, insert leading html
1153: //
1154: thinProviders.insert(0,
1155: "<FONT SIZE=\"+0\" FACE=\"[tag:desktop-fontFace1]\">");
1156:
1157: if (wideProviders.length() == 0) {
1158: wideProviders.append(bundle.getString("emptyMsg"));
1159: }
1160:
1161: //
1162: // now that we checked if it's empty, insert leading html
1163: //
1164: wideProviders.insert(0,
1165: "<FONT SIZE=\"+0\" FACE=\"[tag:desktop-fontFace1]\">");
1166:
1167: if (fullProviders.length() == 0) {
1168: fullProviders.append(bundle.getString("emptyMsg"));
1169: }
1170:
1171: //
1172: // now that we checked if it's empty, insert leading html
1173: //
1174: fullProviders.insert(0,
1175: "<FONT SIZE=\"+0\" FACE=\"[tag:desktop-fontFace1]\">");
1176:
1177: thinProviders.append("</FONT>");
1178: wideProviders.append("</FONT>");
1179: fullProviders.append("</FONT>");
1180:
1181: Hashtable tags = getStandardTags(req);
1182: String selected = req.getParameter("selected");
1183: if (selected != null && selected.length() != 0) {
1184: tags.put(SELECTED_TAB_NAME, selected);
1185: tags.put("selectedName", getProviderContext()
1186: .encodeURLParameter(selected));
1187: }
1188: tags.put(CONTENT_BAR_IN_CONTENT,
1189: getTemplate(CONTENT_BAR_IN_CONTENT_TEMPLATE));
1190: tags.put(FRONT_CONTAINER_NAME, getName());
1191: tags.put("help_link", getHelpLink("contentPage", req));
1192: tags.put("thinProviders", thinProviders.toString());
1193: tags.put("wideProviders", wideProviders.toString());
1194: tags.put("fullProviders", fullProviders.toString());
1195:
1196: StringBuffer ob = getTemplate(CONTENT_TEMPLATE, tags);
1197:
1198: return (ob);
1199: }
1200:
1201: public URL processLayoutEdit(HttpServletRequest req,
1202: HttpServletResponse res) throws ProviderException {
1203: ProviderContext pc = getProviderContext();
1204: ContainerProviderContext cpc = getContainerProviderContext();
1205:
1206: Map channelsColumn = null;
1207: Map channelsRow = null;
1208:
1209: channelsColumn = getMapProperty(CHANNELS_COLUMN);
1210: channelsRow = getMapProperty(CHANNELS_ROW);
1211:
1212: String layoutIDString = (String) req.getParameter("layoutID");
1213:
1214: if (layoutIDString != null) {
1215: switch (Integer.valueOf(layoutIDString).intValue()) {
1216: //********************************************
1217: // All the cases in the switch are the same at
1218: // this point. But I
1219: // decided to leave it in, incase we
1220: // decide to add more layouts or
1221: // more complex handling of layout info.
1222: //**************************************
1223:
1224: //Thin, Wide
1225: case 1:
1226:
1227: //Wide, Thin
1228: case 2:
1229:
1230: //Thin, Wide, Thin
1231: case 3:
1232:
1233: //Thin, Thin, Thin
1234: case 4:
1235:
1236: default: {
1237: String[] one = req.getParameterValues("one");
1238: String[] two = req.getParameterValues("two");
1239: String[] three = req.getParameterValues("three");
1240: String[] fulltop = req.getParameterValues("fulltop");
1241: String[] fullbottom = req
1242: .getParameterValues("fullbottom");
1243:
1244: if (one != null) {
1245: for (int i = 0; i < one.length; i++) {
1246: if (one[i].equals(".none")
1247: || one[i].equals("spacer")) {
1248: continue;
1249: }
1250: channelsColumn.put(one[i], "1");
1251: channelsRow.put(one[i], (i + 1) + "");
1252: logger.log(Level.FINEST, "PSDT_CSPPCTTL0011",
1253: channelsRow.get(one[i]));
1254: logger.log(Level.FINEST, "PSDT_CSPPCTTL0012",
1255: channelsColumn.get(one[i]));
1256: }
1257: }
1258:
1259: if (two != null) {
1260: for (int i = 0; i < two.length; i++) {
1261: if (two[i].equals(".none")
1262: || two[i].equals("spacer")) {
1263: continue;
1264: }
1265: channelsColumn.put(two[i], "2");
1266: channelsRow.put(two[i], (i + 1) + "");
1267: logger.log(Level.FINEST, "PSDT_CSPPCTTL0013",
1268: channelsRow.get(two[i]));
1269: logger.log(Level.FINEST, "PSDT_CSPPCTTL0014",
1270: channelsColumn.get(two[i]));
1271: }
1272: }
1273:
1274: if (three != null) {
1275: for (int i = 0; i < three.length; i++) {
1276: if (three[i].equals(".none")
1277: || three[i].equals("spacer")) {
1278: continue;
1279: }
1280: channelsColumn.put(three[i], "3");
1281: channelsRow.put(three[i], (i + 1) + "");
1282: logger.log(Level.FINEST, "PSDT_CSPPCTTL0015",
1283: channelsRow.get(two[i]));
1284: logger.log(Level.FINEST, "PSDT_CSPPCTTL0016",
1285: channelsColumn.get(two[i]));
1286: }
1287: }
1288:
1289: if (fulltop != null) {
1290: for (int i = 0; i < fulltop.length; i++) {
1291: if (fulltop[i].equals(".none")
1292: || fulltop[i].equals("spacer")) {
1293: continue;
1294: }
1295: channelsRow.put(fulltop[i], (i + 1) + "");
1296: }
1297: }
1298:
1299: if (fullbottom != null) {
1300: for (int i = 0; i < fullbottom.length; i++) {
1301: if (fullbottom[i].equals(".none")
1302: || fullbottom[i].equals("spacer")) {
1303: continue;
1304: }
1305: channelsRow.put(fullbottom[i], (i + 1) + "");
1306: }
1307: }
1308: }
1309: }
1310: setMapProperty(CHANNELS_COLUMN, channelsColumn);
1311: setMapProperty(CHANNELS_ROW, channelsRow);
1312: }
1313: return null;
1314: }
1315:
1316: public StringBuffer getLayoutEdit(HttpServletRequest req,
1317: HttpServletResponse res) throws ProviderException {
1318: String layoutTemplate = null;
1319: ContainerProviderContext cpc = getContainerProviderContext();
1320: ProviderContext pc = getProviderContext();
1321:
1322: String charset = pc.getCharset();
1323:
1324: //
1325: // init this stuff once
1326: //
1327: List userProviders = null;
1328:
1329: userProviders = ProviderOrder.order(getSelectedChannels(),
1330: getName(), cpc, req);
1331:
1332: int size = userProviders.size();
1333:
1334: StringBuffer leftUserProviderList = new StringBuffer();
1335: leftUserProviderList.append("<SELECT NAME=\"one\" SIZE=")
1336: .append(size).append(" MULTIPLE>");
1337:
1338: StringBuffer centerUserProviderList = new StringBuffer();
1339: centerUserProviderList.append("<SELECT NAME=\"three\" SIZE=")
1340: .append(size).append(" MULTIPLE>");
1341:
1342: StringBuffer rightUserProviderList = new StringBuffer();
1343: rightUserProviderList.append("<SELECT NAME=\"two\" SIZE=")
1344: .append(size).append(" MULTIPLE>");
1345:
1346: StringBuffer fulltopUserProviderList = new StringBuffer();
1347: fulltopUserProviderList
1348: .append("<SELECT NAME=\"fulltop\" SIZE=").append(size)
1349: .append(" MULTIPLE>");
1350:
1351: StringBuffer fullbottomUserProviderList = new StringBuffer();
1352: fullbottomUserProviderList.append(
1353: "<SELECT NAME=\"fullbottom\" SIZE=").append(size)
1354: .append(" MULTIPLE>");
1355:
1356: int layout = -1;
1357: layout = getIntegerProperty(LAYOUT);
1358:
1359: //sanitary check
1360: switch (layout) {
1361: case Layout.LAYOUT_THIN_THICK:
1362: case Layout.LAYOUT_THICK_THIN:
1363: case Layout.LAYOUT_THIN_THICK_THIN:
1364: case Layout.LAYOUT_THIN_THIN_THIN:
1365: break;
1366: default:
1367: throw new ProviderException(
1368: "FrontProvider.getLayoutEdit: invalid layout");
1369: }
1370:
1371: boolean hasFullTop = false;
1372: boolean hasFullBottom = false;
1373:
1374: Map layout_channelsColumn = null;
1375: Map channelsMovable = null;
1376:
1377: layout_channelsColumn = getMapProperty(CHANNELS_COLUMN);
1378: channelsMovable = getMapProperty(CHANNELS_IS_MOVABLE);
1379:
1380: for (int i = 0; i < userProviders.size(); i++) {
1381: //
1382: // build up provider selects.
1383: // there's no reason to switch on the layout type for each iteration
1384: // of the loop. the reason why this is done is to avoid
1385: // duplicating common code in each of the switch blocks.
1386: //
1387: String providerName = (String) userProviders.get(i);
1388:
1389: if (!checkSelChannelInAvailList(providerName)) {
1390: continue;
1391: }
1392:
1393: Provider theProvider = null;
1394: theProvider = cpc.getProvider(req, getName(), providerName);
1395:
1396: if (theProvider == null) {
1397: logger.log(Level.INFO, "PSDT_CSPPCTTL0010",
1398: providerName);
1399: continue;
1400: }
1401:
1402: String title = theProvider.getTitle();
1403: int width = 1;
1404: int column = 1;
1405: boolean dIsMovable = getBooleanProperty(DEFAULT_CHANNEL_IS_MOVABLE);
1406: boolean presentable = theProvider.isPresentable(req);
1407: String defaultChannelColumn = getStringProperty(DEFAULT_CHANNEL_COLUMN);
1408: try {
1409: width = theProvider.getWidth();
1410: column = Integer.parseInt(PropertyUtil
1411: .getStringValueFromMap(layout_channelsColumn,
1412: providerName, defaultChannelColumn));
1413: logger.log(Level.FINEST, "PSDT_CSPPCTTL0017", ""
1414: + column);
1415: } catch (NumberFormatException e) {
1416: throw new ProviderException(
1417: "FrontProvider.buildPage(): got NumberFormatException for column");
1418: }
1419:
1420: if (!PropertyUtil.getBooleanValueFromMap(channelsMovable,
1421: providerName, dIsMovable)
1422: || !presentable) {
1423: continue;
1424: }
1425:
1426: String providerOption = genProviderOption(providerName,
1427: title);
1428:
1429: switch (width) {
1430: case ProviderWidths.WIDTH_FULL_TOP:
1431: fulltopUserProviderList.append(providerOption);
1432: hasFullTop = true;
1433: break;
1434:
1435: case ProviderWidths.WIDTH_FULL_BOTTOM:
1436: fullbottomUserProviderList.append(providerOption);
1437: hasFullBottom = true;
1438: break;
1439:
1440: case ProviderWidths.WIDTH_THIN:
1441: switch (layout) {
1442: //thin, wide
1443: case Layout.LAYOUT_THIN_THICK:
1444: leftUserProviderList.append(providerOption);
1445: break;
1446: case Layout.LAYOUT_THICK_THIN:
1447: rightUserProviderList.append(providerOption);
1448: break;
1449: case Layout.LAYOUT_THIN_THICK_THIN:
1450: StringBuffer list = null;
1451: if (column == 1) {
1452: list = leftUserProviderList;
1453: } else {
1454: list = rightUserProviderList;
1455: }
1456: list.append(providerOption);
1457: break;
1458:
1459: case Layout.LAYOUT_THIN_THIN_THIN:
1460: StringBuffer list2 = null;
1461: if (column == 1) {
1462: list2 = leftUserProviderList;
1463: } else if (column == 3) {
1464: list2 = centerUserProviderList;
1465: } else if (column == 2) {
1466: list2 = rightUserProviderList;
1467: }
1468: list2.append(providerOption);
1469: break;
1470: }
1471: break;
1472:
1473: case ProviderWidths.WIDTH_THICK:
1474: switch (layout) {
1475: case Layout.LAYOUT_THIN_THICK:
1476: rightUserProviderList.append(providerOption);
1477: break;
1478: case Layout.LAYOUT_THICK_THIN:
1479: leftUserProviderList.append(providerOption);
1480: break;
1481: case Layout.LAYOUT_THIN_THICK_THIN:
1482: centerUserProviderList.append(providerOption);
1483: break;
1484: case Layout.LAYOUT_THIN_THIN_THIN:
1485: logger.log(Level.INFO, "PSDT_CSPPCTTL0018");
1486: break;
1487: }
1488: break;
1489: }
1490: }
1491:
1492: //
1493: // center list may not be used, but doesn't hurt to put it and
1494: // reduces code
1495: //
1496: leftUserProviderList.append(genProviderOption("spacer",
1497: "---------------------------------"));
1498: leftUserProviderList.append("</SELECT>");
1499: centerUserProviderList.append(genProviderOption("spacer",
1500: "---------------------------------"));
1501: centerUserProviderList.append("</SELECT>");
1502: rightUserProviderList.append(genProviderOption("spacer",
1503: "---------------------------------"));
1504: rightUserProviderList.append("</SELECT>");
1505: fulltopUserProviderList.append(genProviderOption("spacer",
1506: "---------------------------------"));
1507: fulltopUserProviderList.append("</SELECT>");
1508: fullbottomUserProviderList.append(genProviderOption("spacer",
1509: "---------------------------------"));
1510: fullbottomUserProviderList.append("</SELECT>");
1511:
1512: Hashtable tags = getStandardTags(req);
1513: String selected = req.getParameter("selected");
1514: if (selected != null && selected.length() != 0) {
1515: tags.put(SELECTED_TAB_NAME, selected);
1516: tags.put("selectedName", getProviderContext()
1517: .encodeURLParameter(selected));
1518: }
1519: tags.put(CONTENT_BAR_IN_LAYOUT,
1520: getTemplate(CONTENT_BAR_IN_LAYOUT_TEMPLATE));
1521: tags.put(FRONT_CONTAINER_NAME, getName());
1522: tags.put("help_link", getHelpLink("layoutPage", req));
1523: tags.put("leftUserProviderList", leftUserProviderList
1524: .toString());
1525: tags.put("centerUserProviderList", centerUserProviderList
1526: .toString());
1527: tags.put("rightUserProviderList", rightUserProviderList
1528: .toString());
1529:
1530: tags.put("arrangeProvider", getTemplate(ARRANGE_PROVIDER_JS));
1531:
1532: tags.put("removeProvider", getTemplate(REMOVE_PROVIDER_JS));
1533:
1534: tags.put("performSubstitution",
1535: getTemplate(PERFORM_SUBSTITUTION_JS));
1536:
1537: tags.put("performColumnSubstitution",
1538: getTemplate(PERFORM_COLUMN_SUBSTITUTION_JS));
1539:
1540: tags.put("selectAll", getTemplate(SELECT_ALL_JS));
1541:
1542: tags.put("switchColumns", getTemplate(SWITCH_COLUMNS_JS));
1543:
1544: if (hasFullTop) {
1545: tags.put("fulltopUserProviderList", fulltopUserProviderList
1546: .toString());
1547: tags.put("layoutFullTop",
1548: getTemplate(LAYOUT_FULL_TOP_TEMPLATE));
1549: } else
1550: tags.put("layoutFullTop", new String());
1551:
1552: if (hasFullBottom) {
1553: tags.put("fullbottomUserProviderList",
1554: fullbottomUserProviderList.toString());
1555: tags.put("layoutFullBottom",
1556: getTemplate(LAYOUT_FULL_BOTTOM_TEMPLATE));
1557: } else
1558: tags.put("layoutFullBottom", new String());
1559:
1560: StringBuffer ob = getTemplate((String) templateMap.get(Integer
1561: .toString(layout)), tags);
1562:
1563: return (ob);
1564: }
1565:
1566: private static String genProviderOption(String providerName,
1567: String title) {
1568: StringBuffer list = new StringBuffer(64);
1569: list.append("<OPTION VALUE=").append(providerName).append("> ")
1570: .append(title).append("</OPTION>\n");
1571:
1572: return list.toString();
1573: }
1574:
1575: public StringBuffer getPopupProviderContents(
1576: HttpServletRequest req, HttpServletResponse res)
1577: throws ProviderException {
1578:
1579: ContainerProviderContext cpc = getContainerProviderContext();
1580: String desktopURL = cpc.getDesktopURL(req);
1581: String sContext = cpc.getStaticContentPath();
1582: Provider cp = null;
1583: ResourceBundle bundle = getResourceBundle();
1584:
1585: StringBuffer provider_cmds = new StringBuffer();
1586: String providerName = req.getParameter(getName()
1587: + ".targetProvider");
1588:
1589: Map channelsIsDetached = getMapProperty(CHANNELS_IS_DETACHED);
1590: Map channelsIsDetachable = getMapProperty(CHANNELS_IS_DETACHABLE);
1591: Map channelsIsMinimized = getMapProperty(CHANNELS_IS_MINIMIZED);
1592: Map channelsIsMinimizable = getMapProperty(CHANNELS_IS_MINIMIZABLE);
1593: Map channelsIsMaximizable = Collections.EMPTY_MAP;
1594: String maximizedChannel = "";
1595: boolean dIsMaximizable = false;
1596: try {
1597: if (getProviderContext().getProviderVersion(getName()) > 1) {
1598: channelsIsMaximizable = getMapProperty(CHANNELS_IS_MAXIMIZABLE);
1599: maximizedChannel = getStringProperty(MAXIMIZED_CHANNEL);
1600: dIsMaximizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MAXIMIZABLE);
1601: }
1602: } catch (ProviderContextException pce) {
1603: logger.log(Level.WARNING, "PSDT_CSPPCTTL0009", pce);
1604: }
1605:
1606: Map channelsIsRemovable = getMapProperty(CHANNELS_IS_REMOVABLE);
1607: Map channelsBackgroundColor = getMapProperty(CHANNELS_BACKGROUND_COLOR);
1608:
1609: boolean dIsMinimizable = getBooleanProperty(DEFAULT_CHANNEL_IS_MINIMIZABLE);
1610: boolean dIsDetachable = getBooleanProperty(DEFAULT_CHANNEL_IS_DETACHABLE);
1611: boolean dIsRemovable = getBooleanProperty(DEFAULT_CHANNEL_IS_REMOVABLE);
1612: boolean dIsMinimized = getBooleanProperty(DEFAULT_CHANNEL_IS_MINIMIZED);
1613: boolean dIsDetached = getBooleanProperty(DEFAULT_CHANNEL_IS_DETACHED);
1614:
1615: cp = cpc.getProvider(req, getName(), providerName);
1616:
1617: StringBuffer content = null;
1618: try {
1619: content = cp.getContent(req, res);
1620: } catch (ProviderException pe) {
1621: throw new ProviderException(
1622: "PopupProvider.getContent():Contents for providerName="
1623: + providerName + " is null");
1624: }
1625:
1626: String providerTitle = cp.getTitle();
1627: providerName = cp.getName();
1628:
1629: String title = cp.getTitle();
1630:
1631: Hashtable tags = getStandardTags(req);
1632:
1633: //get default background color and images from Theme
1634: String bgColor = null;
1635: Map themeMap = null;
1636: try {
1637: themeMap = Theme.getMap(getName(), cpc, Theme
1638: .getSelectedName(getName(), cpc));
1639: } catch (ProviderContextException pce) {
1640: throw new ProviderException(
1641: "TemplateTableContainerProvider.getPopupProviderContent(): failed to get theme related attribute",
1642: pce);
1643: }
1644:
1645: String dBgColor = (String) themeMap.get(BG_COLOR);
1646: String normalizeImage = (String) themeMap.get(NORMALIZE_IMAGE);
1647: String maximizeImage = (String) themeMap.get(MAXIMIZE_IMAGE);
1648: String minimizeImage = (String) themeMap.get(MINIMIZE_IMAGE);
1649: String helpImage = (String) themeMap.get(HELP_IMAGE);
1650: String editImage = (String) themeMap.get(EDIT_IMAGE);
1651: String removeImage = (String) themeMap.get(REMOVE_IMAGE);
1652: String attachImage = (String) themeMap.get(ATTACH_IMAGE);
1653: String detachImage = (String) themeMap.get(DETACH_IMAGE);
1654:
1655: Hashtable tagtable = ProviderCommands.getProviderCommands(cp,
1656: getName(), cpc, req, bundle, desktopURL, sContext,
1657: channelsIsDetachable, channelsIsDetached,
1658: channelsIsMinimizable, channelsIsMaximizable,
1659: maximizedChannel, channelsIsMinimized,
1660: channelsIsRemovable, dIsDetachable, dIsDetached,
1661: dIsMinimizable, dIsMaximizable, dIsMinimized,
1662: dIsRemovable, normalizeImage, maximizeImage,
1663: minimizeImage, helpImage, editImage, removeImage,
1664: attachImage, detachImage);
1665: tags.put(PROVIDER_CMDS, getTemplate(
1666: "providerCommands.template", tagtable));
1667:
1668: tags.put(PROVIDER_TITLE, providerTitle);
1669: tags.put(FRONT_CONTAINER_NAME, getName());
1670: tags.put(PROVIDER_NAME, providerName);
1671: tags.put(CONTENT, content.toString());
1672:
1673: tags.put(TITLE, title);
1674: tags.put(SIZE, "100%");
1675:
1676: // Need to find if channel specific background color is specified
1677: // Migration requirement
1678: if (!channelsBackgroundColor.isEmpty()) {
1679: bgColor = (String) channelsBackgroundColor
1680: .get(providerName);
1681: }
1682: if (bgColor != null)
1683: tags.put(BG_COLOR, bgColor);
1684: else
1685: tags.put(BG_COLOR, dBgColor);
1686:
1687: StringBuffer wrapContent = getTemplate(
1688: PROVIDER_WRAPPER_TEMPLATE, tags);
1689: tags.put("providerContent", wrapContent.toString());
1690:
1691: StringBuffer popup = getTemplate(POPUP_MENUBAR_TEMPLATE, tags);
1692: tags.put("popupMenubar", popup.toString());
1693:
1694: StringBuffer openURLInParent = getTemplate(OPENURL_INPARENT_JS,
1695: tags);
1696: tags.put("openURLInParent", openURLInParent.toString());
1697:
1698: StringBuffer ob = getTemplate(POPUP_TEMPLATE, tags);
1699:
1700: return (ob);
1701: }
1702:
1703: public boolean checkSelChannelInAvailList(String provider)
1704: throws ProviderException {
1705: List allProviders = getAvailableChannels();
1706: if (allProviders.contains(provider)) {
1707: return true;
1708: } else {
1709: return false;
1710: }
1711: }
1712:
1713: /**
1714: * Gets the window state of the channel.
1715: *
1716: * @param channelName channel for which the window state is requested.
1717: *
1718: * @return window state either <code>ProviderWindowStates.Maximize</code> or
1719: * <code>ProviderWindowStates.Minimize</code> or <code>ProviderWindowStates.NORMAL</code>
1720: *
1721: * @exception ProviderException
1722: * @see com.sun.portal.providers.containers.ProviderWindowStates#Minimize
1723: * @see com.sun.portal.providers.containers.ProviderWindowStates#Maximize
1724: * @see com.sun.portal.providers.containers.ProviderWindowStates#NORMAL
1725: * @see com.sun.portal.providers.containers.JSPTableContainerProvider#getWindowState
1726: */
1727: public int getWindowState(String channelName)
1728: throws ProviderException {
1729: try {
1730: Map channelsIsMinimized = getProviderContext()
1731: .getCollectionProperty(getName(),
1732: CHANNELS_IS_MINIMIZED);
1733: String maximizedChannel = "";
1734: if (getProviderContext().getProviderVersion(getName()) > 1) {
1735: maximizedChannel = getStringProperty(MAXIMIZED_CHANNEL);
1736: }
1737: if (channelsIsMinimized.containsKey(channelName)
1738: && ((Boolean) channelsIsMinimized.get(channelName))
1739: .booleanValue()) {
1740: return ProviderWindowStates.MINIMIZE;
1741: } else if (maximizedChannel.equalsIgnoreCase(channelName)) {
1742: return ProviderWindowStates.MAXIMIZE;
1743: } else {
1744: return ProviderWindowStates.NORMAL;
1745: }
1746: } catch (ProviderContextException pce) {
1747: throw new ProviderException(
1748: "JSPTableContainerProvider.getWindowState: ", pce);
1749: }
1750: }
1751:
1752: /**
1753: * Sets the window state of a channel.
1754: *
1755: * @param channelName channel for which the window state needs to be set
1756: * @param windowState The new window state either <code>ProviderWindowStates.Maximize</code> or
1757: * <code>ProviderWindowStates.Minimize</code> or <code>ProviderWindowStates.NORMAL</code>
1758: *
1759: * @exception UnsupportedWindowStateException if the window state passed in is not in
1760: * supported window states list.
1761: * @see com.sun.portal.providers.containers.ProviderWindowStates#Minimize
1762: * @see com.sun.portal.providers.containers.ProviderWindowStates#Maximize
1763: * @see com.sun.portal.providers.containers.ProviderWindowStates#NORMAL
1764: * @see com.sun.portal.providers.containers.JSPTableContainerProvider#getWindowState
1765: * @see com.sun.portal.providers.containers.JSPTableContainerProvider#getSupportedWindowStates()
1766: */
1767: public void setWindowState(String channelName, int windowState)
1768: throws UnsupportedWindowStateException {
1769: try {
1770: Map channelsIsMinimized = getProviderContext()
1771: .getCollectionProperty(getName(),
1772: CHANNELS_IS_MINIMIZED);
1773: String maximizedChannel = "";
1774: if (getProviderContext().getProviderVersion(getName()) > 1) {
1775: maximizedChannel = getStringProperty(MAXIMIZED_CHANNEL);
1776: }
1777: if (windowState == ProviderWindowStates.MINIMIZE) {
1778: Boolean minimize_value = Boolean.TRUE;
1779: channelsIsMinimized.put(channelName, minimize_value);
1780: getProviderContext().setCollectionProperty(getName(),
1781: CHANNELS_IS_MINIMIZED, channelsIsMinimized);
1782: //if this channel is previously maximized, remove it from maximized.
1783: if (maximizedChannel.equalsIgnoreCase(channelName)) {
1784: setStringProperty(MAXIMIZED_CHANNEL, "");
1785: }
1786: } else if (windowState == ProviderWindowStates.NORMAL) {
1787: Boolean maximize_value = Boolean.FALSE;
1788: channelsIsMinimized.put(channelName, maximize_value);
1789: getProviderContext().setCollectionProperty(getName(),
1790: CHANNELS_IS_MINIMIZED, channelsIsMinimized);
1791: //remove it from maximized
1792: if (maximizedChannel.equalsIgnoreCase(channelName)) {
1793: setStringProperty(MAXIMIZED_CHANNEL, "");
1794: }
1795: } else if (windowState == ProviderWindowStates.MAXIMIZE) {
1796: if (getProviderContext().getProviderVersion(getName()) > 1) {
1797: setStringProperty(MAXIMIZED_CHANNEL, channelName);
1798: } else {
1799: throw new UnsupportedWindowStateException(
1800: "window state MAXIMIZE is not supported");
1801: }
1802: Boolean minimize_value = Boolean.FALSE;
1803: channelsIsMinimized.put(channelName, minimize_value);
1804: getProviderContext().setCollectionProperty(getName(),
1805: CHANNELS_IS_MINIMIZED, channelsIsMinimized);
1806: } else {
1807: throw new UnsupportedWindowStateException(
1808: "window state passed in is not supported");
1809: }
1810: } catch (ProviderContextException pce) {
1811: throw new UnsupportedWindowStateException(
1812: "JSPTableContainerProvider.setWindowState: ", pce);
1813: } catch (ProviderException pe) {
1814: throw new UnsupportedWindowStateException(
1815: "JSPTableContainerProvider.setWindowState: ", pe);
1816: }
1817: }
1818:
1819: /**
1820: * Gets the supported window states.
1821: *
1822: * @return Supported Window States as an integer array containing
1823: * <code>ProviderWindowStates.Maximize</code>,
1824: * <code>ProviderWindowStates.Minimize</code>, <code>ProviderWindowStates.NORMAL</code>
1825: *
1826: * @exception ProviderException If the window states cannot be returned.
1827: *
1828: * @see com.sun.portal.providers.containers.ProviderWindowStates#Minimize
1829: * @see com.sun.portal.providers.containers.ProviderWindowStates#Maximize
1830: * @see com.sun.portal.providers.containers.ProviderWindowStates#NORMAL
1831: * @see com.sun.portal.providers.containers.ContainerProvider#getWindowState()
1832: * @see com.sun.portal.providers.containers.ContainerProvider#setWindowState()
1833: */
1834: public int[] getSupportedWindowStates() throws ProviderException {
1835: return supportedStates;
1836: }
1837:
1838: }
|