This site works best in a real browser - Web Design

Yet another IE6 Hang bug

nospam@example.com (Graham Cox) — Thu, 03 Jan 2008 16:10:06 +0000

It appears that I have just discovered yet another IE6 hang bug- though I'm probably not the first person to discover it...

I'm not sure of the exact set of circumstances that cause it to happen yet, as I've not been able to reproduce it in a simplified form unfortunatly, but at least part of what is required is as follows:

An element - div in this case - with a margin-left of some non-zero value

Immediatly inside this element at least 4 input elements of type hidden, all together

Immediatly after these 4 input elements, an element that is defined to be float: left

Whether or not a doctype is present does not appear to affect the outcome, so it is not a simple reproduction of the bug mentioned at this blog post.

However, the following do stop the bug from manifesting:

Making it so that there are less than 4 input elements all together before the float

Making at least one of the input elements to not be of type hidden

Putting another element between the 4 inputs and the float

Making the element not float any more

Changing the margin-left to padding-left instead.

Wrapping the 4 input elements in a container element themselves - This is the one I used to solve the problem, the 4 input elements now exist inside a div that is set to display: none, and everything is happy.

Website Templates

nospam@example.com (Graham Cox) — Tue, 10 Oct 2006 13:53:08 +0100

Web design is something that people are either very good at or very bad at. I'm one of the people who are very bad at it, and as such use as much help as possible from elsewhere to do the design of any websites I'm working on.

One such place is Open Source Web Design - a repository of free to use web templates that you can just drop into place and use. This I have used a fair bit and the work is generally quite excellent.

Another place that I have just found is GetTemplate - another site with free web templates and also offering custom designs for a fee. I think this site is run by one of the publishers who has work on OSWD, and it's his work that he is offering.

getElementsBy...

nospam@example.com (Graham Cox) — Thu, 17 Aug 2006 16:15:13 +0100

This site is a very useful reference of all the different getElement(s)By... functions available in Javascript:

http://www.getelementsby.com/

Caret Position in a text control

nospam@example.com (Graham Cox) — Fri, 21 Jul 2006 10:23:52 +0100

Once again, IE proves that it can't do anything in a standard way.

Retrieving the caret position from a text control in Firefox and Opera is a very simple job - you simply use the selectionStart and selectionEnd parameters of the control itself.

Retrieving the caret position from a text control in IE is not quite so simple. There are no parameters that give you this information, so you have to work it out for yourself. As it happens, there are a number of ways of doing this available on the internet. Unfortunatly, none of them work properly.

The "official" method of doing it according to the Microsoft Web Team in the article Yule Not Want to Miss this One (See "O Cursor, Where Art Thou—finding yourself in a text box") is just horrible:

Save the input field value in a temporary variable.
Create a TextRange object on the document.selection (assuming the input field is focused).
Insert a “~” character into that TextRange object (range.text = "~"). Thus, the tilde would be inserted at the caret position (which we actually want to determine).
Search for the “~” character in the input field value and remember the index where it was found.
Restore the original input field value, saved at (1).
Return the index determined at (4) and claim it is the caret position.

The better method of doing it uses undocumented features of the Range object, and is described here by Mishoo.

