--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface JavaScript {
+ public String[] value();
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Temporary hack used for ensuring external javascript libraries are included.
- * To add a javascript, add this annotation to your Root class.
- *
- * @deprecated Will be removed in favor of a more robust solution before version
- * 7.0.0
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-@Deprecated
-public @interface LoadScripts {
- public String[] value();
-
-}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface StyleSheet {
+ public String[] value();
+}
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConfiguration.ErrorMessage;
+import com.vaadin.terminal.gwt.client.ResourceLoader.ResourceLoadEvent;
+import com.vaadin.terminal.gwt.client.ResourceLoader.ResourceLoadListener;
import com.vaadin.terminal.gwt.client.communication.HasJavaScriptConnectorHelper;
import com.vaadin.terminal.gwt.client.communication.JsonDecoder;
import com.vaadin.terminal.gwt.client.communication.JsonEncoder;
json.getValueMap("typeMappings"), widgetSet);
}
+ VConsole.log("Handling resource dependencies");
+ if (json.containsKey("scriptDependencies")) {
+ loadScriptDependencies(json.getJSStringArray("scriptDependencies"));
+ }
+ if (json.containsKey("styleDependencies")) {
+ loadStyleDependencies(json.getJSStringArray("styleDependencies"));
+ }
+
handleUIDLDuration.logDuration(
" * Handling type mappings from server completed", 10);
/*
ApplicationConfiguration.runWhenWidgetsLoaded(c);
}
+ private static void loadStyleDependencies(JsArrayString dependencies) {
+ // Assuming no reason to interpret in a defined order
+ ResourceLoadListener resourceLoadListener = new ResourceLoadListener() {
+ public void onResourceLoad(ResourceLoadEvent event) {
+ ApplicationConfiguration.endWidgetLoading();
+ }
+ };
+ ResourceLoader loader = ResourceLoader.get();
+ for (int i = 0; i < dependencies.length(); i++) {
+ ApplicationConfiguration.startWidgetLoading();
+ loader.loadStylesheet(dependencies.get(i), resourceLoadListener);
+ }
+ }
+
+ private static void loadScriptDependencies(final JsArrayString dependencies) {
+ if (dependencies.length() == 0) {
+ return;
+ }
+
+ // Listener that loads the next when one is completed
+ ResourceLoadListener resourceLoadListener = new ResourceLoadListener() {
+ public void onResourceLoad(ResourceLoadEvent event) {
+ if (dependencies.length() != 0) {
+ ApplicationConfiguration.startWidgetLoading();
+ // Load next in chain (hopefully already preloaded)
+ event.getResourceLoader().loadScript(dependencies.shift(),
+ this);
+ }
+ // Call start for next before calling end for current
+ ApplicationConfiguration.endWidgetLoading();
+ }
+ };
+
+ ResourceLoader loader = ResourceLoader.get();
+
+ // Start chain by loading first
+ ApplicationConfiguration.startWidgetLoading();
+ loader.loadScript(dependencies.shift(), resourceLoadListener);
+
+ // Preload all remaining
+ for (int i = 0; i < dependencies.length(); i++) {
+ loader.loadScript(dependencies.get(i), null);
+ }
+ }
+
// Redirect browser, null reloads current page
private static native void redirect(String url)
/*-{
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.core.client.Scheduler.RepeatingCommand;
+import com.google.gwt.dom.client.AnchorElement;
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.dom.client.LinkElement;
+import com.google.gwt.dom.client.NodeList;
+import com.google.gwt.dom.client.ObjectElement;
+import com.google.gwt.dom.client.ScriptElement;
+
+/**
+ * ResourceLoader lets you dynamically include external scripts and styles on
+ * the page and lets you know when the resource has been loaded.
+ *
+ * You can also preload resources, allowing them to get cached by the browser
+ * without being evaluated. This enables downloading multiple resources at once
+ * while still controlling in which order e.g. scripts are executed.
+ *
+ * @author Vaadin Ltd
+ * @version @VERSION@
+ * @since 7.0.0
+ */
+public class ResourceLoader {
+ /**
+ * Event fired when a resource has been loaded.
+ */
+ public static class ResourceLoadEvent {
+ private ResourceLoader loader;
+ private String resourceUrl;
+ private final boolean preload;
+
+ /**
+ * Creates a new event.
+ *
+ * @param loader
+ * the resource loader that has loaded the resource
+ * @param resourceUrl
+ * the url of the loaded resource
+ * @param preload
+ * true if the resource has only been preloaded, false if
+ * it's fully loaded
+ */
+ public ResourceLoadEvent(ResourceLoader loader, String resourceUrl,
+ boolean preload) {
+ this.loader = loader;
+ this.resourceUrl = resourceUrl;
+ this.preload = preload;
+ }
+
+ /**
+ * Gets the resource loader that has fired this event
+ *
+ * @return the resource loader
+ */
+ public ResourceLoader getResourceLoader() {
+ return loader;
+ }
+
+ /**
+ * Gets the absolute url of the loaded resource.
+ *
+ * @return the absolute url of the loaded resource
+ */
+ public String getResourceUrl() {
+ return resourceUrl;
+ }
+
+ /**
+ * Returns true if the resource has been preloaded, false if it's fully
+ * loaded
+ *
+ * @see ResourceLoader#preloadResource(String, ResourceLoadListener)
+ *
+ * @return true if the resource has been preloaded, false if it's fully
+ * loaded
+ */
+ public boolean isPreload() {
+ return preload;
+ }
+ }
+
+ /**
+ * Event listener that gets notified when a resource has been loaded
+ */
+ public interface ResourceLoadListener {
+ /**
+ * Notified this ResourceLoadListener that a resource has been loaded
+ *
+ * @see ResourceLoadEvent
+ *
+ * @param event
+ * a resource load event with information about the loaded
+ * resource
+ */
+ public void onResourceLoad(ResourceLoadEvent event);
+ }
+
+ private static final ResourceLoader INSTANCE = GWT
+ .create(ResourceLoader.class);
+
+ private ApplicationConnection connection;
+
+ private final Set<String> loadedResources = new HashSet<String>();
+ private final Set<String> preloadedResources = new HashSet<String>();
+
+ private final Map<String, Collection<ResourceLoadListener>> loadListeners = new HashMap<String, Collection<ResourceLoadListener>>();
+ private final Map<String, Collection<ResourceLoadListener>> preloadListeners = new HashMap<String, Collection<ResourceLoadListener>>();
+
+ private final Element head;
+
+ /**
+ * Creates a new resource loader. You should generally not create you own
+ * resource loader, but instead use {@link ResourceLoader#get()} to get an
+ * instance.
+ */
+ protected ResourceLoader() {
+ Document document = Document.get();
+ head = document.getElementsByTagName("head").getItem(0);
+
+ // detect already loaded scripts and stylesheets
+ NodeList<Element> scripts = document.getElementsByTagName("script");
+ for (int i = 0; i < scripts.getLength(); i++) {
+ ScriptElement element = ScriptElement.as(scripts.getItem(i));
+ String src = element.getSrc();
+ if (src != null && src.length() != 0) {
+ loadedResources.add(src);
+ }
+ }
+
+ NodeList<Element> links = document.getElementsByTagName("link");
+ for (int i = 0; i < links.getLength(); i++) {
+ LinkElement linkElement = LinkElement.as(links.getItem(i));
+ String rel = linkElement.getRel();
+ String href = linkElement.getHref();
+ if ("stylesheet".equalsIgnoreCase(rel) && href != null
+ && href.length() != 0) {
+ loadedResources.add(href);
+ }
+ }
+ }
+
+ /**
+ * Returns the default ResourceLoader
+ *
+ * @return the default ResourceLoader
+ */
+ public static ResourceLoader get() {
+ return INSTANCE;
+ }
+
+ /**
+ * Load a script and notify a listener when the script is loaded. Calling
+ * this method when the script is currently loading or already loaded
+ * doesn't cause the script to be loaded again, but the listener will still
+ * be notified when appropriate.
+ *
+ *
+ * @param scriptUrl
+ * the url of the script to load
+ * @param resourceLoadListener
+ * the listener that will get notified when the script is loaded
+ */
+ public void loadScript(final String scriptUrl,
+ final ResourceLoadListener resourceLoadListener) {
+ final String url = getAbsoluteUrl(scriptUrl);
+ if (loadedResources.contains(url)) {
+ if (resourceLoadListener != null) {
+ resourceLoadListener.onResourceLoad(new ResourceLoadEvent(this,
+ url, false));
+ }
+ return;
+ }
+
+ if (preloadListeners.containsKey(url)) {
+ preloadResource(url, new ResourceLoadListener() {
+ public void onResourceLoad(ResourceLoadEvent event) {
+ loadScript(url, resourceLoadListener);
+ }
+ });
+ return;
+ }
+
+ if (addListener(url, resourceLoadListener, loadListeners)) {
+ ScriptElement scriptTag = Document.get().createScriptElement();
+ scriptTag.setSrc(url);
+ scriptTag.setType("text/javascript");
+ addOnloadHandler(scriptTag, url, false);
+ head.appendChild(scriptTag);
+ }
+ }
+
+ private static String getAbsoluteUrl(String url) {
+ AnchorElement a = Document.get().createAnchorElement();
+ a.setHref(url);
+ return a.getHref();
+ }
+
+ /**
+ * Download a resource and notify a listener when the resource is loaded
+ * without attempting to interpret the resource. When a resource has been
+ * preloaded, it will be present in the browser's cache (provided the HTTP
+ * headers allow caching), making a subsequent load operation complete
+ * without having to wait for the resource to be downloaded again.
+ *
+ * Calling this method when the resource is currently loading, currently
+ * preloading, already preloaded or already loaded doesn't cause the
+ * resource to be preloaded again, but the listener will still be notified
+ * when appropriate.
+ *
+ * @param url
+ * the url of the resource to preload
+ * @param resourceLoadListener
+ * the listener that will get notified when the resource is
+ * preloaded
+ */
+ public void preloadResource(String url,
+ ResourceLoadListener resourceLoadListener) {
+ url = getAbsoluteUrl(url);
+ if (loadedResources.contains(url) || preloadedResources.contains(url)) {
+ if (resourceLoadListener != null) {
+ resourceLoadListener.onResourceLoad(new ResourceLoadEvent(this,
+ url, !loadedResources.contains(url)));
+ }
+ return;
+ }
+
+ if (addListener(url, resourceLoadListener, preloadListeners)
+ && !loadListeners.containsKey(url)) {
+ // Inject loader element if this is the first time this is preloaded
+ // AND the resources isn't already being loaded in the normal way
+
+ Element element = getPreloadElement(url);
+ addOnloadHandler(element, url, true);
+
+ // TODO Remove object when loaded (without causing spinner in FF)
+ Document.get().getBody().appendChild(element);
+ }
+ }
+
+ private static Element getPreloadElement(String url) {
+ if (BrowserInfo.get().isIE()) {
+ ScriptElement element = Document.get().createScriptElement();
+ element.setSrc(url);
+ element.setType("text/cache");
+ return element;
+ } else {
+ ObjectElement element = Document.get().createObjectElement();
+ element.setData(url);
+ element.setType("text/plain");
+ element.setHeight("0px");
+ element.setWidth("0px");
+ return element;
+ }
+ }
+
+ private native void addOnloadHandler(Element element, String url,
+ boolean preload)
+ /*-{
+ var self = this;
+ var done = $entry(function() {
+ element.onloadDone = true;
+ element.onload = null;
+ element.onreadystatechange = null;
+ self.@com.vaadin.terminal.gwt.client.ResourceLoader::onResourceLoad(Ljava/lang/String;Z)(url, preload);
+ });
+ element.onload = function() {
+ if (!element.onloadDone) {
+ done();
+ }
+ };
+ element.onreadystatechange = function() {
+ if (("loaded" === element.readyState || "complete" === element.readyState) && !element.onloadDone ) {
+ done();
+ }
+ };
+ }-*/;
+
+ /**
+ * Load a stylesheet and notify a listener when the stylesheet is loaded.
+ * Calling this method when the stylesheet is currently loading or already
+ * loaded doesn't cause the stylesheet to be loaded again, but the listener
+ * will still be notified when appropriate.
+ *
+ * @param stylesheetUrl
+ * the url of the stylesheet to load
+ * @param resourceLoadListener
+ * the listener that will get notified when the stylesheet is
+ * loaded
+ */
+ public void loadStylesheet(final String stylesheetUrl,
+ final ResourceLoadListener resourceLoadListener) {
+ final String url = getAbsoluteUrl(stylesheetUrl);
+ if (loadedResources.contains(url)) {
+ if (resourceLoadListener != null) {
+ resourceLoadListener.onResourceLoad(new ResourceLoadEvent(this,
+ url, false));
+ }
+ return;
+ }
+
+ if (preloadListeners.containsKey(url)) {
+ preloadResource(url, new ResourceLoadListener() {
+ public void onResourceLoad(ResourceLoadEvent event) {
+ loadStylesheet(url, resourceLoadListener);
+ }
+ });
+ return;
+ }
+
+ if (addListener(url, resourceLoadListener, loadListeners)) {
+ LinkElement linkElement = Document.get().createLinkElement();
+ linkElement.setRel("stylesheet");
+ linkElement.setType("text/css");
+ linkElement.setHref(url);
+
+ if (BrowserInfo.get().isSafari()) {
+ // Safari doesn't fire onload events for link elements
+ // See http://www.phpied.com/when-is-a-stylesheet-really-loaded/
+ // TODO Stop checking after some timeout
+ Scheduler.get().scheduleFixedPeriod(new RepeatingCommand() {
+ public boolean execute() {
+ if (isStyleSheetPresent(url)) {
+ onResourceLoad(url, false);
+ return false; // Stop repeating
+ } else {
+ return true; // Continue repeating
+ }
+ }
+ }, 10);
+ } else {
+ addOnloadHandler(linkElement, url, false);
+ }
+
+ head.appendChild(linkElement);
+ }
+ }
+
+ private static native boolean isStyleSheetPresent(String url)
+ /*-{
+ for(var i = 0; i < $doc.styleSheets.length; i++) {
+ if ($doc.styleSheets[i].href === url) {
+ return true;
+ }
+ }
+ return false;
+ }-*/;
+
+ private static boolean addListener(String url,
+ ResourceLoadListener listener,
+ Map<String, Collection<ResourceLoadListener>> listenerMap) {
+ Collection<ResourceLoadListener> listeners = listenerMap.get(url);
+ if (listeners == null) {
+ listeners = new HashSet<ResourceLoader.ResourceLoadListener>();
+ listeners.add(listener);
+ listenerMap.put(url, listeners);
+ return true;
+ } else {
+ listeners.add(listener);
+ return false;
+ }
+ }
+
+ private void onResourceLoad(String resource, boolean preload) {
+ Collection<ResourceLoadListener> listeners;
+ if (preload) {
+ preloadedResources.add(resource);
+ listeners = preloadListeners.remove(resource);
+ } else {
+ if (preloadListeners.containsKey(resource)) {
+ // Also fire preload events for potential listeners
+ onResourceLoad(resource, true);
+ }
+ preloadedResources.remove(resource);
+ loadedResources.add(resource);
+ listeners = loadListeners.remove(resource);
+ }
+ if (listeners != null && !listeners.isEmpty()) {
+ ResourceLoadEvent event = new ResourceLoadEvent(this, resource,
+ preload);
+ for (ResourceLoadListener listener : listeners) {
+ if (listener != null) {
+ listener.onResourceLoad(event);
+ }
+ }
+ }
+ }
+
+}
import java.text.SimpleDateFormat;
import java.text.StringCharacterIterator;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import com.vaadin.Application.SystemMessages;
import com.vaadin.RootRequiresMoreInformationException;
import com.vaadin.Version;
+import com.vaadin.annotations.JavaScript;
+import com.vaadin.annotations.StyleSheet;
import com.vaadin.external.json.JSONArray;
import com.vaadin.external.json.JSONException;
import com.vaadin.external.json.JSONObject;
* found
* @throws IOException
* @throws InvalidUIDLSecurityKeyException
+ * @throws JSONException
*/
public void handleUidlRequest(WrappedRequest request,
WrappedResponse response, Callback callback, Root root)
- throws IOException, InvalidUIDLSecurityKeyException {
+ throws IOException, InvalidUIDLSecurityKeyException, JSONException {
checkWidgetsetVersion(request);
requestThemeName = request.getParameter("theme");
* @param analyzeLayouts
* @throws PaintException
* @throws IOException
+ * @throws JSONException
*/
private void paintAfterVariableChanges(WrappedRequest request,
WrappedResponse response, Callback callback, boolean repaintAll,
final PrintWriter outWriter, Root root, boolean analyzeLayouts)
- throws PaintException, IOException {
+ throws PaintException, IOException, JSONException {
// Removes application if it has stopped during variable changes
if (!application.isRunning()) {
@SuppressWarnings("unchecked")
public void writeUidlResponse(WrappedRequest request, boolean repaintAll,
final PrintWriter outWriter, Root root, boolean analyzeLayouts)
- throws PaintException {
+ throws PaintException, JSONException {
ArrayList<ClientConnector> dirtyVisibleConnectors = new ArrayList<ClientConnector>();
Application application = root.getApplication();
// Paints components
boolean typeMappingsOpen = false;
ClientCache clientCache = getClientCache(root);
+ List<Class<? extends ClientConnector>> newConnectorTypes = new ArrayList<Class<? extends ClientConnector>>();
+
for (Class<? extends ClientConnector> class1 : usedClientConnectors) {
if (clientCache.cache(class1)) {
// client does not know the mapping key for this type, send
// mapping to client
+ newConnectorTypes.add(class1);
+
if (!typeMappingsOpen) {
typeMappingsOpen = true;
outWriter.print(", \"typeMappings\" : { ");
}
}
+ /*
+ * Ensure super classes come before sub classes to get script dependency
+ * order right. Sub class @JavaScript might assume that @JavaScript
+ * defined by super class is already loaded.
+ */
+ Collections.sort(newConnectorTypes, new Comparator<Class<?>>() {
+ public int compare(Class<?> o1, Class<?> o2) {
+ // TODO optimize using Class.isAssignableFrom?
+ return hierarchyDepth(o1) - hierarchyDepth(o2);
+ }
+
+ private int hierarchyDepth(Class<?> type) {
+ if (type == Object.class) {
+ return 0;
+ } else {
+ return hierarchyDepth(type.getSuperclass()) + 1;
+ }
+ }
+ });
+
+ List<String> scriptDependencies = new ArrayList<String>();
+ List<String> styleDependencies = new ArrayList<String>();
+
+ for (Class<? extends ClientConnector> class1 : newConnectorTypes) {
+ JavaScript jsAnnotation = class1.getAnnotation(JavaScript.class);
+ if (jsAnnotation != null) {
+ scriptDependencies.addAll(Arrays.asList(jsAnnotation.value()));
+ }
+
+ StyleSheet styleAnnotation = class1.getAnnotation(StyleSheet.class);
+ if (styleAnnotation != null) {
+ styleDependencies
+ .addAll(Arrays.asList(styleAnnotation.value()));
+ }
+ }
+
+ // Include script dependencies in output if there are any
+ if (!scriptDependencies.isEmpty()) {
+ outWriter.print(", \"scriptDependencies\": "
+ + new JSONArray(scriptDependencies).toString());
+ }
+
+ // Include style dependencies in output if there are any
+ if (!styleDependencies.isEmpty()) {
+ outWriter.print(", \"styleDependencies\": "
+ + new JSONArray(styleDependencies).toString());
+ }
+
// add any pending locale definitions requested by the client
printLocaleDeclarations(outWriter);
private boolean handleVariables(WrappedRequest request,
WrappedResponse response, Callback callback,
Application application2, Root root) throws IOException,
- InvalidUIDLSecurityKeyException {
+ InvalidUIDLSecurityKeyException, JSONException {
boolean success = true;
String changes = getRequestPayload(request);
* @return a string with the initial UIDL message
* @throws PaintException
* if an exception occurs while painting
+ * @throws JSONException
+ * if an exception occurs while encoding output
*/
protected String getInitialUIDL(WrappedRequest request, Root root)
- throws PaintException {
+ throws PaintException, JSONException {
// TODO maybe unify writeUidlResponse()?
StringWriter sWriter = new StringWriter();
PrintWriter pWriter = new PrintWriter(sWriter);
import java.io.OutputStreamWriter;
import java.io.Serializable;
import java.io.Writer;
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import com.vaadin.Application;
import com.vaadin.RootRequiresMoreInformationException;
import com.vaadin.Version;
-import com.vaadin.annotations.LoadScripts;
import com.vaadin.external.json.JSONException;
import com.vaadin.external.json.JSONObject;
import com.vaadin.terminal.DeploymentConfiguration;
page.write("<title>"
+ AbstractApplicationServlet.safeEscapeForHtml(title)
+ "</title>\n");
-
- if (root != null) {
- List<LoadScripts> loadScriptsAnnotations = getAnnotationsFor(
- root.getClass(), LoadScripts.class);
- Collections.reverse(loadScriptsAnnotations);
- // Begin from the end as a class might requests scripts that depend
- // on script loaded by a super class
- for (int i = loadScriptsAnnotations.size() - 1; i >= 0; i--) {
- LoadScripts loadScripts = loadScriptsAnnotations.get(i);
- String[] value = loadScripts.value();
- if (value != null) {
- for (String script : value) {
- page.write("<script type='text/javascript' src='");
- page.write(script);
- page.write("'></script>\n");
- }
- }
- }
-
- }
- }
-
- private static <T extends Annotation> List<T> getAnnotationsFor(
- Class<?> type, Class<T> annotationType) {
- List<T> list = new ArrayList<T>();
- // Find from the class hierarchy
- Class<?> currentType = type;
- while (currentType != Object.class) {
- T annotation = currentType.getAnnotation(annotationType);
- if (annotation != null) {
- list.add(annotation);
- }
- currentType = currentType.getSuperclass();
- }
-
- // Find from an implemented interface
- for (Class<?> iface : type.getInterfaces()) {
- T annotation = iface.getAnnotation(annotationType);
- if (annotation != null) {
- list.add(annotation);
- }
- }
-
- return list;
}
/**
* @return a string with the initial UIDL message
* @throws PaintException
* if an exception occurs while painting the components
+ * @throws JSONException
+ * if an exception occurs while formatting the output
*/
protected abstract String getInitialUIDL(WrappedRequest request, Root root)
- throws PaintException;
+ throws PaintException, JSONException;
}
import javax.servlet.ServletContext;
import com.vaadin.Application;
+import com.vaadin.external.json.JSONException;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.StreamVariable;
import com.vaadin.terminal.WrappedRequest;
@Override
protected String getInitialUIDL(WrappedRequest request, Root root)
- throws PaintException {
+ throws PaintException, JSONException {
return CommunicationManager.this.getInitialUIDL(request, root);
}
};
@Override
public void handleUidlRequest(WrappedRequest request,
WrappedResponse response, Callback callback, Root root)
- throws IOException, InvalidUIDLSecurityKeyException {
+ throws IOException, InvalidUIDLSecurityKeyException, JSONException {
setCurrentMimeReponse(response);
super.handleUidlRequest(request, response, callback, root);
currentMimeResponse = null;
@Override
protected String getInitialUIDL(WrappedRequest request, Root root)
- throws PaintException {
+ throws PaintException, JSONException {
return PortletCommunicationManager.this.getInitialUIDL(request,
root);
}
import java.util.Arrays;
import java.util.List;
-import com.vaadin.annotations.LoadScripts;
+import com.vaadin.annotations.JavaScript;
import com.vaadin.external.json.JSONArray;
import com.vaadin.external.json.JSONException;
import com.vaadin.terminal.WrappedRequest;
import com.vaadin.ui.JavaScriptCallback;
import com.vaadin.ui.Notification;
-@LoadScripts({ "/statictestfiles/jsconnector.js" })
public class BasicJavaScriptComponent extends AbstractTestRoot {
public interface ExampleClickRpc extends ServerRpc {
}
}
+ @JavaScript("/statictestfiles/jsconnector.js")
public static class ExampleWidget extends AbstractJavaScriptComponent {
public ExampleWidget() {
registerRpc(new ExampleClickRpc() {
package com.vaadin.tests.extensions;
-import com.vaadin.annotations.LoadScripts;
+import com.vaadin.annotations.JavaScript;
+import com.vaadin.annotations.StyleSheet;
import com.vaadin.external.json.JSONArray;
import com.vaadin.external.json.JSONException;
import com.vaadin.terminal.AbstractJavaScriptExtension;
import com.vaadin.ui.JavaScriptCallback;
import com.vaadin.ui.Notification;
-@LoadScripts({ "/statictestfiles/jsextension.js" })
public class SimpleJavaScriptExtensionTest extends AbstractTestRoot {
public static class SimpleJavaScriptExtensionState extends
public void greet(String message);
}
+ @JavaScript("/statictestfiles/jsextension.js")
+ @StyleSheet("/VAADIN/external1.css")
public static class SimpleJavascriptExtension extends
AbstractJavaScriptExtension {
projects / vaadin-framework.git / commitdiff