New Blog Template

With the growing popularity of mobile phones and lower resolution netbooks, a fixed width blog format is looking less and less appealing. I decided to work on a new look for this blog. The main feature I was looking for was a set of CSS rules that would allow the main content to scale with the viewer's browser window width. If the window is too narrow, the less important content on the sidebar should flow down below the main content.

I began with an existing theme for Blogger, Tekka, that pushes the right sidebar down beneath the main content when the window is narrow. I then made some CSS changes to tweak the look to fit my tastes.

First things first, the default fonts must go! I drew much of my inspiration from Nick Johnson's blog, specifically the way that serif fonts are used in some places for accent while sans-serif is used for most of the content. This is a technique that I experimented with a bit in a graphic design class in college.

For titles I added:

h1, h2 {
  ...
  font-family: Georgia, 'Times New Roman', Times, serif;
}

h3 {
  ...
  font-family: Trebuchet MS, Verdana, Sans-serif;
}

To change the font used for the main text in the page, I set a template variable as follows:

<Variable name="bodyFont" description="Text Font"
  type="font" 
  default="normal normal 100% 'Lucida Grande', 
    Verdana, Helvetica, sans-serif" 
  value="normal normal 100% 'Lucida Grande', 
    Verdana, Helvetica, sans-serif">

Next I set about changing the style of the title link. You see, when someone is viewing a single post, the blog title becomes a link to the main blog page. So, the blog's title is styled like a link and I found the default link styles a bit jarring. This might seem like a minor change but so often it's the little things that matter. I set this style using

h1 a:visited {
  ...
  color: #505050;
}

Now that the text styling is done, the layout could use a bit of adjustment. I changed the margins on the main content to the following:

#content-wrapper { 
  margin-top: 20px;
  margin-$endSide: 30px;
  margin-bottom: 30;
  margin-$startSide: 35px;
 }

I removed the padding from the h1 title style and the date header. I also removed the style rule entirely for the description.

We're nearing the end! The sidebar wasn't quite to my liking so I changed the border style. Lastly, in order to get the sidebar to flow down beneath the main content I set a minimum width. Here is the final style for the sidebar:

#sidebar {
  text-transform:none;
  background-color: $sidebarBgColor;
  color: $sidebarTextColor;
  padding-$startSide: 20px;
  width: 30%;
  min-width: 215px;
  float: $endSide;
  font: $bodyFont;
  border-$startSide:1px solid $mainTextColor;
  word-wrap: break-word;
  overflow: hidden;
}

I debated about posting the whole template here, but I'm not sure that it would be very readable. If you would like the whole thing, leave a comment and I can email it to you.

DOM Manipulation in JavaScript, a Utility

In my latest addition to the q12 JavaScript library, I have added a simple function to construct a nested document structure. I grew tired of writing repetitive and difficult to follow code like this

var div = document.createElement('div');
div['id'] = 'outer-div';
var link = document.createElement('a');
link.href = 'http://blog.jeffscudder.com';
link.appendChild(document.createTextNode('my blog'));
div.appendChild(link);

Using the new tree function this would become:

var div = tree([
    'div', {
        id: 'outer-div'}, [
      'a', {
          href: 'http://blog.jeffscudder.com'}, [
        'my blog']]]);

In the process of writing this utility function, I came across another small oddity in editing HTML using JavaScript related to the style attribute. Most HTML attributes are simple text properties, however when editing the CSS style of a node, you cannot set the full content of the style attribute.

// You cannot do this:
div.style = "color:red; font-weight:bold";

Instead, you set each sub item in the style attribute:

// This works:
div.style.color = 'red';
div.style['font-weight'] = 'bold';

The tree function that I've written handles this nested style structure as well. Here's an example:

['div', {
    'id': 'foo', 
    'style': {'color': 'red', 'font-weight': 'bold'}}, 
  'This works too!']

Now that you have an idea of how to use this utility, here's the code. Minus the comments it's only about twenty-one lines.

/**
 * Creates a DOM tree from a simple list.
 * The structure of the tree passed in is as follows:
 * ['elementTag', 
 *      {attribute1: value,
 *       attribute2: value,
 *       style: {property1: value,
 *               property2: value}},
 *    'child text node',
 *    ['elementTag',
 *         {property: value},
 *       'grandchild text node'],
 *    'third node']
 * The above will result in a DOM node which has three child nodes, the
 * first and third will be text nodes because the values were strings.
 * The second child node will be a DOM node as well.
 *
 * @param {Array} t The tree's structure as a collection of strings, lists,
 *     and simple objects. The structure is as follows
 *     ['elementTag', {attributes}, child, child, child, ...]
 * @return {Element} Returns a new DOM element.
 */
function tree(t) {
  // Create the node using the tag which is first in the list.
  var domNode = document.createElement(t[0]);
  // Add all HTML attributes to the node.
  for (var key in t[1]) {
    // The style attributes get special treatment.
    if (key == 'style') {
      for (var styleAttribute in t[1].style) {
        domNode.style[styleAttribute] = t[1].style[styleAttribute];
      }
    } else {
      domNode[key] = t[1][key];
    }
  }
  // Iterate over all child nodes, converting them to either text or HTML
  // nodes.
  for (var index = 2, child; child = t[index]; index++) {
    if (typeof(child) == 'string') {
      domNode.appendChild(document.createTextNode(child));
    } else {
      // Buid recursively.
      domNode.appendChild(tree(child));
    }
  }
  return domNode; 
}

What do you think, is there anything you would add?

On a realted note, if you're interested in a more powerful templating system, you might want to try Closure Templates which were recently open sourced.