Introduction
This article shall describe a simple tool you can build and use to create the
CSS to apply a gradient overlay to buttons, divs, or whatever you like, in an
ASP.NET or just plain HTML project. The tool accepts a gradient overlay and
background color inputted by the user and it emits the CSS required to render
the effect on a web page. The download includes the code for the tool itself as
well as a simple demo website showing the output at work.
Figure 1: Gradient Button Tool in Use
The CSS generated by the tool may be used to define, for example, the normal
appearance of a button, the button under hover, and the button once activated.
One may copy and paste the CSS into the appropriate classes in a style sheet to
support the appearance of different elements of the page including buttons,
banners, or whatever you think might look better with a gradient effect applied
to it.
The tool converts the overlay image to a base 64 string; the advantage being
that once the user has obtained the CSS, there is no separate image to download
and so the CSS file itself is all that is required; multiple separate image file
downloads can eliminated within a single project.
Figure 2: Demo Website with Buttons and a Banner Styled Using the Tool
In order to use the tool, it is necessary to first create the gradient. I used
Expression Design to accomplish that task. I start by adding identical two
rectangles to a new project; the height of the rectangles are set to be equal
and should be the same height as you intend for the item you are styling. I
offset the rectangles horizontally, set the border to nothing. I set the lower
image to the background color and apply a gradient effect to the upper image as
shown in the following image (except for leaving the border visible to
illustrate the presence of two rectangles).
Figure 3: Figuring Out the Gradient in Expression Design
For the gradient, I first change the gradient orientation to vertical from the
default horizontal. I then set one end of the gradient to be transparent and the
other to a suitable color (which will depend on the background color to some
extent). Once I am satisfied with the appearance, I export a slice 1 pixel wide
out to a temp folder.
Figure 4: Exporting a 1 pixel wide slice in Expression Design
Once the slice has been exported, I can use the tool to generate my CSS for me
and to pack the image into that CSS. You should only do this with a very small
image such as the 1 pixel wide slice; converting large images to a Base 64
string and embedding that into the CSS does not help out much.
The tool itself is simple enough; first load the gradient into the Image File
field using a file open dialog triggered from the Browse button. Then set the
background color using the color picker launched by clicking the Set Background
color button. Lastly, click the Generate CSS button at the bottom of the page to
generate the CSS required to create the appearance. The CSS will be shown in
this format:
background: #000080
url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAfCAYAAAAmyadiAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFxE
AABcRAcom8z8AAABESURBVBhXrYwxDoAwDMQuzsz/X8mUDBSpPShvYLFkWbIkOfvqg4wsbDeWi4j4tCAp1r2aOWcxxihOna23wh5s6EfsnR+8nSVffqczwQAAAABJ
RU5ErkJggg==")
repeat-x;
This CSS fragment can then be added to your CSS
to supply the gradient background with no separate image files required; for
example, if we have a command button class, we could use the tool to create
separate background appearances for the normal, hover, and active states:
/* button style*/
.commandbutton{
color:#FFFFFF;
border-radius:5px;
-moz-border-radius:5px;
-webkit-border-radius:5px;
border:0px;
font-size:1em;
text-align:center;
height:30px;
width:100px;
padding:5px;
background: #000000 url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAfCAYAAAAmyadiAAAAAXNSR0IArs4c6QAAAARnQU1BAAC
xjwv8YQUAAAAJcEhZcwAAFxEAABcRAcom8z8AAABESURBVBhXrYwxDoAwDMQuzsz/X8mUDBSpPShvYLFkWbIkOfvqg4wsbDeWi4j4tCAp1r2aOWcxxihOn
a23wh5s6EfsnR+8nSVffqczwQAAAABJRU5ErkJggg==") repeat-x;
}
.commandbutton:hover{
background:#F5170C url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAfCAYAAAAmyadiAAAAAXNSR0IArs4c6QAAAARnQU1BAACx
jwv8YQUAAAAJcEhZcwAAFxEAABcRAcom8z8AAABESURBVBhXrYwxDoAwDMQuzsz/X8mUDBSpPShvYLFkWbIkOfvqg4wsbDeWi4j4tCAp1r2aOWcxxihOna
23wh5s6EfsnR+8nSVffqczwQAAAABJRU5ErkJggg==") repeat-x;
}
.commandbutton:active{
border-right:#FFF 2px solid;
border-bottom:#FFF 2px solid;
border-left:#000000 2px solid;
border-top:#000000 2px solid;
background:#2B315A url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAfCAYAAAAmyadiAAAAAXNSR0IArs4c6QAAAARnQU1BAACx
jwv8YQUAAAAJcEhZcwAAFxEAABcRAcom8z8AAABESURBVBhXrYwxDoAwDMQuzsz/X8mUDBSpPShvYLFkWbIkOfvqg4wsbDeWi4j4tCAp1r2aOWcxxihOna
23wh5s6EfsnR+8nSVffqczwQAAAABJRU5ErkJggg==") repeat-x;
}
This bit of CSS would render
out per the following example images:
Figure 5: Command Button class
Figure 6: Command Button Hover
Figure 7: Command Button Active
Getting Started
There are two solutions in the download; the first is the tool itself and it is
entitled, "Base64Gen". The second project is entitled, "" and it demonstrates
the output of the tool as used in a website.
The first "Base64Gen" project contains three forms, "about" which is an about
box, "instructions" which provides some simple instructions for using the tool,
and the last, "main" is the actual tool. All code required by the tool is
contained in the main.cs file. The about box and instructions forms are not
relevant to this project and so will be not be described herein.
Figure 8: Base64Gen Solution
The second solution is an ASP.NET web forms project containing a single web page
displaying a banner and a few buttons styled using the tool. It also contains a
CSS file used to contain the styles built around the CSS emitted by the tool.
Figure 9: Gradient Button Test Solution
First Solution – Base64GEn:
Code: Main.cs
Main.cs is the tool. It contains the code needed to load the overlay image, set
the background color, and to generate the CSS. The code is annotated and should
be self-explanatory:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
namespace Base64Gen
{
public partial class main : Form
{
// form variables
private string imageFilePath;
private Color backColor;
private string hexColor;
// default constructor
public main()
{
InitializeComponent();
}
/// <summary>
/// Open an image file - this should be a slice of a gradient,
/// 1px wide and at whatever height is needed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnOpenImage_Click(object sender, EventArgs e)
{
// configure open file dialog
openFileDialog1.Title = "Source Image File";
openFileDialog1.Filter = "png files (*.png)|*.png";
openFileDialog1.FileName = string.Empty;
// return if user cancels dialog
if (openFileDialog1.ShowDialog() == DialogResult.Cancel)
return;
// get the path to the image file
string sFilePath = openFileDialog1.FileName;
// make sure the string has content
if (String.IsNullOrEmpty(sFilePath))
{
MessageBox.Show("File path does not exist", "File");
return;
}
// make sure the file exists
if (System.IO.File.Exists(sFilePath) == false)
{
MessageBox.Show(String.Format("File {0} does not exist", sFilePath),
"Missing File");
return;
}
// update the display to show the file path and set the form
// variable imageFilePath to the file path
imageFilePath = sFilePath;
txtImgFile.Text = imageFilePath;
}
/// <summary>
/// Exit the application upon user request
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnExit_Click(object sender, EventArgs e)
{
Application.Exit();
}
/// <summary>
/// Convert the image to a base 64 string
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvert_Click(object sender, EventArgs e)
{
if (String.IsNullOrEmpty(imageFilePath))
{
MessageBox.Show("Invalid or missing file name, please select a PNG
file to continue.", "Missing Image File");
}
else
{
txtBase64.Text = GetBase64String();
}
}
/// <summary>
/// Create a CSS snippet to set the background to the selected color
/// with the gradient image file overlay
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnGenCSS_Click(object sender, EventArgs e)
{
StringBuilder sb = new StringBuilder();
sb.Append("background: " + hexColor + " url(\"data:image/png;base64," +
GetBase64String() + "\") repeat-x;");
txtBase64.Text = sb.ToString();
}
/// <summary>
/// Conver the image to a base 64 string so that it can be
/// embedded into the CSS file
/// </summary>
/// <returns></returns>
private string GetBase64String()
{
try
{
// set a string pointing to the file to be converted
string fileToConvert = imageFilePath;
// get the length of the file
FileInfo fInfo = new FileInfo(fileToConvert);
long numBytes = fInfo.Length;
// open/read file into a filestream
FileStream fStream = new FileStream(fileToConvert,
FileMode.Open, FileAccess.Read);
// get a binary reader pointed at the
// filestream
BinaryReader br = new BinaryReader(fStream);
// get a byte array from the binary reader
byte[] data = br.ReadBytes((int)numBytes);
br.Close();
// convert the byte array to a base 64 string
string base64String = Convert.ToBase64String(data);
txtBase64.Text = base64String;
// clean up
fStream.Close();
fStream.Dispose();
// return the string
return base64String;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
return string.Empty;
}
}
/// <summary>
/// Display the about box
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void aboutThisBase64GenToolStripMenuItem_Click(object sender,
EventArgs e)
{
about f = new about();
f.ShowDialog();
}
/// <summary>
/// User a color dialog to set the background color
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnHoverColor_Click(object sender, EventArgs e)
{
DialogResult result = colorDialog1.ShowDialog();
if (result == DialogResult.OK)
{
// get the background color from the dialog and display
// the selected color by setting the picturebox background
// color to the selected color
backColor = colorDialog1.Color;
pboxBackground.BackColor = backColor;
// convert backcolor to hex and format a hex string
string hex = string.Format("0x{0:X8}", backColor.ToArgb());
hexColor = "#" + hex.Substring(hex.Length - 6, 6);
lblColor.Text = "Background Color: " + hexColor;
}
}
/// <summary>
/// Display some simple instructions for how to use the
/// program
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void howToUseThisProgramToolStripMenuItem_Click(object sender,
EventArgs e)
{
instructions f = new instructions();
f.Show();
}
}
}
Second Solution - Gradient Button Test
This solution contains a single asp.net web forms application with a single web
page (default.aspx) and a single CSS style sheet. The gradients used on the web
page were generated using the tool and the CSS fragments were placed into
classes in the style sheet and applied to elements in the web form.
Summary.
The article provides instructions for creating a simple tool that can be used to
help define imageless CSS background styles that may be used to style button,
banners, and so forth on a web page. The tool may be used in ASP.NET with web
forms or it may be used with a straight HTML based project. Building the styles without requiring separate and multiple image file downloads can improve
performance slightly by eliminating the additional file downloads.