import java.io.Serializable;
import com.vaadin.Application;
-import com.vaadin.terminal.StreamVariable.StreamingEndedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingFailedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingStartedEvent;
+import com.vaadin.terminal.StreamVariable.StreamingEndEvent;
+import com.vaadin.terminal.StreamVariable.StreamingErrorEvent;
+import com.vaadin.terminal.StreamVariable.StreamingStartEvent;
/**
* StreamVariable is a special kind of variable whose value is streamed to an
/**
* Invoked by the terminal when a new upload arrives, after
- * {@link #streamingStarted(StreamingStartedEvent)} method has been called.
+ * {@link #streamingStarted(StreamingStartEvent)} method has been called.
* The terminal implementation will write the streamed variable to the
* returned output stream.
*
* {@link #onProgress(long, long)} is called in a synchronized block when
* the content is being received. This is potentially bit slow, so we are
* calling that method only if requested. The value is requested after the
- * {@link #uploadStarted(StreamingStartedEvent)} event, but not after
+ * {@link #uploadStarted(StreamingStartEvent)} event, but not after
* reading each buffer.
*
* @return true if this {@link StreamVariable} wants to by notified during
* the upload of the progress of streaming.
- * @see #onProgress(StreamingProgressedEvent)
+ * @see #onProgress(StreamingProgressEvent)
*/
boolean listenProgress();
* This method is called by the terminal if {@link #listenProgress()}
* returns true when the streaming starts.
*/
- void onProgress(StreamingProgressedEvent event);
+ void onProgress(StreamingProgressEvent event);
- void streamingStarted(StreamingStartedEvent event);
+ void streamingStarted(StreamingStartEvent event);
- void streamingFinished(StreamingEndedEvent event);
+ void streamingFinished(StreamingEndEvent event);
- void streamingFailed(StreamingFailedEvent event);
+ void streamingFailed(StreamingErrorEvent event);
/*
* Not synchronized to avoid stalls (caused by UIDL requests) while
}
/**
- * Event passed to {@link #uploadStarted(StreamingStartedEvent)} method
+ * Event passed to {@link #uploadStarted(StreamingStartEvent)} method
* before the streaming of the content to {@link StreamVariable} starts.
*/
- public interface StreamingStartedEvent extends StreamingEvent {
+ public interface StreamingStartEvent extends StreamingEvent {
}
/**
- * Event passed to {@link #onProgress(StreamingProgressedEvent)} method
+ * Event passed to {@link #onProgress(StreamingProgressEvent)} method
* during the streaming progresses.
*/
- public interface StreamingProgressedEvent extends StreamingEvent {
+ public interface StreamingProgressEvent extends StreamingEvent {
}
/**
- * Event passed to {@link #uploadFinished(StreamingEndedEvent)} method the
+ * Event passed to {@link #uploadFinished(StreamingEndEvent)} method the
* contents have been streamed to StreamVariable successfully.
*/
- public interface StreamingEndedEvent extends StreamingEvent {
+ public interface StreamingEndEvent extends StreamingEvent {
}
/**
- * Event passed to {@link #uploadFailed(StreamingFailedEvent)} method when
+ * Event passed to {@link #uploadFailed(StreamingErrorEvent)} method when
* the streaming ended before the end of the input. The streaming may fail
* due an interruption by {@link } or due an other unknown exception in
* communication. In the latter case the exception is also passed to
* {@link Application#terminalError(com.vaadin.terminal.Terminal.ErrorEvent)}
* .
*/
- public interface StreamingFailedEvent extends StreamingEvent {
+ public interface StreamingErrorEvent extends StreamingEvent {
/**
* @return the exception that caused the receiving not to finish cleanly
import com.vaadin.terminal.Paintable;
import com.vaadin.terminal.Paintable.RepaintRequestEvent;
import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingEndedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingFailedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingStartedEvent;
+import com.vaadin.terminal.StreamVariable.StreamingEndEvent;
+import com.vaadin.terminal.StreamVariable.StreamingErrorEvent;
+import com.vaadin.terminal.StreamVariable.StreamingStartEvent;
import com.vaadin.terminal.Terminal.ErrorEvent;
import com.vaadin.terminal.Terminal.ErrorListener;
import com.vaadin.terminal.URIHandler;
* @throws IOException
*/
protected void doHandleSimpleMultipartFileUpload(Request request,
- Response response, StreamVariable streamVariable, VariableOwner owner,
- String boundary) throws IOException {
+ Response response, StreamVariable streamVariable,
+ VariableOwner owner, String boundary) throws IOException {
boundary = CRLF + "--" + boundary + "--";
// multipart parsing, supports only one file for request, but that is
* @throws IOException
*/
protected void doHandleXhrFilePost(Request request, Response response,
- StreamVariable streamVariable, VariableOwner owner, int contentLength)
- throws IOException {
+ StreamVariable streamVariable, VariableOwner owner,
+ int contentLength) throws IOException {
// These are unknown in filexhr ATM, maybe add to Accept header that
// is accessible in portlets
}
protected final void streamToReceiver(final InputStream in,
- StreamVariable streamVariable, String filename,
- String type, int contentLength) throws UploadException {
+ StreamVariable streamVariable, String filename, String type,
+ int contentLength) throws UploadException {
if (streamVariable == null) {
- throw new IllegalStateException("StreamVariable for the post not found");
+ throw new IllegalStateException(
+ "StreamVariable for the post not found");
}
final Application application = getApplication();
try {
boolean listenProgress;
synchronized (application) {
- StreamingStartedEvent startedEvent = new StreamingStartedEventImpl(
- streamVariable, filename, type, contentLength);
+ StreamingStartEvent startedEvent = new StreamingStartEventImpl(
+ filename, type, contentLength);
streamVariable.streamingStarted(startedEvent);
out = streamVariable.getOutputStream();
listenProgress = streamVariable.listenProgress();
// update progress if listener set and contentLength
// received
synchronized (application) {
- StreamingProgressedEventImpl progressEvent = new StreamingProgressedEventImpl(
- streamVariable, filename, type, contentLength,
- totalBytes);
+ StreamingProgressEventImpl progressEvent = new StreamingProgressEventImpl(
+ filename, type, contentLength, totalBytes);
streamVariable.onProgress(progressEvent);
}
}
// upload successful
out.close();
- StreamingEndedEvent event = new StremingEndedEventImpl(streamVariable,
- filename, type, totalBytes);
+ StreamingEndEvent event = new StreamingEndEventImpl(filename, type,
+ totalBytes);
synchronized (application) {
streamVariable.streamingFinished(event);
}
} catch (UploadInterruptedException e) {
// Download interrupted by application code
tryToCloseStream(out);
- StreamingFailedEvent event = new StreamingFailedEventImpl(streamVariable,
- filename, type, contentLength, totalBytes, e);
+ StreamingErrorEvent event = new StreamingErrorEventImpl(filename,
+ type, contentLength, totalBytes, e);
synchronized (application) {
streamVariable.streamingFailed(event);
}
} catch (final Exception e) {
tryToCloseStream(out);
synchronized (application) {
- StreamingFailedEvent event = new StreamingFailedEventImpl(
- streamVariable, filename, type, contentLength, totalBytes, e);
+ StreamingErrorEvent event = new StreamingErrorEventImpl(
+ filename, type, contentLength, totalBytes, e);
synchronized (application) {
streamVariable.streamingFailed(event);
}
}
- abstract String createReceiverUrl(VariableOwner owner, String name,
+ abstract String createStreamVariableTargetUrl(VariableOwner owner, String name,
StreamVariable value);
}
package com.vaadin.terminal.gwt.server;
-import com.vaadin.terminal.StreamVariable;
import com.vaadin.terminal.StreamVariable.StreamingEvent;
/**
abstract class AbstractStreamingEvent implements StreamingEvent {
private final String type;
private final String filename;
- private final StreamVariable streamVariable;
private final long contentLength;
private final long bytesReceived;
return type;
}
- protected AbstractStreamingEvent(StreamVariable streamVariable, String filename,
- String type, long length, long bytesReceived) {
- this.streamVariable = streamVariable;
+ protected AbstractStreamingEvent(String filename, String type, long length,
+ long bytesReceived) {
this.filename = filename;
this.type = type;
contentLength = length;
this.bytesReceived = bytesReceived;
}
- public final StreamVariable getReceiver() {
- return streamVariable;
- }
-
public final long getContentLength() {
return contentLength;
}
/**
* Handles file upload request submitted via Upload component.
*
- * @see #createReceiverUrl(ReceiverOwner, String, StreamVariable)
+ * @see #createStreamVariableTargetUrl(ReceiverOwner, String,
+ * StreamVariable)
*
* @param request
* @param response
String uppUri = pathInfo.substring(startOfData);
String[] parts = uppUri.split("/", 3); // 0 = pid, 1= name, 2 = sec key
- StreamVariable streamVariable = pidToNameToReceiver.get(parts[0]).remove(parts[1]);
- String secKey = receiverToSeckey.remove(streamVariable);
+ StreamVariable streamVariable = pidToNameToStreamVariable.get(parts[0])
+ .remove(parts[1]);
+ String secKey = streamVariableToSeckey.remove(streamVariable);
if (secKey.equals(parts[2])) {
- VariableOwner source = (VariableOwner) getVariableOwner(parts[0]);
+ VariableOwner source = getVariableOwner(parts[0]);
String contentType = request.getContentType();
if (request.getContentType().contains("boundary")) {
// Multipart requests contain boundary string
doHandleSimpleMultipartFileUpload(
new HttpServletRequestWrapper(request),
- new HttpServletResponseWrapper(response), streamVariable,
- source, contentType.split("boundary=")[1]);
+ new HttpServletResponseWrapper(response),
+ streamVariable, source,
+ contentType.split("boundary=")[1]);
} else {
// if boundary string does not exist, the posted file is from
// XHR2.post(File)
doHandleXhrFilePost(new HttpServletRequestWrapper(request),
- new HttpServletResponseWrapper(response), streamVariable,
- source, request.getContentLength());
+ new HttpServletResponseWrapper(response),
+ streamVariable, source, request.getContentLength());
}
} else {
throw new InvalidUIDLSecurityKeyException(
@Override
protected void unregisterPaintable(Component p) {
/* Cleanup possible receivers */
- if (pidToNameToReceiver != null) {
- Map<String, StreamVariable> removed = pidToNameToReceiver
+ if (pidToNameToStreamVariable != null) {
+ Map<String, StreamVariable> removed = pidToNameToStreamVariable
.remove(getPaintableId(p));
if (removed != null) {
for (String key : removed.keySet()) {
- receiverToSeckey.remove(removed.get(key));
+ streamVariableToSeckey.remove(removed.get(key));
}
}
}
}
- private Map<String, Map<String, StreamVariable>> pidToNameToReceiver;
+ private Map<String, Map<String, StreamVariable>> pidToNameToStreamVariable;
- private Map<StreamVariable, String> receiverToSeckey;
+ private Map<StreamVariable, String> streamVariableToSeckey;
@Override
- String createReceiverUrl(VariableOwner owner, String name, StreamVariable value) {
-
- /*
- * TODO figure out how this can be simplified now that ReceiverOwner is removed.
- */
+ String createStreamVariableTargetUrl(VariableOwner owner, String name,
+ StreamVariable value) {
/*
* We will use the same APP/* URI space as ApplicationResources but
* SECKEY is created on each paint to make URL's unpredictable (to
* prevent CSRF attacks).
*
- * NAME and PID from URI forms a key to fetch StreamVariable when handling
- * post
+ * NAME and PID from URI forms a key to fetch StreamVariable when
+ * handling post
*/
String paintableId = getPaintableId((Paintable) owner);
String key = paintableId + "/" + name;
- if (pidToNameToReceiver == null) {
- pidToNameToReceiver = new HashMap<String, Map<String, StreamVariable>>();
+ if (pidToNameToStreamVariable == null) {
+ pidToNameToStreamVariable = new HashMap<String, Map<String, StreamVariable>>();
}
- Map<String, StreamVariable> nameToReceiver = pidToNameToReceiver
+ Map<String, StreamVariable> nameToStreamVariable = pidToNameToStreamVariable
.get(paintableId);
- if (nameToReceiver == null) {
- nameToReceiver = new HashMap<String, StreamVariable>();
- pidToNameToReceiver.put(paintableId, nameToReceiver);
+ if (nameToStreamVariable == null) {
+ nameToStreamVariable = new HashMap<String, StreamVariable>();
+ pidToNameToStreamVariable.put(paintableId, nameToStreamVariable);
}
- nameToReceiver.put(name, value);
+ nameToStreamVariable.put(name, value);
- if (receiverToSeckey == null) {
- receiverToSeckey = new HashMap<StreamVariable, String>();
+ if (streamVariableToSeckey == null) {
+ streamVariableToSeckey = new HashMap<StreamVariable, String>();
}
String seckey = UUID.randomUUID().toString();
- receiverToSeckey.put(value, seckey);
+ streamVariableToSeckey.put(value, seckey);
return getApplication().getURL()
+ AbstractApplicationServlet.UPLOAD_URL_PREFIX + key + "/"
public void addVariable(VariableOwner owner, String name, StreamVariable value)
throws PaintException {
- String url = manager.createReceiverUrl(owner, name, value);
+ String url = manager.createStreamVariableTargetUrl(owner, name, value);
addVariable(owner, name, url);
}
String name = request.getParameter("name");
String ownerId = request.getParameter("rec-owner");
VariableOwner variableOwner = (VariableOwner) getVariableOwner(ownerId);
- StreamVariable streamVariable = ownerToNameToReceiver.get(variableOwner).remove(
+ StreamVariable streamVariable = ownerToNameToStreamVariable.get(variableOwner).remove(
name);
// clean up, may be re added on next paint
- ownerToNameToReceiver.get(variableOwner).remove(name);
+ ownerToNameToStreamVariable.get(variableOwner).remove(name);
if (contentType.contains("boundary")) {
doHandleSimpleMultipartFileUpload(
@Override
protected void unregisterPaintable(Component p) {
super.unregisterPaintable(p);
- if (ownerToNameToReceiver != null) {
- ownerToNameToReceiver.remove(p);
+ if (ownerToNameToStreamVariable != null) {
+ ownerToNameToStreamVariable.remove(p);
}
}
application, assumedWindow);
}
- private Map<VariableOwner, Map<String, StreamVariable>> ownerToNameToReceiver;
+ private Map<VariableOwner, Map<String, StreamVariable>> ownerToNameToStreamVariable;
@Override
- String createReceiverUrl(VariableOwner owner, String name, StreamVariable value) {
- if (ownerToNameToReceiver == null) {
- ownerToNameToReceiver = new HashMap<VariableOwner, Map<String, StreamVariable>>();
+ String createStreamVariableTargetUrl(VariableOwner owner, String name, StreamVariable value) {
+ if (ownerToNameToStreamVariable == null) {
+ ownerToNameToStreamVariable = new HashMap<VariableOwner, Map<String, StreamVariable>>();
}
- Map<String, StreamVariable> nameToReceiver = ownerToNameToReceiver.get(owner);
+ Map<String, StreamVariable> nameToReceiver = ownerToNameToStreamVariable.get(owner);
if (nameToReceiver == null) {
nameToReceiver = new HashMap<String, StreamVariable>();
- ownerToNameToReceiver.put(owner, nameToReceiver);
+ ownerToNameToStreamVariable.put(owner, nameToReceiver);
}
nameToReceiver.put(name, value);
ResourceURL resurl = currentUidlResponse.createResourceURL();
--- /dev/null
+package com.vaadin.terminal.gwt.server;
+
+import com.vaadin.terminal.StreamVariable.StreamingEndEvent;
+
+@SuppressWarnings("serial")
+final class StreamingEndEventImpl extends AbstractStreamingEvent implements
+ StreamingEndEvent {
+
+ public StreamingEndEventImpl(String filename, String type, long totalBytes) {
+ super(filename, type, totalBytes, totalBytes);
+ }
+
+}
--- /dev/null
+package com.vaadin.terminal.gwt.server;
+
+import com.vaadin.terminal.StreamVariable.StreamingErrorEvent;
+
+@SuppressWarnings("serial")
+final class StreamingErrorEventImpl extends AbstractStreamingEvent implements
+ StreamingErrorEvent {
+
+ private final Exception exception;
+
+ public StreamingErrorEventImpl(final String filename, final String type,
+ long contentLength, long bytesReceived, final Exception exception) {
+ super(filename, type, contentLength, bytesReceived);
+ this.exception = exception;
+ }
+
+ public final Exception getException() {
+ return exception;
+ }
+
+}
+++ /dev/null
-package com.vaadin.terminal.gwt.server;
-
-import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingFailedEvent;
-
-@SuppressWarnings("serial")
-final class StreamingFailedEventImpl extends AbstractStreamingEvent implements
- StreamingFailedEvent {
-
- private final Exception exception;
-
- public StreamingFailedEventImpl(StreamVariable streamVariable, final String filename,
- final String type, long contentLength, long bytesReceived,
- final Exception exception) {
- super(streamVariable, filename, type, contentLength, bytesReceived);
- this.exception = exception;
- }
-
- public final Exception getException() {
- return exception;
- }
-
-}
--- /dev/null
+package com.vaadin.terminal.gwt.server;
+
+import com.vaadin.terminal.StreamVariable.StreamingProgressEvent;
+
+@SuppressWarnings("serial")
+final class StreamingProgressEventImpl extends AbstractStreamingEvent implements
+ StreamingProgressEvent {
+
+ public StreamingProgressEventImpl(final String filename, final String type,
+ long contentLength, long bytesReceived) {
+ super(filename, type, contentLength, bytesReceived);
+ }
+
+}
+++ /dev/null
-package com.vaadin.terminal.gwt.server;
-
-import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingProgressedEvent;
-
-@SuppressWarnings("serial")
-final class StreamingProgressedEventImpl extends AbstractStreamingEvent
- implements StreamingProgressedEvent {
-
- public StreamingProgressedEventImpl(StreamVariable streamVariable,
- final String filename, final String type, long contentLength,
- long bytesReceived) {
- super(streamVariable, filename, type, contentLength, bytesReceived);
- }
-
-}
--- /dev/null
+package com.vaadin.terminal.gwt.server;
+
+import com.vaadin.terminal.StreamVariable.StreamingStartEvent;
+
+@SuppressWarnings("serial")
+final class StreamingStartEventImpl extends AbstractStreamingEvent implements
+ StreamingStartEvent {
+
+ public StreamingStartEventImpl(final String filename, final String type,
+ long contentLength) {
+ super(filename, type, contentLength, 0);
+ }
+
+}
+++ /dev/null
-package com.vaadin.terminal.gwt.server;
-
-import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingStartedEvent;
-
-@SuppressWarnings("serial")
-final class StreamingStartedEventImpl extends AbstractStreamingEvent implements
- StreamingStartedEvent {
-
- public StreamingStartedEventImpl(StreamVariable streamVariable, final String filename,
- final String type, long contentLength) {
- super(streamVariable, filename, type, contentLength, 0);
- }
-
-}
+++ /dev/null
-package com.vaadin.terminal.gwt.server;
-
-import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingEndedEvent;
-
-@SuppressWarnings("serial")
-final class StremingEndedEventImpl extends AbstractStreamingEvent implements
- StreamingEndedEvent {
-
- public StremingEndedEventImpl(StreamVariable streamVariable, String filename,
- String type, long totalBytes) {
- super(streamVariable, filename, type, totalBytes, totalBytes);
- }
-
-}
if (receivers != null && receivers.size() > 0) {
for (Iterator<Entry<String, Html5File>> it = receivers.entrySet()
.iterator(); it.hasNext();) {
- String id = it.next().getKey();
- Html5File html5File = receivers.get(id);
- if (html5File.getReceiver() != null) {
+ Entry<String, com.vaadin.ui.Html5File> entry = it.next();
+ String id = entry.getKey();
+ Html5File html5File = entry.getValue();
+ if (html5File.getStreamVariable() != null) {
target.addVariable(this, "rec-" + id, new ProxyReceiver(
html5File));
// these are cleaned from receivers once the upload has
private boolean listenProgressOfUploadedFile;
public OutputStream getOutputStream() {
- if (file.getReceiver() == null) {
+ if (file.getStreamVariable() == null) {
return null;
}
- return file.getReceiver().getOutputStream();
+ return file.getStreamVariable().getOutputStream();
}
public boolean listenProgress() {
- return file.getReceiver().listenProgress();
+ return file.getStreamVariable().listenProgress();
}
- public void onProgress(StreamingProgressedEvent event) {
- file.getReceiver().onProgress(new ReceivingEventWrapper(event));
+ public void onProgress(StreamingProgressEvent event) {
+ file.getStreamVariable().onProgress(
+ new ReceivingEventWrapper(event));
}
- public void streamingStarted(StreamingStartedEvent event) {
- listenProgressOfUploadedFile = file.getReceiver() != null;
+ public void streamingStarted(StreamingStartEvent event) {
+ listenProgressOfUploadedFile = file.getStreamVariable() != null;
if (listenProgressOfUploadedFile) {
- file.getReceiver().streamingStarted(
+ file.getStreamVariable().streamingStarted(
new ReceivingEventWrapper(event));
}
// no need tell to the client about this receiver on next paint
receivers.remove(file);
}
- public void streamingFinished(StreamingEndedEvent event) {
+ public void streamingFinished(StreamingEndEvent event) {
if (listenProgressOfUploadedFile) {
- file.getReceiver().streamingFinished(
+ file.getStreamVariable().streamingFinished(
new ReceivingEventWrapper(event));
}
}
- public void streamingFailed(final StreamingFailedEvent event) {
+ public void streamingFailed(final StreamingErrorEvent event) {
if (listenProgressOfUploadedFile) {
- file.getReceiver().streamingFailed(
+ file.getStreamVariable().streamingFailed(
new ReceivingEventWrapper(event));
}
}
public boolean isInterrupted() {
- return file.getReceiver().isInterrupted();
+ return file.getStreamVariable().isInterrupted();
}
/*
* terminal event and provides the lacking information from the
* Html5File.
*/
- class ReceivingEventWrapper implements StreamingFailedEvent,
- StreamingEndedEvent, StreamingStartedEvent,
- StreamingProgressedEvent {
+ class ReceivingEventWrapper implements StreamingErrorEvent,
+ StreamingEndEvent, StreamingStartEvent, StreamingProgressEvent {
private StreamingEvent wrappedEvent;
}
public Exception getException() {
- if (wrappedEvent instanceof StreamingFailedEvent) {
- return ((StreamingFailedEvent) wrappedEvent).getException();
+ if (wrappedEvent instanceof StreamingErrorEvent) {
+ return ((StreamingErrorEvent) wrappedEvent).getException();
}
return null;
}
* the callback that returns stream where the implementation
* writes the file contents as it arrives.
*/
- public void setReceiver(StreamVariable streamVariable) {
+ public void setStreamVariable(StreamVariable streamVariable) {
this.streamVariable = streamVariable;
}
- public StreamVariable getReceiver() {
+ public StreamVariable getStreamVariable() {
return streamVariable;
}
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.StreamVariable.StreamingStartedEvent;
+import com.vaadin.terminal.StreamVariable.StreamingStartEvent;
import com.vaadin.terminal.gwt.client.ui.VUpload;
import com.vaadin.terminal.gwt.server.NoInputStreamException;
import com.vaadin.terminal.gwt.server.NoOutputStreamException;
protected com.vaadin.terminal.StreamVariable getStreamVariable() {
if (streamVariable == null) {
streamVariable = new com.vaadin.terminal.StreamVariable() {
- private StreamingStartedEvent lastStartedEvent;
+ private StreamingStartEvent lastStartedEvent;
public boolean listenProgress() {
return (progressListeners != null && !progressListeners
.isEmpty());
}
- public void onProgress(StreamingProgressedEvent event) {
+ public void onProgress(StreamingProgressEvent event) {
fireUpdateProgress(event.getBytesReceived(),
event.getContentLength());
}
return receiveUpload;
}
- public void streamingStarted(StreamingStartedEvent event) {
+ public void streamingStarted(StreamingStartEvent event) {
startUpload();
contentLength = event.getContentLength();
fireStarted(event.getFileName(), event.getMimeType());
lastStartedEvent = event;
}
- public void streamingFinished(StreamingEndedEvent event) {
+ public void streamingFinished(StreamingEndEvent event) {
fireUploadSuccess(event.getFileName(), event.getMimeType(),
event.getContentLength());
endUpload();
requestRepaint();
}
- public void streamingFailed(StreamingFailedEvent event) {
+ public void streamingFailed(StreamingErrorEvent event) {
Exception exception = event.getException();
if (exception instanceof NoInputStreamException) {
fireNoInputStream(event.getFileName(),
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
-import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import com.vaadin.event.dd.acceptcriteria.AcceptCriterion;
import com.vaadin.event.dd.acceptcriteria.Not;
import com.vaadin.event.dd.acceptcriteria.SourceIsTarget;
-import com.vaadin.terminal.StreamVariable;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.StreamResource;
import com.vaadin.terminal.StreamResource.StreamSource;
+import com.vaadin.terminal.StreamVariable;
import com.vaadin.terminal.ThemeResource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.tests.components.TestBase;
byte[] byteArray = bas.toByteArray();
return new ByteArrayInputStream(byteArray);
}
- // TODO Auto-generated method stub
return null;
}
};
table.setEditable(true);
w.addComponent(table);
getMainWindow().addWindow(w);
- // TODO saving would be nice demo
}
}
public boolean listenProgress() {
- // TODO Auto-generated method stub
return false;
}
- public void onProgress(
- StreamingProgressedEvent event) {
- // TODO Auto-generated method stub
-
+ public void onProgress(StreamingProgressEvent event) {
}
public void streamingStarted(
- StreamingStartedEvent event) {
- // TODO Auto-generated method stub
-
+ StreamingStartEvent event) {
}
public void streamingFinished(
- StreamingEndedEvent event) {
- // TODO Auto-generated method stub
-
+ StreamingEndEvent event) {
}
public void streamingFailed(
- StreamingFailedEvent event) {
- // TODO Auto-generated method stub
-
+ StreamingErrorEvent event) {
}
public boolean isInterrupted() {
- // TODO Auto-generated method stub
return false;
}
};
- html5File.setReceiver(streamVariable);
+ html5File.setStreamVariable(streamVariable);
File file = new File(fileName, bas);
file.setType(html5File.getType());
import com.vaadin.event.dd.acceptcriteria.AcceptAll;
import com.vaadin.event.dd.acceptcriteria.AcceptCriterion;
import com.vaadin.terminal.StreamVariable;
-import com.vaadin.terminal.StreamVariable.StreamingEndedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingFailedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingProgressedEvent;
-import com.vaadin.terminal.StreamVariable.StreamingStartedEvent;
+import com.vaadin.terminal.StreamVariable.StreamingEndEvent;
+import com.vaadin.terminal.StreamVariable.StreamingErrorEvent;
+import com.vaadin.terminal.StreamVariable.StreamingProgressEvent;
+import com.vaadin.terminal.StreamVariable.StreamingStartEvent;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Component;
import com.vaadin.ui.CssLayout;
}
public void onProgress(
- StreamingProgressedEvent event) {
+ StreamingProgressEvent event) {
System.err.println("Progress"
+ event.getBytesReceived());
}
public void streamingStarted(
- StreamingStartedEvent event) {
+ StreamingStartEvent event) {
getMainWindow().showNotification(
"Started uploading "
+ event.getFileName());
}
public void streamingFinished(
- StreamingEndedEvent event) {
+ StreamingEndEvent event) {
getMainWindow().showNotification(
"Finished uploading "
+ event.getFileName());
}
public void streamingFailed(
- StreamingFailedEvent event) {
+ StreamingErrorEvent event) {
getMainWindow().showNotification(
"Failed uploading "
+ event.getFileName());
return false;
}
};
- file.setReceiver(streamVariable);
+ file.setStreamVariable(streamVariable);
}
}
root.getPosition(component).setLeftValue(
Float.valueOf(clientX - left));
} catch (Exception e) {
- // TODO: handle exception
}
} else {
// drag started and ended inside the this Pane
if (files != null) {
for (Html5File html5File : files) {
l.setCaption(html5File.getFileName());
- html5File.setReceiver(new StreamVariable() {
+ html5File.setStreamVariable(new StreamVariable() {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
public OutputStream getOutputStream() {
}
public boolean listenProgress() {
- // TODO Auto-generated method stub
return false;
}
- public void onProgress(StreamingProgressedEvent event) {
- // TODO Auto-generated method stub
-
+ public void onProgress(StreamingProgressEvent event) {
}
- public void streamingStarted(StreamingStartedEvent event) {
- // TODO Auto-generated method stub
-
+ public void streamingStarted(StreamingStartEvent event) {
}
- public void streamingFinished(StreamingEndedEvent event) {
+ public void streamingFinished(StreamingEndEvent event) {
l.setValue((new String(byteArrayOutputStream
.toByteArray()).substring(0, 80) + "..."));
}
- public void streamingFailed(StreamingFailedEvent event) {
- // TODO Auto-generated method stub
-
+ public void streamingFailed(StreamingErrorEvent event) {
}
public boolean isInterrupted() {
- // TODO Auto-generated method stub
return false;
}
});
projects / vaadin-framework.git / commitdiff