CodeProject: ASP.NET Watermarker Module. Free source code and programming help

Report Article

Discuss

Send to a friend

20 votes for this Article.

Popularity: 5.43 Rating: 4.17 out of 5

Introduction

This article presents a technique for applying watermark images to ASP.NET web forms though the use of an HTTP module. The concept of filtering the HTTP stream as a means for inserting additional markup is presented through the definition of the custom InsertionFilterStream class. To simplify the creation of modules that would perform this filtering, the base class InsertionModuleBase is presented with a virtual method FilterString. Finally, the WatermarkerInsertionModule class is defined as a functional subclass of the base, providing a practical means for inserting common watermark images across web forms and applications.

Background

In June of 2005, CodeProject member Kenny Young [^] posted a nice article, ASP.NET - C# Application Environment Backsplash [^], in which he demonstrated a technique of using a custom Page class as a base page for applying watermark images (Kenny refers to them as “backsplashes” in his article). Any page in an ASP.NET application that would display the watermark would inherit from his BasePage class.

As Kenny demonstrated, a simple style attribute inserted into the <body> tag of the output HTML is all that is necessary to create the watermark. I liked the concept of automating a watermark image, particularly to distinguish among development, beta, or production environments, and wondered whether or not such functionality could also be accomplished using an HTTP module. (Readers who are unfamiliar with HTTP modules are encouraged to examine George Shepherd's MSDN article on the topic [^] for an introduction.) Such an implementation would tap into the HTTP stream itself, eliminating the need to derive watermarked pages from a custom Page class.

At first thought, one might attempt to manipulate the HttpResponse.OutputStream [^] property directly to read from the HTTP stream and insert the required style attribute. After all, this property holds the Stream object that represents the outgoing HTTP content, and the HttpResponse object is certainly available in the context of an HTTP module. Unfortunately, this possibility is prevented by the fact that the OutputStream property actually contains an HttpResponseStream type, which is write-only. Attempts to read from an HttpResponseStream object result in an exception being thrown.

Filtering the HTTP Stream

What is allowed is the filtering of the output stream. The HttpResponse object exposes a Filter [^] property, which itself is a Stream type. If Filter is set, then any output written to the response stream is redirected to the filtering stream. The filter may perform its manipulation of the contents, but must then write its results back to the original stream. This effectively forms a chain of two streams; indeed, multiple filtering streams may be applied, provided each assumes the responsibility of writing back to the stream object it is replacing as the Filter.

Our filtering stream is defined by the InsertionFilterStream class included with the source download, the constructor of which follows:

public class InsertionFilterStream : Stream
{
  // the original stream we are filtering

  private Stream _originalStream;
 
  // the response encoding, passed in the constructor

  private Encoding _encoding;

  // our string replacement function for inserting text

  private FilterReplacementDelegate _replacementFunction; 

  . . .

  // the constructor must have the original stream for which this one is

  // acting as a filter, the replacement function delegate, and the

  // HttpResponse.ContentEncoding object


  public InsertionFilterStream(Stream originalStream
    , FilterReplacementDelegate replacementFunction
    , Encoding encoding)
  {
    // remember all these objects for later

    _originalStream = originalStream;
    _replacementFunction = replacementFunction;
    _encoding = encoding;
  }

  . . .
}

Three important pieces of information will be passed in to the constructor for our filtering object. The first is the original Stream object for which we’re performing our string manipulations. This will likely be the HTTP output stream, but there could be one or more additional filter streams already in place. In practice, we’ll use whatever stream is already set for the HttpResponse.Filter property; if no other filter were already applied, this would be the output stream itself.

The second piece of information is a delegate, pointing to the function that will perform a string replacement. The delegate is defined with the following signature:

public delegate string FilterReplacementDelegate(string s);

As we’ll see later, this offers simplicity for the developer; rather than dealing with encoded byte arrays, the developer will use common string objects.

The final parameter for the constructor is an Encoding object. This will also be retrieved from the HttpResponse object through its ContentEncoding property, allowing our implementation to be neutral to the given character set. These three objects are stored in private class variables for later use.

The most important method in our filtering Stream subclass is the Write method. When Write is called, it is passed a byte array, already encoded according to the response stream’s character set. Our overridden method performs these important steps: it converts the encoded byte array to a plain string for ease of use, passes that string to the replacement function delegate, re-encodes the result as a byte array, and writes the bytes back to the original output stream.

public override void Write(byte[] buffer, int offset, int count)
{
    // we want to retrieve the bytes in the buffer array, which are already

    // encoded (using, for example, utf-8 encoding). We'll use the 

    // HttpResponse.ContentEncoding object that was passed in the 

    // constructor to return a string, while accounting for the character

    // encoding of the response stream

    string sBuffer = _encoding.GetString(buffer, offset, count);
 
    // having retrieved the encoded bytes as a normal string, we

    // can execute the replacement function

    string sReplacement = _replacementFunction(sBuffer);
 
    // finally, we have to write back out to our original stream;

    // it is our responsibility to convert the string back to an array of

    // bytes, again using the proper encoding. 

    _originalStream.Write(_encoding.GetBytes(sReplacement)
        , 0, _encoding.GetByteCount(sReplacement));
    
}

The Base HTTP Module

With our InsertionFilterStream class prepared to intercept writes to the output stream, we’ll use an HTTP module to hook into the web application’s events and instate our filter. An HTTP module is created by implementing the IHttpModule [^] interface, and installed in the HTTP pipeline by adding an item to the <httpModules> subsection of the <system.web> section of a web.config or machine.config file.

The IHttpModule contract requires the implementer to define two methods: Init and Dispose. The ASP.NET runtime will call Init for each installed module, passing each the HttpApplication object. With this object, the module may install handlers for any number of events exposed by the web application. In our case, we only need to hook into the BeginRequest event.

To support a simple model for creating modules that rely on string replacement functions to insert additional markup, we’ll define a base class that handles the appropriate event interaction with the web application. We’ll also include a virtual method called FilterString which is sent to the InsertionFilterStream object as a delegate. The InsertionModuleBase class is shown below in its entirety:

public class InsertionModuleBase : IHttpModule
{    
    private FilterReplacementDelegate   _replacementDelegate = null;
    private InsertionFilterStream       _filterStream = null;
 
    public InsertionModuleBase()
    {
    }
 
    // required to support IHttpModule

    public void Dispose()
    {           
    }
     
    public void Init(HttpApplication app)
    {
        // setup an application-level event handler for BeginRequest

        app.BeginRequest 
          += (new EventHandler(this.Application_BeginRequest));          
    }
 
    private void Application_BeginRequest(object source, EventArgs e)
    {
        // upon an application page request, establish our 

        // InsertionFilterStream object in the HttpResponse 

        // filter chain

 
        HttpApplication app = source as HttpApplication;
        if (app != null)
        {
            // construct the delegate function, using the FilterString method;

            // as this method is virtual, it would be overriden in subclasses

            _replacementDelegate = new FilterReplacementDelegate(FilterString);
 
            // construct the filtering stream, taking the existing 

            // HttpResponse.Filter to preserve the Filter chain;

            // we'll also pass in a delegate for our string replacement 

            // function FilterString(), and the character encoding object 

            // used by the http response stream. These will then be used

            // within the custom filter object to perform the string 

            // replacement.

            _filterStream = new InsertionFilterStream(
                                      app.Response.Filter
                                     , _replacementDelegate
                                     , app.Response.ContentEncoding
                            );
 
            // set our filtering stream as the new HttpResponse.Filter 

            app.Response.Filter = _filterStream;
        }
    }

    // This is the function that will be called when it's time to perform

    // string replacement on the web buffer. Subclasses should override this

    // method to define their own string replacements

    protected virtual string FilterString(string s)
    {
        // by default, perform no filtering; just return the given string

        return s;
    }

}

A Simple Insertion Module

An insertion module may now be created by subclassing InsertionModuleBase and overriding the FilterString method. Here is a simple but complete example that replaces the <body> tag of the HTML output with one adorned with a background color, and a heading <table> displaying the text “Development”.

public class SimpleInsertionModule : InsertionModuleBase
{
    protected override string FilterString(string s)
    {
        return s.Replace("<body>"
             , "<body bgcolor='#EFEFEF'>"
             + "  <table width='100%' bgcolor='pink'>"
             + "    <tr><td>Development</td></tr>"
             + "  </table>");
    }
}

Provided a compiled version of this class (and the supporting classes InsertionModuleBase and InsertionFilterStream) were available to a web application (i.e. installed in the global assembly cache, or copied into the application’s /bin directory), a simple addition to the application’s web.config file is all that is necessary for this string replacement to occur with all the application’s web forms. Alternatively, the addition may be made to the server’s machine.config file, in which case all applications on the server would have the functionality available.

Custom HTTP modules are included in the HTTP pipeline by adding items to the <httpModules>[^] section of web.config (which is nested within <system.web>). The following format is used to add a module to the HTTP pipeline:

<add type="classname,assemblyname" name="modulename"/>

So to indicate the inclusion of the SimpleInsertionModule defined above, assuming the namespace MyNamespace, compiled into a .dll called InsertionModules.dll, we could use the following fragment in web.config or machine.config:

<configuration>
  <system.web>
    <httpModules>
      <add type=”MyNamespace.SimpleInsertionModule,InsertionModules”
           Name=”SimpleInsertionModule” />
    </httpModules>
  </system.web>
</configuration>

The WatermarkerInsertionModule Class

To accomplish the original challenge, the inclusion of a watermark image using an HTTP module rather than a Page subclass, we again subclass InsertionModuleBase and override the FilterString method. In addition to watermarking, we’ll provide the ability to add a header and/or footer. We’ll also use regular expressions for more robust pattern matching and case-insensitive replacements. The WatermarkerInsertionModule class is shown below in its entirety:

public class WatermarkerInsertionModule : InsertionModuleBase
{
    protected override string FilterString(string s)
    {
        string sReturn = s;        
 
        // check configuration settings for what the watermarker module 

        // should do;

        string sImage 
     = ConfigurationSettings.AppSettings["WatermarkerInsertionModule_Image"];
        string sTopContents 
     = ConfigurationSettings.AppSettings["WatermarkerInsertionModule_Top"];
        string sBottomContents 
     = ConfigurationSettings.AppSettings["WatermarkerInsertionModule_Bottom"];
 
        // if we want a watermark image, add a <style> tag just before 

        // the </head> tag

        if (sImage != String.Empty && sImage != null)
        {
            Regex rHeadEnd = new Regex("(</head>)", RegexOptions.IgnoreCase);
            
            // this style tag is borrowed directly from Kenny's article

            string sStyle = "<style>body {" 
                          + "background-image: url(" + sImage + "); "
                          + "background-attachment: scroll; "
                          + "background-repeat: repeat; "
                          + "background-color: transparent; "
                          + "}</style>";

            sReturn = rHeadEnd.Replace(sReturn, sStyle + "</head>");
        }
 
        // if we want contents at the top, insert them immediately 

        // after the body tag; we'll use a regular expression to 

        // find the body tag, in case it has other attributes

        if (sTopContents != String.Empty && sTopContents != null)
        {
            Regex rBodyBegin = new Regex("<body.*?>", RegexOptions.IgnoreCase);
            Match m = rBodyBegin.Match(sReturn);
            if (m.Success)
            {
                string matched = m.Groups[0].Value;
                sReturn = sReturn.Replace(matched, matched + sTopContents);
            }
        }
 
        // if we want contents at the bottom, insert them immediately 

        // before the closing </body> tag; again, just to make sure 

        // we're doing this in a case-insensitive way, we'll use a 

        // regular expression to locate it.

        if (sBottomContents != String.Empty && sBottomContents != null)
        {
            Regex rBodyEnd = new Regex("</body>", RegexOptions.IgnoreCase);
            sReturn = rBodyEnd.Replace(sReturn, sBottomContents + "</body>");
        }
 
        // return the filtered string

        return sReturn;
    }
}

As in the previous SimpleInsertionModule example, the deployment of WatermarkerInsertionModule involves the following steps:

Install the compiled .dll containing the WatermarkerInsertionModule, InsertionFilterStream, and InsertionModuleBase classes to either the global assembly cache, or the web application’s /bin directory.
Modify either the machine.config file on the server, or the web.config file in the web application directory, to include the appropriate <add> item in the <httpModules> section of <system.web>.

Additional Considerations

While boiling down this replacement process to a single overridden FilterString method in a custom subclass may provide a convenience to the developer, it’s not without a price. Converting the byte array to a string and back again entails more overhead than just manipulating the byte array directly. For that matter, using an HTTP module is its own form of overhead. While it may be appropriate to watermark using this technique for lower-volume development or beta deployments, it may not be the best option for, say, applying a common copyright notice in footers of pages on a high-volume production site. The developer must make the decision as to whether the performance hit from this technique is worth the functionality for his or her own environment.

Additionally, this technique assumes that the server is buffering page output, so the complete page may be sent to the client in one call to Write (this is the default ASP.NET behavior). If page buffering is disabled (by setting Page.Response.BufferOutput to false), this technique may produce unexpected results.

It is also important to note that when configured in <httpModules>, the module receives all requests passed to it by the ASP.NET runtime. There may be situations, for example, an .aspx page that changes the content-type and outputs a binary stream, or web methods that return SOAP-formatted messages, in which you would want the module to be disabled, or at least to ignore the request. You may wish to modify the module source to check for the content type, or choose to place such pages in their own subdirectory, incorporating additional web.config files with <remove> tags in the <httpModules> section to disable the module entirely under those types of circumstances.

About the Demo Project

The demo project contains the file InsertionModuleBase.dll, which is a compiled version of all the custom classes mentioned in this article. Web.config files are used in both the main project directory and in subdirectories to configure the inclusion or exclusion of the WatermarkerInsertionModule for different page options.

Summary

Presented as an alternative to creating a base Page class, the WatermarkerInsertionModule provides an implementation of the IHttpModule interface for the purpose of applying watermark images and common headers and footers to web forms. It inherits from the class InsertionModuleBase in which is defined the consumption of the web application’s BeginRequest event, and the incorporation of a custom filter for the HTTP output stream. The InsertionFilterStream intercepts calls to the Write method, and applies the string replacement function defined in WatermarkerInsertionModule. Provided a developer’s environment allows for page buffering and the requisite performance hit that comes with string conversion and module overhead, the WatermarkerInsertionModule can be a convenient utility for performing automated watermarking on web forms.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Mike Ellison

I work for the University of Nevada, Las Vegas in the Office of Institutional Analysis and Planning. Among other things, our office is charged with the mission of deriving useful information in support of administrative decision-making from institutional data. Within the context of that mission, my office mates and I apply technology in the form of custom data processing applications, data extraction and analysis tools, reporting tools, relational databases, OLAP solutions, data warehousing, and data mining.

Location:

United States

Other popular ASP.NET articles:

Multiple File Upload With Progress Bar Using Flash and ASP.NET
How to use Flash to upload multiple files in a medium-trust hosting environment
CAPTCHA Image
Using CAPTCHA images to prevent automated form submission.
10 ASP.NET Performance and Scalability Secrets
10 easy ways to make ASP.NET and AJAX websites faster, more scalable and support more traffic at lower cost
Paging of Large Resultsets in ASP.NET
An article about optimization and performance testing of MS SQL Server 2000 stored procedures used for paging of large resultsets in ASP.NET
File Upload with ASP.NET
This article shows you how work with uploading of the files using ASP.NET and C#.

Article Top

You must Sign In to use this message board.

Msgs 1 to 22 of 22 (Total in Forum: 22) (Refresh)

FirstPrevNext

Checking content type to prevent problems with images and other files

AlastairM

13:00 15 Dec '08

This was a great article and it has been really useful.

I ran in to one or two problems with my own replacement funtions on certain file types. When I checked the Content Type in the Application_BeginRequest function in the InsertionModuleBase I found it was always text/html.

Testing each of the application lifecycle events, the content type did not seem to change for images until the PostRequestHandlerExecute event. Fortunately the filter does not get applied until later.

I found this article helpful: http://msdn.microsoft.com/en-us/library/ms178473.aspx

Updating the code in the InsertionModuleBase class as follows solved the issue:


public void Init(HttpApplication app)
{
    // setup an application-level event handler for PostRequestHandlerExecute instead of for BeginRequest
    app.PostRequestHandlerExecute += (new EventHandler(this.Application_PostRequestHandlerExecute));
}

// Application_BeginRequest function renamed to Application_PostRequestHandlerExecute
private void Application_PostRequestHandlerExecute(object source, EventArgs e)
{
    HttpApplication app = source as HttpApplication;
    // check the content type
    if (app != null && app.Response.ContentType == "text/html")
    {
        // same as before...
    }
}

Thank you very much.

5.00/5 (1 vote)

Re: Checking content type to prevent problems with images and other files

Mike Ellison

14:15 15 Dec '08

Thanks for the contribution, Alastair. That makes perfect sense.
Sign In·View Thread·PermaLink

Dosn't work with ASP.NET 2.0

hakervytas

7:10 16 Mar '07

Hi, I tryed your example, converted using VS.NET 2005 convertion to ASP.NET 2.0 and after tryed run your demo examples, not apears images and text too (not works). Will be good if you post working example for ASP.NET 2.0 Thank's
Sign In·View Thread·PermaLink

Re: Dosn't work with ASP.NET 2.0

Mike Ellison

8:49 16 Mar '07

Yea, that may be. You can see that the coding is dependent on the expectation of how pages are rendered in 1.1. I think the concept could still work the same in 2.0, but there may need to be adjustments to work for how 2.0 is rendering pages. I haven't tried this in 2.0, but if you work with it please feel free to post your experiences.
Sign In·View Thread·PermaLink

Image content not showing up

chriscaldwell2000

6:12 10 May '06

BTW, thanks for the code. It's extremely useful. I noticed that my images are now showing up when I used the SimpleInsertionModule with a simple string replacement ("?id=" to "?ids="). any ideas as to why the image content is not getting rendered? Thanks!
Sign In·View Thread·PermaLink	5.00/5 (1 vote)

Re: Image content not showing up

Mike Ellison

11:09 14 May '06

Hi Chris. I'm not following you - if you're using the SimpleInsertionModule in the article, you wouldn't be using ?id=... I don't think. What am I missing in your question?
Sign In·View Thread·PermaLink	1.00/5 (1 vote)

Re: Image content not showing up

pophelix

14:56 25 Jan '07

图片真的不能显示出来图片真的不能显示出来图片真的不能显示出来
Sign In·View Thread·PermaLink

multiple calls to Write on large pages

travislaborde

17:13 24 Jan '06

Great article, thanks, but....

I've found that even with buffering turned ON, if the page output is large (say a datagrid with 100 rows), there are multiple calls to the Write() method. Do you know of any way around this, or to force it to only hit the Write() method once?

I'm very excited about my own implementation of this idea, but I'm being killed by the multiple Write() calls.

Thanks!
Travis

Travis

Re: multiple calls to Write on large pages

Mike Ellison

15:03 25 Jan '06

Hi there Travis. I'm not sure there is anything we can do about this... the calls to Write() would be made by the aspnet parser. Is it slowing down too much with the multiple calls?
Sign In·View Thread·PermaLink

Re: multiple calls to Write on large pages

travislaborde

3:48 26 Jan '06

No but I was parsing for data that might get split among multiple calls to Write(). I've decided to use the Write() method to gather data but keep the stream empty, then use the Flush() method to write out what I want, when it's done. Thanks, Travis Travis
Sign In·View Thread·PermaLink

Re: multiple calls to Write on large pages

Mike Ellison

5:08 26 Jan '06

Oh, I see. Sure - that makes sense. I'm glad you've got something that works for you.
Sign In·View Thread·PermaLink

Working with content types and rewriting urls

Casper Leon Nielsen

4:40 4 Oct '05

Hi all

Used this premium example Rose

as a working base for rewriting urls on our site.

Had a lot of articles on the form http://mysite/index.aspx?articleId=120, which is treated quite badly by search engines, so we decided to rewrite all internal urls to the form http://mysite/some_name_describing_content.aspx which get better placement in searchengine results.

When implementing this we discovered a little addition to the above code which would make it work with embedded types of content other than "html/txt":

And we also discovered what we believe is a small bug, namely that the Encoding property in the InsertionFilterStream is not correct if one changes the content encoding dynamically.

We propose that the Response object itself is given to the stream constructor:

InsertionFilterStream changes:


[...]

		private Encoding _encoding
		{
			get
			{
				return _response.ContentEncoding;
			}
		}

		private HttpResponse _response;
[...]

		// constructor must have the original stream for which this one is acting as
		// a filter, the replacement function delegate, and the HttpResponse		public InsertionFilterStream(Stream originalStream, FilterReplacementDelegate replacementFunction, HttpResponse response)
		{
			// remember all these objects for later
			_originalStream = originalStream;
			_replacementFunction = replacementFunction;		
			_response = response;
		}
		    
[...]
		// override the Write method to inspect the buffer characters and
		// perform our text replacement
		public override void Write(byte[] buffer, int offset, int count)
		{
                        //we only want to filter stuff that are text.
			if( _response.ContentType == "text/html" ) 
			{
				// we want to retrieve the bytes in the buffer array, which are already
				// encoded (using, for example, utf-8 encoding).  We'll use the 
				// HttpResponse.ContentEncoding object that was passed in the 
				// constructor to return a string, while accounting for the character
				// encoding of the response stream
				string sBuffer = _encoding.GetString(buffer, offset, count);
			
				// having retrieved the encoded bytes as a normal string, we
				// can execute the replacement function
				string sReplacement = _replacementFunction(sBuffer);

				// finally, we have to write back out to our original stream;
				// it is our responsibility to convert the string back to an array of
				// bytes, again using the proper encoding.  
				_originalStream.Write(_encoding.GetBytes(sReplacement)
					, 0, _encoding.GetByteCount(sReplacement));
			}	
			else 
			{
				_originalStream.Write(buffer, 0, count);
			}

		}
	}

