Jan 172012
 

vim has an awesome feature, using which you can pipe a range through an external command. This is pretty useful if you’re opening up an un-indented or poorly-indented XML or HTML file. If you want to indent your entire file, simply do the following:

:%!tidy -i -xml -q

The -i option tells tidy that it needs to indent the content, -xml tells tidy that the content is well-formed XML, and -q puts tidy into “quiet mode” where extraneous information is suppressed. You can also specify ranges like so:

:40, 74!tidy -i -xml -q

This indents content between lines 40 and 74 (both lines inclusive). You can also do:

:., .+50!tidy -i -xml -q

This indents the current line and the next 50 lines. You can also do the same for HTML:

:%!tidy -i -xml -q

You can of course, supply additional parameters to tidy to customize the indenting.

:%!tidy -i -q
Nov 052009
 

I’ve been using WordPress for about two months now and I really like it. It takes away a lot of the pain from blogging. Recently I was writing a blog post and I was trying to get two images displayed side-by-side. This proved to be more difficult than I thought. There’s no immediately obvious way in WordPress to display images side-by-side. I tried to use tables, but that didn’t work out. I also tried to use the gallery, but that displays all the images, and I just wanted to display two. I was able to get it working finally.
Continue reading »

Jul 132007
 

You have probably seen websites that have images with drop-shadows. It gives the image a three-dimensional floating effect. Usually the images are given drop-shadows with an image editing software like Photoshop. In IE, a drop-shadow is easy to achieve using the DropShadow filter. Unfortunately, this method is not standards compliant and only works on Internet Explorer 5.5 or later. For all the gripes I have against Internet Explorer, I actually like the filters on Internet Explorer and I wish that the W3C would figure out a standards-compliant way to implement filters in their CSS design.

Currently, the only way to implement drop-shadows without resorting to IE’s DropShadow filter is to have an image that was previously edited through an image-editing software, dynamically generate the drop-shadow for the image through a dynamic graphics generation tool like GD or ImageMagick, or (complicated} CSS. I have run across a number of CSS-based drop-shadow solutions on the web. I either found them to be too complicated or unsatisfactory. My major problem was that I couldn’t easily accommodate them into my site design. One major problem I had was that many of the solutions employ floated images. This was an issue for me, because I like to center my images and this is impossible to do with floated elements. In addition, I have a major case of Re-inventing The Wheel So I Can Say It’s Mine! syndrome. Anyway, I decide to muck around and come up with my own solution. I have come up with one that doesn’t look that complicated and should work… in theory. But I ran into some issues when I tried to apply it. As a result the final solution is… well, clunky. But it works for me!

My solution involves the use of two divs. The first (parent) div contains the shadow image (which I shamelessly stole from here). The child div contains the actual image for which we want to create a drop-shadow. Essentially, the layout looks like this:

Structure

Pretty simple. In HTML, the structure looks like this:

<div style = "position:relative;">

 <img id = "sh_image" src = "http://vivin.net/images/shadow.png" />

 <div style = "position:absolute; top:-Xpx; left:-Ypx;">
  <img id = "img_image" src = "http://path.to.image/image.png" />
 </div>

</div>

You might be wondering what the Xpx and Ypx things are. Well, this is where some of the clunky parts come in. One problem I faced was that I couldn’t simply offset it by a constant amount, like 5px, for example. For some reason, the amount needs to be changed based on the dimensions of the image. I am not sure why this happens. Theoretically, the dimensions shouldn’t matter. Well, that’s one of the clunky issues. The other one has to do with Javascript. If you implement what I have so far, you’ll notice that the parent div would extend to accommodate the entire shadow image. This is obviously not what we want. My solution for this problem was to use Javascript to scale the shadow image to the size of the child image:

function dropShadow(img_name, shadowWidthExtend, shadowHeightExtend)
{
         var shadow = document.getElementById("sh_" + img_name);
         var img = document.getElementById("img_" + img_name);

         shadow.width = img.width + shadowWidthExtend;
         shadow.height = img.height + shadowHeightExtend;
}

