Rough Book

random musings of just another computer nerd

Tag: xhtml

innerHTML alternative for XHTML documents in Firefox

I finally figured out an alternative to using innerHTML for an XHTML document in Firefox. <a target = “_blank” href = http://vivin.net/2005/06/30/innerhtml-and-createcontextualfragment-problems-when-firefox-renders-xhtml/”>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

innerHTML and createContextualFragment problems when Firefox renders XHTML

If any of you use Firefox, then you’ll have noticed that the “Preview Comment” feature doesn’t work anymore. It stopped working after I converted this site over to XHTML. Initially it worked (even though it validated as XHTML 1.1) because I was setting the mime-type to text/html. To make it completely compliant, I set the mime-type (for browsers that accept it) to application/xhtml+xml. This made certain things break in Firefox. Namely, innerHTML. HTMLElement.innerHTML isn’t a W3C standard anyway, so it would make sense that it wouldn’t work. However, it was not so much an error as it is a bug in Mozilla (or in Gecko).

I looked around for some alternatives and chanced upon the createContextualFragment function. It is supposed to work, but I guess those examples were for Firefox when it didn’t support the innerHTML property in HTML. I tried something like this:

var range = div_preview.ownerDocument.createRange();
            
range.selectNodeContents(div_preview);
range.deleteContents();

var fragment = range.createContextualFragment(comment); //&#60;-- will crash here
div_preview.appendChild(fragment);

But that didn’t work either. I then found out that this is also a bug. I’ve got two pages demonstrating the bugs here and here.

I don’t have any other alternatives than to

  • Wait for Firefox 1.1
  • Parse the code I want to insert through an XML parser, and then create the objects through DOM Core methods

I figure I’ll try the option b for now, but I don’t know how the slow the parsing will be. I guess I won’t know until I try.

This site is XHTML 1.1 Valid

I finally got this site to validate! The folks over here were really helpful, and pointed out that I wasn’t assigning values to my objects’ style attributes properly. For example, I was doing:

obj.style.width = 200;

instead of:

obj.style.width = "200px";

The second way is the correct way because it is important to specify units for your attributes. In addition, Firefox won’t parse it because it’s very strict about XHTML and CSS. Furthermore, certain things weren’t where I expected them to be. I was used to writing:

obj.style.height = document.body.scrollHeight;

But that no longer worked (the value being returned was 0). The method that works now is:

obj.style.height = document.body.parentNode.scrollHeight + "px";

You have to add in that “px” because the scroll height doesn’t have any units. Once I made these changes, the site started working and validating perfectly. Thanks a bunch to all those who helped!

I guess I did most of this just to jump on the bandwagon and because it did have a “geek” factor. But eitherway, since my website adheres to the standards now, I can be reasonably sure that it looks like the way it should… except for IE though. IE lets you get away with almost anything, and that’s why 90% of the websites out there have such terrible code. IE is very forgiving and can recover from bad HTML, but that only encourages sloppy coding. But anway, now that my site validates, I can proudly display the W3C’s “Valid XHTML 1.1” icon!

Live! Preview and XHTML Compatibility

I’ve added a new feature called “Live Preview”. You can see your comment as it will appear, right as you type it. I randomly just came up with the idea yesterday – I figured I could use the same code I have in place for the preview, for the Live Preview as well. I just trap the onkeyup event for the textarea. It works pretty well. Of course, there is a lag, but it’s not too bad. Oh yeah, I also removed the numbers in the comment list and replaced them with little blurbs that I made. The blurbs won’t show correctly in IE, because IE is stupid and doesn’t handle PNG transparencies well.

Then there’s XHTML compatibility. I’ve been trying really hard to get this page to validate. I was finally able to get rid of all the errors. This page validates (if you set the DOCTYPE to XHTML 1.1 explicitly, but I’ll get to that later) without any errors, as does all the CSS. However, the problem comes when I add in the DOCTYPE. The page validates perfectly, but displays completely messed up in Firefox (IE can’t handle the mime type so I didn’t even bother checking it with IE). I tracked the problem down to the Javascript. Basically, I can’t set any DOM object attribute values from Javascript. It’s as if all attributes are read-only. It’s really quite bizarre. I’ve posted the problem on a message board, so we’ll see what happens. If any of you know why I could be facing this problem, please let me know.

Here’s what the DOCTYPE (and other information) looks like:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
 "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">

Also, I have a sandboxed version of the website here. You can see the problem directly there.

XHTML and Episode III

Getting this site to be XHTML compliant is a total bitch.

Anyway, today (well, tomorrow really) we are going to see Episode III. It’s the 12:01 showing. I remember when I went to see Episode II three years ago. It was really awesome, and I liked it. But I guess the feeling sorta died down and now that I think about it, some parts of it really sucked. Especially the parts with Anakin and Amidala. George Lucas is just a terrible director. I did like Yoda’s fight scene with Count Dooku though! Awesome, it was!

I have high hopes for Episode III. Reviewers are saying it’s pretty good, and that Lucas might have finally redeemed himself for the atrocities that were Episodes I and II. They are even saying that this one is like The Empire Strikes Back. I talked to Michael about it and he told me that he heard that certain reviewers were even placing it before Return of The Jedi as far as their favourite episodes go. That’s saying a lot.

I hope I’m not disappointed. It would really make my day if I they have a scene where they show Jar-Jar dying… horribly. Where he says something like “Ahhh!!! Meesa skinsa burningsa!!! AHHHH!!!”. That would SO make my day.

All original content on these pages is fingerprinted and certified by Digiprove
%d bloggers like this: