// JavaScript Document

// IE5.5+ PNG Alpha Fix v2.0 Alpha: Background Tiling Support
// (c) 2008 Angus Turnbull http://www.twinhelix.com

// This is licensed under the GNU LGPL, version 2.1 or later.
// For details, see: http://creativecommons.org/licenses/LGPL/2.1/

var IEPNGFix = window.IEPNGFix || {};

IEPNGFix.tileBG = function(elm, pngSrc, ready) {
        // Params: A reference to a DOM element, the PNG src file pathname, and a
        // hidden "ready-to-run" passed when called back after image preloading.

        var data = this.data[elm.uniqueID],
                elmW = Math.max(elm.clientWidth, elm.scrollWidth),
                elmH = Math.max(elm.clientHeight, elm.scrollHeight),
                bgX = elm.currentStyle.backgroundPositionX,
                bgY = elm.currentStyle.backgroundPositionY,
                bgR = elm.currentStyle.backgroundRepeat;

        // Cache of DIVs created per element, and image preloader/data.
        if (!data.tiles) {
                data.tiles = {
                        elm: elm,
                        src: '',
                        cache: [],
                        img: new Image(),
                        old: {}
                };
        }
        var tiles = data.tiles,
                pngW = tiles.img.width,
                pngH = tiles.img.height;

        if (pngSrc) {
                if (!ready && pngSrc != tiles.src) {
                        // New image? Preload it with a callback to detect dimensions.
                        tiles.img.onload = function() {
                                this.onload = null;
                                IEPNGFix.tileBG(elm, pngSrc, 1);
                        };
                        return tiles.img.src = pngSrc;
                }
        } else {
                // No image?
                if (tiles.src) ready = 1;
                pngW = pngH = 0;
        }
        tiles.src = pngSrc;

        if (!ready && elmW == tiles.old.w && elmH == tiles.old.h &&
                bgX == tiles.old.x && bgY == tiles.old.y && bgR == tiles.old.r) {
                return;
        }

        // Convert English and percentage positions to pixels.
        var pos = {
                        top: '0%',
                        left: '0%',
                        center: '50%',
                        bottom: '100%',
                        right: '100%'
                },
                x,
                y,
                pc;
        x = pos[bgX] || bgX;
        y = pos[bgY] || bgY;
        if (pc = x.match(/(\d+)%/)) {
                x = Math.round((elmW - pngW) * (parseInt(pc[1]) / 100));
        }
        if (pc = y.match(/(\d+)%/)) {
                y = Math.round((elmH - pngH) * (parseInt(pc[1]) / 100));
        }
        x = parseInt(x);
        y = parseInt(y);

        // Handle backgroundRepeat.
        var repeatX = { 'repeat': 1, 'repeat-x': 1 }[bgR],
                repeatY = { 'repeat': 1, 'repeat-y': 1 }[bgR];
        if (repeatX) {
                x %= pngW;
                if (x > 0) x -= pngW;
        }
        if (repeatY) {
                y %= pngH;
                if (y > 0) y -= pngH;
        }

        // Go!
        this.hook.enabled = 0;
        if (!({ relative: 1, absolute: 1 }[elm.currentStyle.position])) {
                elm.style.position = 'relative';
        }
        var count = 0,
                xPos,
                maxX = repeatX ? elmW : x + 0.1,
                yPos,
                maxY = repeatY ? elmH : y + 0.1,
                d,
                s,
                isNew;
        if (pngW && pngH) {
                for (xPos = x; xPos < maxX; xPos += pngW) {
                        for (yPos = y; yPos < maxY; yPos += pngH) {
                                isNew = 0;
                                if (!tiles.cache[count]) {
                                        tiles.cache[count] = document.createElement('div');
                                        isNew = 1;
                                }
                                var clipR = (xPos + pngW > elmW ? elmW - xPos : pngW),
                                        clipB = (yPos + pngH > elmH ? elmH - yPos : pngH);
                                d = tiles.cache[count];
                                s = d.style;
                                s.behavior = 'none';
                                s.left = xPos + 'px';
                                s.top = yPos + 'px';
                                s.width = clipR + 'px';
                                s.height = clipB + 'px';
                                s.clip = 'rect(' +
                                        (yPos < 0 ? 0 - yPos : 0) + 'px,' +
                                        clipR + 'px,' +
                                        clipB + 'px,' +
                                        (xPos < 0 ? 0 - xPos : 0) + 'px)';
                                s.display = 'block';
                                if (isNew) {
                                        s.position = 'absolute';
                                        s.zIndex = -999;
                                        if (elm.firstChild) {
                                                elm.insertBefore(d, elm.firstChild);
                                        } else {
                                                elm.appendChild(d);
                                        }
                                }
                                this.fix(d, pngSrc, 0);
                                count++;
                        }
                }
        }
        while (count < tiles.cache.length) {
                this.fix(tiles.cache[count], '', 0);
                tiles.cache[count++].style.display = 'none';
        }

        this.hook.enabled = 1;

        // Cache so updates are infrequent.
        tiles.old = {
                w: elmW,
                h: elmH,
                x: bgX,
                y: bgY,
                r: bgR
        };
};


IEPNGFix.update = function() {
        // Update all PNG backgrounds.
        for (var i in IEPNGFix.data) {
                var t = IEPNGFix.data[i].tiles;
                if (t && t.elm && t.src) {
                        IEPNGFix.tileBG(t.elm, t.src);
                }
        }
};
IEPNGFix.update.timer = 0;

if (window.attachEvent && !window.opera) {
        window.attachEvent('onresize', function() {
                clearTimeout(IEPNGFix.update.timer);
                IEPNGFix.update.timer = setTimeout(IEPNGFix.update, 100);
        });
}