What’s shadowWidthExtend and shadowHeightExtend you ask? Well, that’s another clunky part. So even after I set my offsets (through trial and error) as per the image dimensions, I still found that my drop-shadows didn’t look perfect. In order to make them look good, I had to “extend” the shadow image’s height and width. Yeah, not that ideal. But like I said, it works. I am not sure why these issues exist. I think it might have to do with the scaling of the shadowy parts of the shadow image (where it actually fades).

Now we can put it all together:

In your HTML file:

<div class = "shadow">

 <img id = "sh_image" src = "http://vivin.net/images/shadow.png" />

 <div class = "image">
  <img id = "img_image" src = "http://path.to.image/image.png" />
 </div>

</div>

<script language = "Javascript">

 dropShadow("image", A, B);

</script>

In your CSS file:

div.shadow
{
    position:relative;
}


div.image
{
    position:absolute;
    top:-Xpx;   /* determined based on image dimensions */
    left:-Ypx;  /* determined based on image dimensions */
}

In your Javascript file:

function dropShadow(img_name, shadowWidthExtend, shadowHeightExtend)
{
         var shadow = document.getElementById("sh_" + img_name);
         var img = document.getElementById("img_" + img_name);

         shadow.width = img.width + shadowWidthExtend;
         shadow.height = img.height + shadowHeightExtend;
}

As you can see, far from ideal. If I was only able to figure out how to make the offsets constant then this would be a pretty decent solution. If anybody knows why this is happening, please let me know. I am decently proficient in CSS and I am not a guru by any means. But I love to learn!

Oh, and as far as centering the drop-shadowed image, that’s easy to do by wrapping the whole thing in a center-aligned table with only one row and one cell.

Jul 012005
 

I finally figured out an alternative to using innerHTML for an XHTML document in Firefox. Earlier I talked about trying to use innerHTML on my website, and how I ran into problems. Basically, the property is not supported for XHTML documents in Firefox. This makes sense if you think about it, because HTML isn’t the same as XHTML. Since HTML isn’t as strict as XHTML, there exists the possiblity of inserting badly formed code into the document, and result wouldn’t be valid. From what I understand, this “problem” will be fixed in the 1.1 release of Firefox. Until then, I have an alternative. It may seem a little convoluted, but it really isn’t all that bad.

My approach revolves around using the DOM Core Methods. There is also another way, and that uses XSLT. I haven’t really looked into it, but I plan to, very soon. It could be faster.

Anyway, I realized that there was no way I could actually plug the XHTML code in directly into the document. I would have to parse it and create objects for each of the elements. But how do we parse the code? There really is no point writing our own parser, since it will be slow. Luckily, you can use the DOMParser object. This parser will let you parse an XML document. Since an XHTML document is essentially XML, you can use the DOMParser object to parse your code. The DOMParser object has three methods – parseFromBuffer, parseFromStream, and parseFromString. The one I used, is the last one. parseFromStream works like XMLHttpRequest, and allows you to read XML from a URI. I could have used that also, but parseFromString worked better for me.

The first thing you want to do, is create a DOMParser object. After that, you use parseFromString to parse your XML. parseFromString returns a Document object, which as you will see, can help us out a lot. So the code for parsing the XHTML looks like this:

var parser = new DOMParser();
var XMLdoc = parser.parseFromString("<root>" + myXHTML + "</root>");

It is not necessary to enclose your XHTML snippet with a root tag, but it will take care of the situation where your snippet doesn’t have a root element (so it would seem like it has more than one root element). In my case, I am inserting a snippet of XHTML code, and there is no root element, which is why I am enclosing the code with those tags.