This uses the Range.getBookmark() function which returns a value that can be used to get to the caret position. It worked fine. And in IE7 it stopped working. Microsoft changed the way this function worked (It's undocumented and so they can do that) and broke things that rely on it.

The third method of working out the caret position, which I have not seen mentioned anywhere on the internet and so might very well not work properly, is to use the Range.offsetLeft value. This gives you a value which represents the distance from the start of the text field that the caret is located at. In standard mode, this value is (position * 7) + 1.

This has been tested in IE5, IE5.5, IE6 and IE7 and returns the same values across all of them. It also returns the same value regardless of the zoom of the page and the location of the textbox on the screen.

As such, below is my cross-browser function to get the caret position from a given text field. It is known to work in Firefox, Opera, Netscape and (now) all versions of IE from 5.5 and up.
Continue reading "Caret Position in a text control"

IE7 Keyboard entry woes

nospam@example.com (Graham Cox) — Thu, 20 Jul 2006 17:27:02 +0100

It seems that IE7 have managed to make things even worse in the cross-browser keyboard handling arena.

From some simple testing, it would appear that either IE7 updates the caret position before the keypress event is triggered, even though the new character isn't yet entered (and might not be entered), or (and this is more likely) the caret positions are now 1-indexed and not 0-indexed like everybody else uses.

For the vast majority of cases out there, this is not going to cause any problems at all, but if you do care about where the character being entered is meant to go in a cross-browser manner then it would appear that you are in trouble. Essentially all it means is that in IE7 your caret positions are always going to be one greater than they are in the other browsers, but it's enough of a difference to cause problems...

Edit: (See above) It appears that the problem is really that Microsoft changed the undocumented feature that I was using to get the caret position. I was using this because there is no documented way to get at the position that is worth considering.

Cross-Browser event object

nospam@example.com (Graham Cox) — Mon, 17 Jul 2006 17:34:54 +0100

Different browsers handle events in different ways. Unfortunatly, this means that the same function will receive it's data in different ways on different browsers. From the major three:

Firefox. Event object is passed as parameter to the callback function
Opera. Event object is passed as a parameter to the callback function. Some members of event object have different names
Internet Explorer. No parameters passed to callback function. Event object exists as a global variable(!) instead. Some members of event object have different names.

Whilst Internet Explorer does use a global variable to store the event object, this is actually less of a problem since the javascript engine is single-threaded. It shouldn't be possible to have two event handlers for two different events using the same event object. This could change in IE7 or later however, at which time things will likely all stop working in a horrible manner.

This snippit can be called, being passed the event parameter from the event handler, and will return an event object in a standardised way. Note that this is nowhere near finished, and still has a lot of work needed to cover everything. In specific, keyboard handling is very rudimentary (see below) and mouse handling is non-existant.
Continue reading "Cross-Browser event object"

Keyboard handling and Opera

nospam@example.com (Graham Cox) — Mon, 17 Jul 2006 13:52:31 +0100

Keyboard handling in Javascript events gives a whole new meaning to "impossible". It turns out that there is simply no reliable way to do this and still have your code work across the board.

The main problem here turns out to be Opera. Opera, in their ultimate wisdom, have decided that in the keypress event they will give you the Keyboard code for function keys, and Character code for all other keys. The problem is that they give you this code in the same variable in the event object.

The problem comes from the fact that the keyboard code and the character code can, and often do, overlap each other. For example, the character code for the period character is 46. It just so happens that the keyboard code for the delete key is also 46. Having compared the event object that is passed into the keypress event when the period and the delete key are pressed, the event objects are identical. There is not a single way to tell the difference between those two keys in that event!

As it happens, the reason I was trying to do this was to have a text field that only allows certain keys to be pressed. Period wasn't one of the keys, but I did want all the function keys to work (arrows, delete, home, end, etc). Another "feature" of Opera is that these keys can not be cancelled. As such, if I think it might be a period I can try and cancel it, and if it's a period it's cancelled and if it's a delete then it's not.

Cross-Browser getElement()

nospam@example.com (Graham Cox) — Mon, 17 Jul 2006 13:42:55 +0100

This code is a simple Javascript function that works in most modern browsers to return a document element given the name of the element. It requires that both the name and id attribute of the control be set to the same value, and this value is what is used to look up the element.
Continue reading "Cross-Browser getElement()"

What "Cross-Browser" really means

nospam@example.com (Graham Cox) — Mon, 17 Jul 2006 13:39:14 +0100

One of the good things about Javascript is that it runs on any web browser that has support for it. This means that you can write your code and know that anyone with a recent enough browser can run it and benefit from it.

One of the bad things about Javascript is that it runs on any web browser, and that the people who write web browsers rarely do things the same as each other. This means that your code that works perfectly on Firefox will likely totally fail to run at all on Internet Explorer, or Opera, or whichever browser you want to use.

Because of this, it becomes very difficult to write powerful Javascript applications that are going to work for even the majority of users, and (almost) impossible to write them so that they will work for all users.