Imports System 
Imports System.IO 
Imports System.Web 
Imports System.Text
Imports GrapeCity.ActiveReports 
Imports GrapeCity.ActiveReports.Export.Html

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;
  }

Dim rpt As New rptCustHTML()
Try
 
rpt.Run(False)
Catch eRunReport As Exception
'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
End Try

'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

Dim HtmlExport1 As New GrapeCity.ActiveReports.Export.Html.Section.HtmlExport()

Dim outputter As New MyCustomHtmlOutputter(Me.Context)
HtmlExport1.Export(rpt.Document, outputter, "")
Response.Redirect("ReportOutput" + "/" + System.IO.Path.GetFileName(outputter.mainPage))

   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));