private void ImageRead(PipeRequest request, Pipe pipe)
{
if (Active)
{
_imageRequest = null;
try
{
if (request.Result.IsNative)
{
byte[] resultBytes = request.Result.AsByteArray;
SetImage(System.Drawing.Image.FromStream(new MemoryStream(resultBytes, 0, resultBytes.Length, false, true)));
}
else
{
using (Stream stream = request.Result.OpenStream())
{
MemoryStream copyStream = new MemoryStream();
StreamUtility.CopyStream(stream, copyStream);
SetImage(System.Drawing.Image.FromStream(copyStream));
}
}
}
catch
{
SetImage(ImageUtility.GetErrorImage());
}
}
}
protected void ImageRead(PipeRequest request, Pipe pipe)
{
_imageRequest = null;
try
{
if (request.Result.IsNative)
{
byte[] resultBytes = request.Result.AsByteArray;
_image = System.Drawing.Image.FromStream(new MemoryStream(resultBytes, 0, resultBytes.Length, false, true));
}
else
{
using (Stream stream = request.Result.OpenStream())
{
MemoryStream copyStream = new MemoryStream();
StreamUtility.CopyStream(stream, copyStream);
_image = System.Drawing.Image.FromStream(copyStream);
}
}
}
catch
{
_image = ImageUtility.GetErrorImage();
}
FCallBack(this, new EventArgs());
}
private void CancelImageRequest()
{
if (_imageRequest != null)
{
HostNode.Pipe.CancelRequest(_imageRequest);
_imageRequest = null;
}
}
/// <summary> Queues up an asynchronous request for a document. </summary>
public void QueueRequest(PipeRequest pipeRequest)
{
lock (_asyncLock)
{
_queue.Add(pipeRequest);
_queueSignal.Set();
}
}
private void UpdateImage()
{
CancelImageRequest();
if (_imageExpression == String.Empty)
{
ClearImage();
}
else
{
// Queue up an asynchronous request
_imageRequest = new PipeRequest(_imageExpression, new PipeResponseHandler(ImageRead), new PipeErrorHandler(ImageError));
_requester.HostNode.Pipe.QueueRequest(_imageRequest);
}
}
/// <summary> Removes a request from the queue or cancels the request if it is being processed. </summary>
/// <remarks> The caller is not guaranteed that after calling this that a response will not be sent. </remarks>
public void CancelRequest(PipeRequest pipeRequest)
{
lock (_asyncLock)
{
if (pipeRequest == _currentRequest)
{
CancelCurrent();
}
else
{
_queue.Remove(pipeRequest);
if (_queue.Count == 0)
{
_queueSignal.Reset();
}
}
}
}
// TODO: change this to use the AsyncImageRequest class
/// <summary> Make sure that the image is loaded or creates an async request for it. </summary>
private void InternalUpdateImage()
{
if (HostNode.Session.AreImagesLoaded())
{
CancelImageRequest();
if (Image == String.Empty)
{
SetImage(null);
}
else
{
// Queue up an asynchronous request
_imageRequest = new PipeRequest(Image, new PipeResponseHandler(ImageRead), new PipeErrorHandler(ImageError));
HostNode.Pipe.QueueRequest(_imageRequest);
}
}
else
{
SetImage(null);
}
}
protected void ImageRead(PipeRequest request, Pipe pipe)
{
_imageRequest = null;
try
{
if (request.Result.IsNative)
{
_image = ImageUtility.BitmapImageFromBytes(request.Result.AsByteArray);
}
else
{
using (Stream stream = request.Result.OpenStream())
_image = ImageUtility.BitmapImageFromStream(stream);
}
}
catch
{
_image = ImageUtility.GetErrorImage();
}
FCallBack(this, new EventArgs());
}
private void ImageRead(PipeRequest request, Pipe pipe)
{
if (Active)
{
_imageRequest = null;
try
{
if (request.Result.IsNative)
{
SetImage(ImageUtility.BitmapImageFromBytes(request.Result.AsByteArray));
}
else
{
using (Stream stream = request.Result.OpenStream())
SetImage(ImageUtility.BitmapImageFromStream(stream));
}
}
catch
{
SetImage(ImageUtility.GetErrorImage());
}
}
}
private void ImageError(PipeRequest request, Pipe pipe, Exception exception)
{
_imageRequest = null;
SetImage(ImageUtility.GetErrorImage());
}
/// <summary> Main asynchronous thread loop. </summary>
private void ProcessAsync()
{
for (;;)
{
try
{
// Wait until an item is enqueued or shut-down occurs
_queueSignal.WaitOne();
// Check for shut-down
if (_stoppingAsync)
{
break;
}
lock (_asyncLock)
{
// Dequeue an item
if (_queue.Count > 0)
{
_currentRequest = _queue[0];
_queue.RemoveAt(0);
if (_queue.Count == 0)
{
_queueSignal.Reset();
}
}
}
try
{
try
{
// Make the request
_currentRequest._result = InternalRequest(_currentRequest.Document, _asyncProcess);
}
catch (Exception exception)
{
// Error callback
// Can't take a lock to ensure that FCancellingCurrent doesn't change before we invoke (might dead-lock on the SafelyInvoke back to the main thread... which might be waiting on the FAsyncLock)
if ((_currentRequest.ErrorHandler != null) && !_cancellingCurrent)
{
SafelyInvoke(_currentRequest.ErrorHandler, new object[] { _currentRequest, this, exception });
}
// Don't rethrow
continue; // Skip the success callback
}
// Success callback
// Can't take a lock to ensure that FCancellingCurrent doesn't change before we invoke (might dead-lock on the SafelyInvoke back to the main thread... which might be waiting on the FAsyncLock)
if ((_currentRequest.ResponseHandler != null) && !_cancellingCurrent)
{
SafelyInvoke(_currentRequest.ResponseHandler, new object[] { _currentRequest, this });
}
}
catch (ThreadAbortException)
{
// An abort above will cause this thread to terminate. This is because a catch will not
// prevent abort exception propagation. Must prevent this by resetting the abort state.
#if !SILVERLIGHT
System.Threading.Thread.ResetAbort();
#endif
// Don't rethrow - unnecessary
}
finally
{
lock (_asyncLock)
{
try
{
try
{
// Free up the result resources
if (_currentRequest._result != null)
{
_currentRequest._result.Dispose();
}
}
finally
{
// Clear the current request
_currentRequest = null;
}
}
finally
{
/*
* if (FCancellingCurrent)
* {
* // Reset the cancel flag
* FCancellingCurrent = false;
*
* // Start a new process, the old one was stopped
* CreateAsyncProcess();
* }
*/
}
}
}
}
catch (Exception exception)
{
Error.Warn(exception.ToString());
// Don't rethrow. We do not want an error here to stop the worker thread (and terminate the application).
}
}
_queueSignal.Close();
}
protected void ImageError(PipeRequest request, Pipe pipe, Exception exception)
{
_imageRequest = null;
_image = ImageUtility.GetErrorImage();
FCallBack(this, new EventArgs());
}