// Copyright 2005, 2006 - Morten Nielsen (www.iter.dk)

//

// This file is part of SharpMap.

// SharpMap is free software; you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// SharpMap is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License

// along with SharpMap; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

using System;

using System.Drawing.Imaging;

using System.IO;

using System.Web;

using Image = System.Drawing.Image;

namespace SharpMap.Web

{

/// <summary>

/// HttpHandler class for web applications

/// </summary>

public class HttpHandler : IHttpHandler

{

#region IHttpHandler Members

/// <summary>

/// Enable Http pooling

/// </summary>

public bool IsReusable

{

get { return true; }

}

/// <summary>

/// Returns the requested image in an http imagestream

/// </summary>

/// <param name="context">HttpContext</param>

public void ProcessRequest(HttpContext context)

{

var imgID = context.Request.QueryString["ID"];

var cached = context.Cache[imgID];

if (cached == null)

{

context.Response.Clear();

context.Response.ContentType = "text/plain";

context.Response.Write("Invalid Image requested");

context.Response.Flush();

context.ApplicationInstance.CompleteRequest();

return;

}

if (cached is byte[])

{

/*

context.Response.ContentType = "image/png";

var buffer = (byte[])cached;

context.Response.OutputStream.Write(buffer, 0, buffer.Length);

*/

WriteResponseInChunks((byte[])cached, context.Response);

context.ApplicationInstance.CompleteRequest();

return;

}

//FObermaier:

// Do we really need to check this, InsertIntoCache does the transformation to

// an array of bytes.

if (cached is Image)

{

//context.Response.ContentType = "image/png";

var b = (Image) cached;

// send the image to the viewer

using (var ms = new MemoryStream())

{

b.Save(ms, ImageFormat.Png);

//Don't tidy up we might need it again. If we want to tidy up we need to update the cached object to the

//the buffer created below. Don't know if that works

//// tidy up

//b.Dispose();

WriteResponseInChunks(ms.ToArray(), context.Response);

context.ApplicationInstance.CompleteRequest();

return;

//var buffer = ms.ToArray();

//context.Response.OutputStream.Write(buffer, 0, buffer.Length);

}

}

}

#endregion

/// <summary>

/// The size of the chunks written to response.

/// </summary>

private const int ChunkSize = 2 * 8192;

/// <summary>

/// Method to write an array of bytes in chunks to a http response

/// </summary>

/// <remarks>

/// The code was adopted from http://support.microsoft.com/kb/812406/en-us

/// </remarks>

/// <param name="buffer">The array of bytes</param>

/// <param name="response">The response</param>

private static void WriteResponseInChunks(byte[] buffer, HttpResponse response)

{

try

{

response.ClearContent();

response.ContentType = "image/png";

using (var ms = new MemoryStream(buffer))

{

var dataToRead = buffer.Length;

while (dataToRead > 0)

{

if (response.IsClientConnected)

{

{

var tmpBuffer = new byte[ChunkSize];

var length = ms.Read(tmpBuffer, 0, tmpBuffer.Length);

response.OutputStream.Write(tmpBuffer, 0, length);

response.Flush();

dataToRead -= length;

}

}

else

{

dataToRead = -1;

}

}

}

}

catch (Exception ex)

{

response.ClearContent();

response.ContentType = "text/plain";

response.Write(string.Format("Error : {0}", ex.Message));

response.Write(string.Format("Source : {0}", ex.Message));

response.Write(string.Format("StackTrace: {0}", ex.StackTrace));

}

finally

{

response.Flush();

response.SuppressContent = true;

}

}

}

}