using System; 
using System.IO; 
using System.Web; 
using System.Text; 
using GrapeCity.ActiveReports; 
using GrapeCity.ActiveReports.Export.Html;

   //The http context of the request
   private System.Web.HttpContext context = null;
    //The directory in which to save filename--this ensures that the filename  
    //is unique.
   private System.IO.DirectoryInfo dirToSave = null;
   public string mainPage = "";
   public MyCustomHtmlOutputter(System.Web.HttpContext context)
   {
      if(context == null)
      {         
        throw new ArgumentNullException("context");
          }     
        this.context = context;
        string dirName = context.Server.MapPath("ReportOutput");
        this.dirToSave = new DirectoryInfo(dirName);      
    }
    
#region Implementation of IOutputHtml
public string OutputHtmlData(HtmlOutputInfoArgs info)
{
   string temp = "";
   switch(info.OutputKind)
   {
      case HtmlOutputKind.BookmarksHtml:
      case HtmlOutputKind.FramesetHtml:
      {
        temp = this.GenUniqueFileNameWithExtension(".html");
        FileStream fs = File.Create(temp);
        this.WriteStreamToStream(info.OutputStream, fs);
        fs.Close();
        return temp;
      }
                
      case HtmlOutputKind.HtmlPage:
      {
         //Store the name of the main page so we can
         //redirect the browser to it
        this.mainPage = this.GenUniqueFileNameWithExtension(".html");
        FileStream fs = File.Create(this.mainPage);
        this.WriteStreamToStream(info.OutputStream, fs);
        fs.Close();
        return this.mainPage;
      }
                
      case HtmlOutputKind.ImageJpg:
      {
         // Create a file with a .jpg extension:
         temp = this.GenUniqueFileNameWithExtension(".jpg");
        FileStream fs = File.Create(temp);
        this.WriteStreamToStream(info.OutputStream, fs);
        fs.Close();
        return temp;
      }
                
      case HtmlOutputKind.ImagePng:
      {
        //Create a file with a .png extension:
        temp = this.GenUniqueFileNameWithExtension(".png");
        FileStream fs = File.Create(temp);
        this.WriteStreamToStream(info.OutputStream, fs);
        fs.Close();
        return temp;
      }
                
      default:
      {
        //Default to html:
        temp = this.GenUniqueFileNameWithExtension(".html");
        FileStream fs = File.Create(temp);
        this.WriteStreamToStream(info.OutputStream, fs);
        fs.Close();
        return temp;
      }
   }
}
    
public void Finish()
{
}
#endregion
    
private void WriteStreamToStream(Stream sourceStream, Stream targetStream)
{
   //Find the size of the source stream
   int size = (int)sourceStream.Length;
       
   //Create a buffer that same size
   byte[] buffer = new byte[size];
       
   //Move the source stream to the beginning
   sourceStream.Seek(0, SeekOrigin.Begin);
       
   //Copy the sourceStream into our buffer
   sourceStream.Read(buffer, 0, size);
       
   //Write out the buffer to the target stream
   targetStream.Write(buffer, 0, size);
}
     
private string GenUniqueFileNameWithExtension(string extensionWithDot)
{
    System.Random r = new Random();
    bool unique = false;
    string filePath = "";
    int iRandom = 0;
    //Generate a random name until it's unique
    while(!unique)
    {
       iRandom = r.Next();
       //Buld the full filename
       System.Text.StringBuilder sb = new System.Text.StringBuilder();
       sb.Append(this.dirToSave.FullName);
       sb.Append(Path.DirectorySeparatorChar);
       sb.Append(iRandom.ToString());
       sb.Append(extensionWithDot);
       filePath = sb.ToString();
       unique = !File.Exists(filePath);
     }
     return filePath;
  }

   rptCustHTML rpt = new rptCustHTML();
   try
   {
      rpt.Run(false);
   }
   catch (Exception eRunReport)
   {
      //If the report fails to run, report the error to the user
      Response.Clear();
      Response.Write("<h1>Error running report:</h1>");
      Response.Write(eRunReport.ToString());
      return;
   }
   //Buffer this page's output until the report output is ready.
   Response.Buffer = true;
        
   //Clear any part of this page that might have already been buffered for output.
   Response.ClearContent();

   //Clear any headers that might have already been buffered (such as the content 
   //type for an HTML page)
   Response.ClearHeaders();
    
   //Tell the browser and the "network" that the resulting data of this page should 
   //be cached since this could be a dynamic report that changes upon each request.
   Response.Cache.SetCacheability(HttpCacheability.NoCache);
    
   //Tell the browser this is an Html document so it will use an appropriate viewer.
   Response.ContentType = "text/html";
    
   //Create the HTML export object
   GrapeCity.ActiveReports.Export.Html.Section.HtmlExport htmlExport1 = new GrapeCity.ActiveReports.Export.Html.Section.HtmlExport();
   
       
   //Export the report to HTML in this session's webcache
   MyCustomHtmlOutputter outputter = new MyCustomHtmlOutputter(this.Context);
   this.htmlExport1.Export(rpt.Document, outputter, "");
   Response.Redirect("ReportOutput" + "/" + System.IO.Path.GetFileName(outputter.mainPage));