diff options
Diffstat (limited to 'src/com/itmill/toolkit/terminal/gwt/server/ApplicationManager.java')
| -rw-r--r-- | src/com/itmill/toolkit/terminal/gwt/server/ApplicationManager.java | 929 |
1 files changed, 929 insertions, 0 deletions
diff --git a/src/com/itmill/toolkit/terminal/gwt/server/ApplicationManager.java b/src/com/itmill/toolkit/terminal/gwt/server/ApplicationManager.java new file mode 100644 index 0000000000..3a3c27af53 --- /dev/null +++ b/src/com/itmill/toolkit/terminal/gwt/server/ApplicationManager.java @@ -0,0 +1,929 @@ +/* ************************************************************************* + + IT Mill Toolkit + + Development of Browser User Interfaces Made Easy + + Copyright (C) 2000-2006 IT Mill Ltd + + ************************************************************************* + + This product is distributed under commercial license that can be found + from the product package on license.pdf. Use of this product might + require purchasing a commercial license from IT Mill Ltd. For guidelines + on usage, see licensing-guidelines.html + + ************************************************************************* + + For more information, contact: + + IT Mill Ltd phone: +358 2 4802 7180 + Ruukinkatu 2-4 fax: +358 2 4802 7181 + 20540, Turku email: info@itmill.com + Finland company www: www.itmill.com + + Primary source for information and releases: www.itmill.com + + ********************************************************************** */ + +package com.itmill.toolkit.terminal.gwt.server; + +import java.io.BufferedWriter; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.text.DateFormatSymbols; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; +import java.util.Comparator; +import java.util.GregorianCalendar; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.WeakHashMap; + +import javax.servlet.ServletException; +import javax.servlet.ServletOutputStream; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import com.itmill.toolkit.Application; +import com.itmill.toolkit.Application.WindowAttachEvent; +import com.itmill.toolkit.Application.WindowDetachEvent; +import com.itmill.toolkit.terminal.DownloadStream; +import com.itmill.toolkit.terminal.PaintTarget; +import com.itmill.toolkit.terminal.Paintable; +import com.itmill.toolkit.terminal.URIHandler; +import com.itmill.toolkit.terminal.Paintable.RepaintRequestEvent; +import com.itmill.toolkit.ui.Component; +import com.itmill.toolkit.ui.FrameWindow; +import com.itmill.toolkit.ui.Window; + +/** + * Application manager processes changes and paints for single application + * instance. + * + * @author IT Mill Ltd. + * @version + * @VERSION@ + * @since 5.0 + */ +public class ApplicationManager implements + Paintable.RepaintRequestListener, Application.WindowAttachListener, + Application.WindowDetachListener { + + private static String GET_PARAM_REPAINT_ALL = "repaintAll"; + + private static int DEFAULT_BUFFER_SIZE = 32 * 1024; + + private static int MAX_BUFFER_SIZE = 64 * 1024; + + private WeakHashMap applicationToVariableMapMap = new WeakHashMap(); + + private HashSet dirtyPaintabletSet = new HashSet(); + + + // TODO THIS TEMPORARY HACK IS ONLY HERE TO MAKE GWT DEVEL EASIER + static WeakHashMap paintableIdMap = new WeakHashMap(); + + private int idSequence = 0; + + private Application application; + + private Set removedWindows = new HashSet(); + + private JsonPaintTarget paintTarget; + + private List locales; + + private int pendingLocalesIndex; + + private ApplicationServlet applicationServlet; + + public ApplicationManager(Application application, ApplicationServlet applicationServlet) { + this.application = application; + this.applicationServlet = applicationServlet; + requireLocale(application.getLocale().toString()); + } + + /** + * + * @return + */ + private AjaxVariableMap getVariableMap() { + AjaxVariableMap vm = (AjaxVariableMap) applicationToVariableMapMap + .get(application); + if (vm == null) { + vm = new AjaxVariableMap(); + applicationToVariableMapMap.put(application, vm); + } + return vm; + } + + /** + * + * + */ + public void takeControl() { + application.addListener((Application.WindowAttachListener) this); + application.addListener((Application.WindowDetachListener) this); + + } + + /** + * + * + */ + public void releaseControl() { + application.removeListener((Application.WindowAttachListener) this); + application.removeListener((Application.WindowDetachListener) this); + } + + + public void handleUidlRequest(HttpServletRequest request, + HttpServletResponse response) throws IOException { + + // repaint requested or sesssion has timed out and new one is created + boolean repaintAll = (request.getParameter(GET_PARAM_REPAINT_ALL) != null) + || request.getSession().isNew(); + + OutputStream out = response.getOutputStream(); + PrintWriter outWriter = new PrintWriter(new BufferedWriter( + new OutputStreamWriter(out, "UTF-8"))); + + outWriter.print(")/*{"); // some dirt to prevent cross site scripting vulnerabilities + + try { + + // Is this a download request from application + DownloadStream download = null; + + // The rest of the process is synchronized with the application + // in order to guarantee that no parallel variable handling is + // made + synchronized (application) { + + // Change all variables based on request parameters + Map unhandledParameters = getVariableMap().handleVariables( + request, application); + + // Handles the URI if the application is still running + if (application.isRunning()) + download = handleURI(application, request, response); + + // If this is not a download request + if (download == null) { + + // Finds the window within the application + Window window = null; + if (application.isRunning()) + window = getApplicationWindow(request, application); + + // Handles the unhandled parameters if the application is + // still running + if (window != null && unhandledParameters != null + && !unhandledParameters.isEmpty()) + window.handleParameters(unhandledParameters); + + // Removes application if it has stopped + if (!application.isRunning()) { + endApplication(request, response, application); + return; + } + + // Returns if no window found + if (window == null) + return; + + // Sets the response type + response.setContentType("application/json; charset=UTF-8"); + outWriter.print("\"changes\":["); + + paintTarget = new JsonPaintTarget(getVariableMap(), + this, outWriter); + + // Paints components + Set paintables; + if (repaintAll) { + paintables = new LinkedHashSet(); + paintables.add(window); + + // Reset sent locales + locales = null; + requireLocale(application.getLocale().toString()); + + // Adds all non-native windows + for (Iterator i = window.getApplication().getWindows() + .iterator(); i.hasNext();) { + Window w = (Window) i.next(); + if (!"native".equals(w.getStyle()) && w != window) + paintables.add(w); + } + } else + paintables = getDirtyComponents(); + if (paintables != null) { + + // Creates "working copy" of the current state. + List currentPaintables = new ArrayList(paintables); + + // Sorts the paintable so that parent windows + // are always painted before child windows + Collections.sort(currentPaintables, new Comparator() { + + public int compare(Object o1, Object o2) { + + // If first argumement is now window + // the second is "smaller" if it is. + if (!(o1 instanceof Window)) { + return (o2 instanceof Window) ? 1 : 0; + } + + // Now, if second is not window the + // first is smaller. + if (!(o2 instanceof Window)) { + return -1; + } + + // Both are windows. + String n1 = ((Window) o1).getName(); + String n2 = ((Window) o2).getName(); + if (o1 instanceof FrameWindow) { + if (((FrameWindow) o1).getFrameset() + .getFrame(n2) != null) { + return -1; + } else if (!(o2 instanceof FrameWindow)) { + return -1; + } + } + if (o2 instanceof FrameWindow) { + if (((FrameWindow) o2).getFrameset() + .getFrame(n1) != null) { + return 1; + } else if (!(o1 instanceof FrameWindow)) { + return 1; + } + } + + return 0; + } + }); + + for (Iterator i = currentPaintables.iterator(); i + .hasNext();) { + Paintable p = (Paintable) i.next(); + + // TODO CLEAN + if (p instanceof Window) { + Window w = (Window) p; + if (w.getTerminal() == null) + w.setTerminal(application.getMainWindow() + .getTerminal()); + } + + paintTarget.startTag("change"); + paintTarget.addAttribute("format", "uidl"); + String pid = getPaintableId(p); + paintTarget.addAttribute("pid", pid); + + // Track paints to identify empty paints + paintTarget.setTrackPaints(true); + p.paint(paintTarget); + + // If no paints add attribute empty + if (paintTarget.getNumberOfPaints() <= 0) { + paintTarget.addAttribute("visible", false); + } + paintTarget.endTag("change"); + paintablePainted(p); + } + } + + + paintTarget.close(); + outWriter.print("]"); // close changes + + + // Render the removed windows + // TODO refactor commented area to send some meta instructions to close window +// Set removed = new HashSet(getRemovedWindows()); +// if (removed.size() > 0) { +// for (Iterator i = removed.iterator(); i.hasNext();) { +// Window w = (Window) i.next(); +// paintTarget.startTag("change"); +// paintTarget.addAttribute("format", "uidl"); +// String pid = getPaintableId(w); +// paintTarget.addAttribute("pid", pid); +// paintTarget.addAttribute("windowname", w.getName()); +// paintTarget.addAttribute("visible", false); +// paintTarget.endTag("change"); +// removedWindowNotified(w); +// +// } +// } + + + + outWriter.print(", \"meta\" : {"); + boolean metaOpen = false; + + + // .. or initializion (first uidl-request) + if(application.ajaxInit()) { + outWriter.print("\"appInit\":true"); + } + // add meta instruction for client to set focus if it is set + Paintable f = (Paintable) application.consumeFocus(); + if(f != null) { + if(metaOpen) + outWriter.append(","); + outWriter.write("\"focus\":\""+ getPaintableId(f) +"\""); + } + + outWriter.print("}, \"resources\" : {"); + + // Precache custom layouts + // TODO Does not support theme-get param or different themes in different windows -> Allways preload layouts with the theme specified by the applications + String themeName = application.getTheme() != null ? application.getTheme() : ApplicationServlet.DEFAULT_THEME; + // TODO We should only precache the layouts that are not cached already + int resourceIndex = 0; + for (Iterator i=paintTarget.getPreCachedResources().iterator(); i.hasNext();) { + String resource = (String) i.next(); + InputStream is = null; + try { + is = applicationServlet.getServletContext().getResourceAsStream(ApplicationServlet.THEME_DIRECTORY_PATH + themeName + "/" + resource); + } catch (Exception e) { + Log.info(e.getMessage()); + } + if (is != null) { + + outWriter.print((resourceIndex++ > 0 ? ", " : "") + "\""+resource + "\" : "); + StringBuffer layout = new StringBuffer(); + + try { + InputStreamReader r = new InputStreamReader(is); + char[] buffer = new char[20000]; + int charsRead = 0; + while ((charsRead = r.read(buffer)) > 0) + layout.append(buffer, 0, charsRead); + r.close(); + } catch (java.io.IOException e) { + Log.info("Resource transfer failed: " + request.getRequestURI() + + ". (" + e.getMessage() + ")"); + } + outWriter.print("\"" + JsonPaintTarget.escapeJSON(layout.toString()) + "\""); + } + } + outWriter.print("}"); + + + /* ----------------------------- + * Sending Locale sensitive date + * ----------------------------- + */ + + // Store JVM default locale for later restoration + // (we'll have to change the default locale for a while) + Locale jvmDefault = Locale.getDefault(); + + // Send locale informations to client + outWriter.print(", \"locales\":["); + for(;pendingLocalesIndex < locales.size(); pendingLocalesIndex++) { + + Locale l = generateLocale((String) locales.get(pendingLocalesIndex)); + // Locale name + outWriter.print("{\"name\":\"" + l.toString() + "\","); + + /* + * Month names (both short and full) + */ + DateFormatSymbols dfs = new DateFormatSymbols(l); + String[] short_months = dfs.getShortMonths(); + String[] months = dfs.getMonths(); + outWriter.print("\"smn\":[\"" + // ShortMonthNames + short_months[0] + "\",\"" + + short_months[1] + "\",\"" + + short_months[2] + "\",\"" + + short_months[3] + "\",\"" + + short_months[4] + "\",\"" + + short_months[5] + "\",\"" + + short_months[6] + "\",\"" + + short_months[7] + "\",\"" + + short_months[8] + "\",\"" + + short_months[9] + "\",\"" + + short_months[10] + "\",\"" + + short_months[11] + "\"" + + "],"); + outWriter.print("\"mn\":[\"" + // MonthNames + months[0] + "\",\"" + + months[1] + "\",\"" + + months[2] + "\",\"" + + months[3] + "\",\"" + + months[4] + "\",\"" + + months[5] + "\",\"" + + months[6] + "\",\"" + + months[7] + "\",\"" + + months[8] + "\",\"" + + months[9] + "\",\"" + + months[10] + "\",\"" + + months[11] + "\"" + + "],"); + + /* + * Weekday names (both short and full) + */ + String[] short_days = dfs.getShortWeekdays(); + String[] days = dfs.getWeekdays(); + outWriter.print("\"sdn\":[\"" + // ShortDayNames + short_days[1] + "\",\"" + + short_days[2] + "\",\"" + + short_days[3] + "\",\"" + + short_days[4] + "\",\"" + + short_days[5] + "\",\"" + + short_days[6] + "\",\"" + + short_days[7] + "\"" + + "],"); + outWriter.print("\"dn\":[\"" + // DayNames + days[1] + "\",\"" + + days[2] + "\",\"" + + days[3] + "\",\"" + + days[4] + "\",\"" + + days[5] + "\",\"" + + days[6] + "\",\"" + + days[7] + "\"" + + "],"); + + /* + * First day of week (0 = sunday, 1 = monday) + */ + Calendar cal = new GregorianCalendar(l); + outWriter.print("\"fdow\":" + (cal.getFirstDayOfWeek() - 1) + ","); + + /* + * Date formatting (MM/DD/YYYY etc.) + */ + // Force our locale as JVM default for a while (SimpleDateFormat uses JVM default) + Locale.setDefault(l); + String df = new SimpleDateFormat().toPattern(); + int timeStart = df.indexOf("H"); + if(timeStart < 0) + timeStart = df.indexOf("h"); + int ampm_first = df.indexOf("a"); + // E.g. in Korean locale AM/PM is before h:mm + // TODO should take that into consideration on client-side as well, now always h:mm a + if(ampm_first > 0 && ampm_first < timeStart) + timeStart = ampm_first; + String dateformat = df.substring(0, timeStart-1); + + outWriter.print("\"df\":\"" + dateformat.trim() + "\","); + + /* + * Time formatting (24 or 12 hour clock and AM/PM suffixes) + */ + String timeformat = df.substring(timeStart, df.length()); // Doesn't return second or milliseconds + // We use timeformat to determine 12/24-hour clock + boolean twelve_hour_clock = timeformat.contains("a"); + // TODO there are other possibilities as well, like 'h' in french (ignore them, too complicated) + String hour_min_delimiter = timeformat.contains(".")? "." : ":"; + //outWriter.print("\"tf\":\"" + timeformat + "\","); + outWriter.print("\"thc\":" + twelve_hour_clock + ","); + outWriter.print("\"hmd\":\"" + hour_min_delimiter + "\""); + if(twelve_hour_clock) { + String[] ampm = dfs.getAmPmStrings(); + outWriter.print(",\"ampm\":[\""+ampm[0]+"\",\""+ampm[1]+"\"]"); + } + outWriter.print("}"); + if(pendingLocalesIndex < locales.size()-1) + outWriter.print(","); + } + outWriter.print("]"); // Close locales + + // Restore JVM default locale + Locale.setDefault(jvmDefault); + + outWriter.flush(); + outWriter.close(); + out.flush(); + } else { + + // For download request, transfer the downloaded data + handleDownload(download, request, response); + } + } + + out.flush(); + out.close(); + + } catch (Throwable e) { + // Writes the error report to client + OutputStreamWriter w = new OutputStreamWriter(out); + PrintWriter err = new PrintWriter(w); + err + .write("<html><head><title>Application Internal Error</title></head><body>"); + err.write("<h1>" + e.toString() + "</h1><pre>\n"); + e.printStackTrace(new PrintWriter(err)); + err.write("\n</pre></body></html>"); + err.close(); + } finally { + + } + + } + + /** + * Gets the existing application or create a new one. Get a window within an + * application based on the requested URI. + * + * @param request + * the HTTP Request. + * @param application + * the Application to query for window. + * @return Window mathing the given URI or null if not found. + * @throws ServletException + * if an exception has occurred that interferes with the + * servlet's normal operation. + */ + private Window getApplicationWindow(HttpServletRequest request, + Application application) throws ServletException { + + Window window = null; + + // Find the window where the request is handled + String path = request.getPathInfo(); + + // Main window as the URI is empty + if (path == null || path.length() == 0 || path.equals("/")) + window = application.getMainWindow(); + + // Try to search by window name + else { + String windowName = null; + if (path.charAt(0) == '/') + path = path.substring(1); + int index = path.indexOf('/'); + if (index < 0) { + windowName = path; + path = ""; + } else { + windowName = path.substring(0, index); + path = path.substring(index + 1); + } + window = application.getWindow(windowName); + + // By default, we use main window + if (window == null) + window = application.getMainWindow(); + } + + return window; + } + + /** + * Handles the requested URI. An application can add handlers to do special + * processing, when a certain URI is requested. The handlers are invoked + * before any windows URIs are processed and if a DownloadStream is returned + * it is sent to the client. + * + * @param application + * the Application owning the URI. + * @param request + * the HTTP request instance. + * @param response + * the HTTP response to write to. + * @return boolean <code>true</code> if the request was handled and + * further processing should be suppressed, otherwise + * <code>false</code>. + * @see com.itmill.toolkit.terminal.URIHandler + */ + private DownloadStream handleURI(Application application, + HttpServletRequest request, HttpServletResponse response) { + + String uri = request.getPathInfo(); + + // If no URI is available + if (uri == null || uri.length() == 0 || uri.equals("/")) + return null; + + // Remove the leading / + while (uri.startsWith("/") && uri.length() > 0) + uri = uri.substring(1); + + // Handle the uri + DownloadStream stream = null; + try { + stream = application.handleURI(application.getURL(), uri); + } catch (Throwable t) { + application.terminalError(new URIHandlerErrorImpl(application, t)); + } + + return stream; + } + + /** + * Handles the requested URI. An application can add handlers to do special + * processing, when a certain URI is requested. The handlers are invoked + * before any windows URIs are processed and if a DownloadStream is returned + * it is sent to the client. + * + * @param stream + * the downloadable stream. + * + * @param request + * the HTTP request instance. + * @param response + * the HTTP response to write to. + * + * @see com.itmill.toolkit.terminal.URIHandler + */ + private void handleDownload(DownloadStream stream, + HttpServletRequest request, HttpServletResponse response) { + + // Download from given stream + InputStream data = stream.getStream(); + if (data != null) { + + // Sets content type + response.setContentType(stream.getContentType()); + + // Sets cache headers + long cacheTime = stream.getCacheTime(); + if (cacheTime <= 0) { + response.setHeader("Cache-Control", "no-cache"); + response.setHeader("Pragma", "no-cache"); + response.setDateHeader("Expires", 0); + } else { + response.setHeader("Cache-Control", "max-age=" + cacheTime + / 1000); + response.setDateHeader("Expires", System.currentTimeMillis() + + cacheTime); + response.setHeader("Pragma", "cache"); // Required to apply + // caching in some + // Tomcats + } + + // Copy download stream parameters directly + // to HTTP headers. + Iterator i = stream.getParameterNames(); + if (i != null) { + while (i.hasNext()) { + String param = (String) i.next(); + response.setHeader((String) param, stream + .getParameter(param)); + } + } + + int bufferSize = stream.getBufferSize(); + if (bufferSize <= 0 || bufferSize > MAX_BUFFER_SIZE) + bufferSize = DEFAULT_BUFFER_SIZE; + byte[] buffer = new byte[bufferSize]; + int bytesRead = 0; + + try { + OutputStream out = response.getOutputStream(); + + while ((bytesRead = data.read(buffer)) > 0) { + out.write(buffer, 0, bytesRead); + out.flush(); + } + out.close(); + } catch (IOException ignored) { + } + + } + + } + + /** + * Ends the Application. + * + * @param request + * the HTTP request instance. + * @param response + * the HTTP response to write to. + * @param application + * the Application to end. + * @throws IOException + * if the writing failed due to input/output error. + */ + private void endApplication(HttpServletRequest request, + HttpServletResponse response, Application application) + throws IOException { + + String logoutUrl = application.getLogoutURL(); + if (logoutUrl == null) + logoutUrl = application.getURL().toString(); + // clients JS app is still running, send a special xml file to + // tell client that application is quit and where to point browser now + // Set the response type + response.setContentType("application/xml; charset=UTF-8"); + ServletOutputStream out = response.getOutputStream(); + out.println("<redirect url=\"" + logoutUrl + "\">"); + out.println("</redirect>"); + } + + /** + * Gets the Paintable Id. + * + * @param paintable + * @return the paintable Id. + */ + public synchronized String getPaintableId(Paintable paintable) { + + String id = (String) paintableIdMap.get(paintable); + if (id == null) { + id = "PID" + Integer.toString(idSequence++); + paintableIdMap.put(paintable, id); + } + + return id; + } + + /** + * + * @return + */ + public synchronized Set getDirtyComponents() { + + // Remove unnecessary repaints from the list + Object[] paintables = dirtyPaintabletSet.toArray(); + for (int i = 0; i < paintables.length; i++) { + if (paintables[i] instanceof Component) { + Component c = (Component) paintables[i]; + + // Check if any of the parents of c already exist in the list + Component p = c.getParent(); + while (p != null) { + if (dirtyPaintabletSet.contains(p)) { + + // Remove component c from the dirty paintables as its + // parent is also dirty + dirtyPaintabletSet.remove(c); + p = null; + } else + p = p.getParent(); + } + } + } + + return Collections.unmodifiableSet(dirtyPaintabletSet); + } + + /** + * Clears the Dirty Components. + * + */ + public synchronized void clearDirtyComponents() { + dirtyPaintabletSet.clear(); + } + + /** + * @see com.itmill.toolkit.terminal.Paintable.RepaintRequestListener#repaintRequested(com.itmill.toolkit.terminal.Paintable.RepaintRequestEvent) + */ + public void repaintRequested(RepaintRequestEvent event) { + Paintable p = event.getPaintable(); + dirtyPaintabletSet.add(p); + + // For FrameWindows we mark all frames (windows) dirty + if (p instanceof FrameWindow) { + FrameWindow fw = (FrameWindow) p; + repaintFrameset(fw.getFrameset()); + } + } + + /** + * Recursively request repaint for all frames in frameset. + * + * @param fs + * the Framewindow.Frameset. + */ + private void repaintFrameset(FrameWindow.Frameset fs) { + List frames = fs.getFrames(); + for (Iterator i = frames.iterator(); i.hasNext();) { + FrameWindow.Frame f = (FrameWindow.Frame) i.next(); + if (f instanceof FrameWindow.Frameset) { + repaintFrameset((FrameWindow.Frameset) f); + } else { + Window w = f.getWindow(); + if (w != null) { + w.requestRepaint(); + } + } + } + } + + /** + * + * @param p + */ + public void paintablePainted(Paintable p) { + dirtyPaintabletSet.remove(p); + p.requestRepaintRequests(); + } + + /** + * + * @param paintable + * @return + */ + public boolean isDirty(Paintable paintable) { + return (dirtyPaintabletSet.contains(paintable)); + } + + /** + * @see com.itmill.toolkit.Application.WindowAttachListener#windowAttached(com.itmill.toolkit.Application.WindowAttachEvent) + */ + public void windowAttached(WindowAttachEvent event) { + event.getWindow().addListener(this); + dirtyPaintabletSet.add(event.getWindow()); + } + + /** + * @see com.itmill.toolkit.Application.WindowDetachListener#windowDetached(com.itmill.toolkit.Application.WindowDetachEvent) + */ + public void windowDetached(WindowDetachEvent event) { + event.getWindow().removeListener(this); + // Notify client of the close operation + removedWindows.add(event.getWindow()); + } + + /** + * + * @return + */ + public synchronized Set getRemovedWindows() { + return Collections.unmodifiableSet(removedWindows); + + } + + /** + * + * @param w + */ + private void removedWindowNotified(Window w) { + this.removedWindows.remove(w); + } + + /** + * Implementation of URIHandler.ErrorEvent interface. + */ + public class URIHandlerErrorImpl implements URIHandler.ErrorEvent { + + private URIHandler owner; + + private Throwable throwable; + + /** + * + * @param owner + * @param throwable + */ + private URIHandlerErrorImpl(URIHandler owner, Throwable throwable) { + this.owner = owner; + this.throwable = throwable; + } + + /** + * @see com.itmill.toolkit.terminal.Terminal.ErrorEvent#getThrowable() + */ + public Throwable getThrowable() { + return this.throwable; + } + + /** + * @see com.itmill.toolkit.terminal.URIHandler.ErrorEvent#getURIHandler() + */ + public URIHandler getURIHandler() { + return this.owner; + } + } + + public void requireLocale(String value) { + if(locales == null) { + locales = new ArrayList(); + locales.add(application.getLocale().toString()); + pendingLocalesIndex = 0; + } + if(!locales.contains(value)) + locales.add(value); + } + + private Locale generateLocale(String value) { + String[] temp = value.split("_"); + if(temp.length == 1) + return new Locale(temp[0]); + else if(temp.length == 2) + return new Locale(temp[0], temp[1]); + else + return new Locale(temp[0], temp[1], temp[2]); + } +} |