And to make it work in the InsertionModuleBase:


				_filterStream = new InsertionFilterStream(
					app.Response.Filter
					, _replacementDelegate
					, app.Response
					);

Working with content types

Casper Leon Nielsen

4:49 4 Oct '05

Oh I forgot: You should also be aware that the `_encoding.GetString(buffer, offset, count);` function is, at least in .Net 1.0, not implemented for Encoding types: "iso-8859-1" and "windows-1252". It _is_ implemented for "UTF-8" however.
Sign In·View Thread·PermaLink

Re: Working with content types and rewriting urls

Mike Ellison

7:37 4 Oct '05

Hi Casper. Nice suggestion - thanks for posting it.
Sign In·View Thread·PermaLink

Re: Working with content types and rewriting urls

Berto Vermeer

0:08 11 Jul '06

Thanks for this solution! I had problems with downloading files like .zip .pdf .doc etc This solution work perfect for me! Berto Vermeer
Sign In·View Thread·PermaLink

Nice idea

mikedepetris

5:55 26 Sep '05

We had to implement our own code to make our "test sites" recognizable by users, so I want to share this experience.

We keep several web.config files with the web project. We have webDevelpment.config, webPrerelease.config, webProduction.config, webSimulation.config. When we publish a new release, we copy the right file as web.config.