I thought that once I had the Document object, I could simply figure out what the children of root are, and simply add them to the DOM by using appendChild. But that didn’t work out. This is due to the fact that XMLdoc is an XML Document, and not an HTML Document. Plugging it into the DOM directly won’t really help. What we have to do is figure out a way to transform the XML Document into an HTML Document. The sure-fire way to do that is to use XSLT. I poked around some code and realized that there was much I had to learn about XSLT before I could try to use it. My only other option was to do it through Javascript. This, as it turned out, wasn’t so bad. The Document object is essentially a tree, and all you’d have to do is “walk” the tree. While walking the tree, you can also create an object tree that you can later append to the main DOM.

I wrote a recursive function called walkTree that does exactly this. On a side-note, I am aware of the existence of the TreeWalker object, but I was too impatient to figure out how exactly it worked. It may actually prove to be faster, but who knows – maybe I will give it a try someday. Anyway, all those Data Structures and Algorithms classes that I had to take in College came to good use. My basic algorithm is this – you walk the tree, and every time you encounter a node, you create the appropriate XHTML element using createElementNS. First let’s look at the code to traverse the tree. Here is the basic skeleton that I use:

function walkTree(node)
{
         if(node.hasChildNodes())
         {
            node = node.firstChild;

            do
            {
                  alert("The node is " + node.nodeName +
                        " and its value is " + node.nodeValue
                       );

                  walkTree(node);
                  node = node.nextSibling;
            }
            while(node);
         }
}

Now we have to figure out how to use this skeleton to create elements and append them to the DOM. Like I mentioned before, you can create elements in XHTML using the createElementNS object. So you could do:

var element = createElementNS("http://www.w3.org/1999/xhtml", tagName);

The URI in createElementNS basically identifies the namespace we want to use. In this case, we want to use the XHTML namespace defined by the W3C. Now that we have created the element, we want to set its attributes. However, we don’t really know what the attributes are at runtime. But we can still access them using the attributes property of a node. The attributes property of a node is an array that contains all the attributes and their values. Now we have to figure out how to copy the attributes over to the element. There really is no easy way to do this. The only way I could figure out how to do this, was to construct Javascript code and use the eval() function. The reason for this is that every location in the attributes array is of type Node. The nodeName and nodeValue properties give us the attribute name and the attribute value respectively. So the code to set attributes would look like:

for(var i = 0; i < node.attributes.length; i++)
{
    var currAttribute = node.attributes[i];

    if(currAttribute.nodeName == "style")
    {
       applyStyle(element, currAttribute.nodeValue);
    }

    else if(currAttribute.nodeName == "class")
    {
       element.className = currAttribute.nodeValue;
    }

    else
    {
       eval("element." +
            node.attributes[j].nodeName +
            " = \"" +
            node.attributes[j].nodeValue +
            "\""
           );
    }
}

Pretty straightforward, but why do we have the if statements for “style” and “class”? Well, I’m sure you can see why you need the if statement for “class”. The attribute name in Javascript is different from the attribute name used in the XHTML code. But what’s that applyStyle function? Well, that function translates the CSS style into the Javascript format. So for example, if we had a style background-color:#ffffff;, the Javascript equivalent is obj.style.backgroundColor = “#ffffff”;. I wrote a simple function that performs this translation:

function applyStyle(obj, style)
{
         // Remove all whitespaces, and remove terminating ; if any
         style = new String(style).replace(/\s/g, "").replace(/;&#36;/, "");

         // Split into an array of attribute:value pairs
         var attributes = style.split(";");

         for(var i = 0; i < attributes.length; i++)
         {
             // Split the pair into the attribute and the value
             // Then translate the CSS style attribute into Javascript

             var attrvalue_pair = attributes[i].split(":");
             var attr = attrvalue_pair[0].replace(/-[a-z]/g, function($1)
                                                             {
                                                                      return new String($1).toUpperCase().replace(/-/g, "");
                                                             }
                                                 );

            // eval the constructed Javascript code

            eval("obj.style." + attr + " = \"" + attrvalue_pair[1] + "\"");
         }
}

Now we can put it all together:

function insertXHTML(myXHTML, myObject)
{
         var parser = new DOMParser();
         var XMLdoc = parser.parseFromString("<root>;" + myXHTML + "</root>", "text/xml");

         if(XMLdoc.documentElement.nodeName == "parserror")
         {
            alert("Your XML document has errors");
         }

         else
         {
            walkTree(XMLdoc.childNodes[0], myObject);
         }
}

function walkTree(node, parent)
{
         // Failing case for recursion. We don't want to continue 
         // if the node has no children.

         if(node.hasChildNodes())
         {
            // Set the node pointer to the first child of the current node
            // and start looping through all the children

            node = node.firstChild;

            do
            {
                  // We don't want any whitespace (line breaks, carriage returns, tabs or spaces)

                  if(!/^[\t\r\n ]+$/.test(node.data))
                  {
                     var element;

                     // Each node has a nodeType. The nodeType for a TextNode is 3. We want to handle
                     // Text Nodes separately from nodes that are tags

                     if(node.nodeType != 3)
                     {
                        // Create a new element using createElementNS as this is an XHTML file

                        element = document.createElementNS("http://www.w3.org/1999/xhtml", node.nodeName);

                        // Here, we manage the set the element's attributes by copying them from the node.
                        // Notice that we want to handle the style and class attributes separately. 
                        // The applyStyle function uses the CSS and creates the equivalent Javascript code
                        // for the style object of the current element. Look at the applyStyle function for
                        // more information

                        if(node.attributes)
                        {
                           for(var j = 0; j < node.attributes.length; j++)
                           {
                               var currAttribute = node.attributes[j];

                               if(currAttribute.nodeName == "style")
                               {
                                  applyStyle(element, currAttribute.nodeValue);
                               }

                               else if(currAttribute.nodeName == "class")
                               {
                                  element.className = currAttribute.nodeValue;
                               }

                               else
                               {
                                  // I guess this might be a hack, but I couldn't think of any other way to do it.
                                  // here we set any other attributes that the node may have. We construct Javascript
                                  // code to set the attributes and eval it. nodeName is the attribute name, and nodeValue
                                  // is the attribute value

                                  eval("element." + currAttribute.nodeName + " = \"" + currAttribute.nodeValue + "\"");
                               }
                           }
                        }
                     }

                     else
                     {
                        // If the element is a text node, we create a TextNode element

                        element = document.createTextNode(node.nodeValue);
                     }

                     // We make a recursive call to the function, to continue traversing the tree

                     walkTree(node, element);

                     // We append the element that we have created, to the parent element

                     parent.appendChild(element);
                  }

                  // Move onto the next sibling of the current node

                  node = node.nextSibling;
            }
            while(node);
         }
}

And there it is, folks. As easy as pie! I’ve found that it’s not that slow, especially if you’re parsing it just once. I’m using this same code for the Live! Preview, and it gets noticeably laggy when the code to be inserted is large. I guess if I was using XSLT, it wouldn’t be this slow. That’s going to be my next project! Feel free to use this code, and I hope it helps you out. Also, if you find ways to make it better/faster, or find bugs, or if you hate/love it, don’t hesitate to comment on it.

Update:

It was pointed out to me that there is a much simpler way of inserting XHTML into the document. You can use the importNode function, instead of walking the tree and manually copying the attributes. There doesn’t seem to be a speed advantage, but it is much simpler:

function insertXHTML(myXHTML, myObject)
{
         var parser = new DOMParser();
         var XMLdoc = parser.parseFromString("<div xmlns = "http://www.w3.org/1999/xhtml">" + comment + "</div>", "application/xhtml+xml");

         var root = XMLdoc.documentElement;

         for(i = 0; i < root.childNodes.length; i++)
         {
             myObject.appendChild(document.importNode(root.childNodes[i], true));
         }
}

I wish I had known about this function earlier – it would have saved me a whole lot of trouble!

References

All original content on these pages is fingerprinted and certified by Digiprove