In the web config files there are keys ho define what databases to access, what functions are enabled adn so on, keys are set to values like "development", "prerelease", "production".

When the code build the web page, it checks autorization keys as well as the above keys, and when the value is not "production" a background image with the text "TEST" is included everywhere, background of the page and various cells in tables.

Your solutions is much cleaner but... we have few pages where we need buffer=off.

Any suggestions are welcome to help me manage our development cycle, expecially manage those bad web configs, my first idea was to keep one web.config that includes different config xmls depending on the above keys.

any better idea?

Re: Nice idea

Mike Ellison

6:08 26 Sep '05

Hi there. I don't think there's anything wrong with the approach you're taking. It reminds me a lot of Kenny's original article (which is cited at the beginning of this article) in which there is code built in to your application to read in keys from web.config.

I guess whether you choose to maintain multiple .config files vs. multiple sections in one .config file for handling development vs. production types of values is really a matter of personal preference. Whatever makes more sense to you.

Re: Nice idea

mikedepetris

7:01 26 Sep '05

It is quite bad to keep all these web.config files, the file is long and a lot of sections are the same or just almost equal between files, so it is quite dangerouse to keep all of them costantly updated. I think it would be much better at this point to have one unique file, with all the keys that are the same for the environment sites, and different xml files with only the different key in them.
Sign In·View Thread·PermaLink

Good Implementation

Kenny Young

14:49 16 Sep '05

Mike, This is a nice alternative to the BaseClass application environment "watermark". Filtering the HTTP Stream was a great idea. Kenny Young
Sign In·View Thread·PermaLink

Re: Good Implementation

Mike Ellison

14:52 16 Sep '05

Thanks, Kenny. Your article really made me think about this and I learned some new things in the process. I appreciate it.
Sign In·View Thread·PermaLink

Wow!

Dario Solera

9:34 16 Sep '05

I was searching some way to let the users know the website is in some kind of development status. Perfect! I'll use this skill! Tozzi is right: Gaia is getting rid of us. Do you feel the way you hate or do you hate the way you feel?
Sign In·View Thread·PermaLink

Re: Wow!