/*
 * {{{ header & license
 * Copyright (c) 2007 Vianney le Clément
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 * }}}
 */
package org.xhtmlrenderer.swt;

import java.awt.Dimension;
import java.awt.Shape;
import java.awt.geom.Area;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.StringReader;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.*;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xhtmlrenderer.css.style.CalculatedStyle;
import org.xhtmlrenderer.css.style.derived.RectPropertySet;
import org.xhtmlrenderer.event.DocumentListener;
import org.xhtmlrenderer.extend.*;
import org.xhtmlrenderer.layout.BoxBuilder;
import org.xhtmlrenderer.layout.Layer;
import org.xhtmlrenderer.layout.LayoutContext;
import org.xhtmlrenderer.layout.SharedContext;
import org.xhtmlrenderer.render.BlockBox;
import org.xhtmlrenderer.render.Box;
import org.xhtmlrenderer.render.PageBox;
import org.xhtmlrenderer.render.RenderingContext;
import org.xhtmlrenderer.render.ViewportBox;
import org.xhtmlrenderer.resource.XMLResource;
import org.xhtmlrenderer.simple.NoNamespaceHandler;
import org.xhtmlrenderer.util.Configuration;
import org.xhtmlrenderer.util.Uu;
import org.xhtmlrenderer.util.XRLog;
import org.xml.sax.InputSource;

/**
 * Renders XML+CSS using SWT in a widget (a Composite). Scrollbars are handled
 * automatically.
 * 
 * @author Vianney le Clément
 */
public class BasicRenderer extends Canvas implements PaintListener, UserInterface, FSCanvas {
    private static final int PAGE_PAINTING_CLEARANCE = 10;

    private SharedContext _sharedContext;

    // TODO layout_context should not be stored!
    private LayoutContext _layout_context;

    private Image _layout_image = null; // Image and GC used in layout_context

    private GC _layout_gc = null;

    private float _fontScalingFactor = 1.2F;

    private float _minFontScale = 0.50F;

    private float _maxFontScale = 3.0F;

    private Document _doc = null;

    private BlockBox _rootBox = null;

    private Set _documentListeners = new HashSet();

    private boolean _needRelayout = false;

    private boolean _hasFixedContent = false;

    private boolean _noResize = false; // temp. deactivate resize code

    private Point _origin = new Point(0, 0);

    private Point _drawnSize = new Point(0, 0);

    private Image _offscreen = null;

    private SpecialRedraw _specialRedraw = null;

    private static int checkStyle(int style) {
        final int mask = SWT.BORDER;
        return (style & mask) | SWT.NO_REDRAW_RESIZE | SWT.NO_BACKGROUND | SWT.V_SCROLL
                | SWT.H_SCROLL | SWT.NO_RADIO_GROUP;
    }

    public BasicRenderer(Composite parent, int style) {
        this(parent, style, new NaiveUserAgent(parent.getDisplay()));
    }

    /**
     * Construct the BasicRenderer
     * 
     * @param parent
     * @param uac
     */
    public BasicRenderer(Composite parent, int style, UserAgentCallback uac) {
        super(parent, checkStyle(style));
        super.setLayout(null);
        setBackground(getDisplay().getSystemColor(SWT.COLOR_WHITE));
        setBackgroundMode(SWT.INHERIT_FORCE);

        _sharedContext = new SharedContext(uac, new SWTFontResolver(parent.getDisplay()),
                new SWTReplacedElementFactory(), new SWTTextRenderer(), getDisplay().getDPI().y);
        _sharedContext.setCanvas(this);

        getHorizontalBar().addListener(SWT.Selection, new Listener() {
            public void handleEvent(Event event) {
                ScrollBar bar = (ScrollBar) event.widget;
                int hSelection = bar.getSelection();
                scrollTo(new Point(hSelection, _origin.y));
            }
        });
        getVerticalBar().addListener(SWT.Selection, new Listener() {
            public void handleEvent(Event event) {
                ScrollBar bar = (ScrollBar) event.widget;
                int vSelection = bar.getSelection();
                scrollTo(new Point(_origin.x, vSelection));
            }
        });

        addPaintListener(this);
        addDisposeListener(new DisposeListener() {
            public void widgetDisposed(DisposeEvent e) {
                // dispose used fonts
                _sharedContext.flushFonts();
                // clean ReplacedElementFactory
                ReplacedElementFactory ref = _sharedContext.getReplacedElementFactory();
                if (ref instanceof SWTReplacedElementFactory) {
                    ((SWTReplacedElementFactory) ref).clean();
                }
                // dispose images when using NaiveUserAgent
                UserAgentCallback uac = _sharedContext.getUac();
                if (uac instanceof NaiveUserAgent) {
                    ((NaiveUserAgent) uac).disposeCache();
                }
                // dispose offscreen image
                if (_offscreen != null) {
                    _offscreen.dispose();
                }
                // dispose temp Image/GC
                if (_layout_image != null) {
                    _layout_gc.dispose();
                    _layout_image.dispose();
                }
            }
        });
        addListener(SWT.Resize, new Listener() {
            private Point _previousSize = null;

            public void handleEvent(Event event) {
                Point size = getScreenSize();
                if (getRootLayer() != null && !_noResize) {
                    if (!isPrint() && (_previousSize == null || size.x != _previousSize.x)) {
                        // Ask for relayout if the width has changed
                        relayout();
                    } else {
                        // Else, don't relayout, but update scrollbars
                        if (updateScrollBars()) {
                            relayout();
                        } else if (_offscreen != null) {
                            redrawSpecial(new RedrawNewSize(_previousSize));
                        }
                    }
                }
                _previousSize = size;
            }
        });
        addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                Point pt = new Point(_origin.x, _origin.y);
                switch (e.keyCode) {
                    case SWT.ARROW_UP:
                        pt.y -= getVerticalBar().getIncrement();
                        break;
                    case SWT.ARROW_DOWN:
                        pt.y += getVerticalBar().getIncrement();
                        break;
                    case SWT.ARROW_LEFT:
                        pt.x -= getHorizontalBar().getIncrement();
                        break;
                    case SWT.ARROW_RIGHT:
                        pt.x += getHorizontalBar().getIncrement();
                        break;
                    case SWT.PAGE_UP:
                        pt.y -= getVerticalBar().getPageIncrement();
                        break;
                    case SWT.PAGE_DOWN:
                        pt.y += getVerticalBar().getPageIncrement();
                        break;
                    case SWT.HOME:
                        pt.x = 0;
                        pt.y = 0;
                        break;
                    case SWT.END:
                        pt.x = 0;
                        pt.y = _drawnSize.y; // will be fixed by setOrigin
                        break;
                }
                setOrigin(pt);
            }
        });

        updateScrollBars();
    }

    public void addDocumentListener(DocumentListener listener) {
        _documentListeners.add(listener);
    }

    public void removeDocumentListener(DocumentListener listener) {
        _documentListeners.remove(listener);
    }

    protected void fireDocumentLoaded() {
        Iterator it = _documentListeners.iterator();
        while (it.hasNext()) {
            ((DocumentListener) it.next()).documentLoaded();
        }
    }

    protected void fireOnLayoutException(Throwable t) {
        Iterator it = _documentListeners.iterator();
        while (it.hasNext()) {
            ((DocumentListener) it.next()).onLayoutException(t);
        }
    }

    protected void fireOnRenderException(Throwable t) {
        Iterator it = _documentListeners.iterator();
        while (it.hasNext()) {
            ((DocumentListener) it.next()).onRenderException(t);
        }
    }

    /**
     * A Renderer has no layout!
     */
    public void setLayout(Layout layout) {
    }

    /**
     * Do a full relayout and redraw
     */
    public void relayout() {
        _needRelayout = true;
        redraw();
    }

    /**
     * Invalidate the whole view. Redraw everything.
     */
    public void invalidate() {
        if (_offscreen != null) {
            _offscreen.dispose();
            _offscreen = null;
        }
        redraw();
    }

    private void redrawSpecial(SpecialRedraw type) {
        if (_hasFixedContent && !type.isForFixedContent()) {
            invalidate();
        } else if (_specialRedraw == null) {
            _specialRedraw = type;
            _specialRedraw.redraw();
        } else if (_specialRedraw.getClass().equals(type.getClass())
                && _specialRedraw.ignoreFurther()) {
            _specialRedraw.redraw();
        } else {
            invalidate();
        }
    }

    /**
     * Redraw only rect.
     * 
     * @param rect
     *            the rectangle
     */
    public void invalidate(Rectangle rect) {
        Rectangle r = getClientArea();
        r.intersect(rect);
        redrawSpecial(new RedrawTarget(r));
    }

    /**
     * @return a new {@link LayoutContext}
     */
    protected LayoutContext newLayoutcontext() {
        LayoutContext result = _sharedContext.newLayoutContextInstance();

        if (_layout_gc == null) {
            _layout_image = new Image(getDisplay(), 1, 1);
            _layout_gc = new GC(_layout_image);
        }

        result.setFontContext(new SWTFontContext(_layout_gc));
        _sharedContext.getTextRenderer().setup(result.getFontContext());

        return result;
    }

    /**
     * @param gc
     * @return a new {@link RenderingContext}
     */
    protected RenderingContext newRenderingContext(GC gc) {
        RenderingContext result = _sharedContext.newRenderingContextInstance();

        result.setFontContext(new SWTFontContext(gc));
        result.setOutputDevice(new SWTOutputDevice(gc));

        _sharedContext.getTextRenderer().setup(result.getFontContext());

        return result;
    }

    protected java.awt.Rectangle getInitialExtents(LayoutContext c) {
        if (!c.isPrint()) {
            Point size = getScreenSize();
            if (size.x == 0 && size.y == 0) {
                size.x = 1;
                size.y = 1;
            }
            return new java.awt.Rectangle(size.x, size.y);
        } else {
            PageBox first = Layer.createPageBox(c, "first");
            return new java.awt.Rectangle(0, 0, first.getContentWidth(c), first.getContentHeight(c));
        }
    }

    /**
     * @return the size of the drawable screen
     */
    public Point getScreenSize() {
        org.eclipse.swt.graphics.Rectangle rect = getClientArea();
        return new Point(rect.width, rect.height);
    }

    public Point computeSize(int wHint, int hHint, boolean changed) {
        return _drawnSize;
    }

    public java.awt.Rectangle getFixedRectangle() {
        Point size = getScreenSize();
        return new java.awt.Rectangle(0, 0, size.x, size.y);
    }

    public int getX() {
        return -_origin.x;
    }

    public int getY() {
        return -_origin.y;
    }

    /**
     * Check (and correct) the point to be within origin bounds.
     */
    private Point checkOrigin(Point pt) {
        Point size = getScreenSize();
        Point p = new Point(pt.x, pt.y);

        if (p.x > _drawnSize.x - size.x) {
            p.x = _drawnSize.x - size.x;
        }
        if (p.x < 0) {
            p.x = 0;
        }

        if (p.y > _drawnSize.y - size.y) {
            p.y = _drawnSize.y - size.y;
        }
        if (p.y < 0) {
            p.y = 0;
        }

        return p;
    }

    /**
     * @return the origin of the view
     */
    public Point getOrigin() {
        return _origin;
    }

    /**
     * Set the origin of the view. NOTE: this won't be done immediately.
     * 
     * @param pt
     */
    public void setOrigin(Point pt) {
        Point p = checkOrigin(pt);
        if (p.equals(_origin))
            return;
        getHorizontalBar().setSelection(p.x);
        getVerticalBar().setSelection(p.y);
        scrollTo(p);
    }

    protected void scrollTo(Point pt) {
        if (_origin.equals(pt)) {
            return;
        }

        if (_offscreen != null) {
            redrawSpecial(new RedrawNewOrigin(_origin));
        }

        Control[] children = getChildren();
        for (int i = 0; i < children.length; i++) {
            Point loc = children[i].getLocation();
            loc.x += _origin.x - pt.x;
            loc.y += _origin.y - pt.y;
            children[i].setLocation(loc);
        }

        _origin = pt;
        redraw();
    }

    /**
     * Update the scrollbars
     * 
     * @return true if we need to relayout the whole thing
     */
    protected boolean updateScrollBars() {
        Point size = getScreenSize();
        ScrollBar hBar = getHorizontalBar(), vBar = getVerticalBar();
        boolean needRelayout = false;

        hBar.setMaximum(_drawnSize.x);
        hBar.setThumb(Math.min(_drawnSize.x, size.x));
        hBar.setIncrement(15); // TODO something meaningful ?
        hBar.setPageIncrement(size.x);
        boolean visible = !(_origin.x == 0 && _drawnSize.x <= size.x);
        hBar.setVisible(visible);

        size = getScreenSize();

        vBar.setMaximum(_drawnSize.y);
        vBar.setThumb(Math.min(_drawnSize.y, size.y));
        vBar.setIncrement(15); // TODO line height here
        vBar.setPageIncrement(size.y);
        visible = !(_origin.y == 0 && _drawnSize.y <= size.y);
        if (!isPrint() && vBar.isVisible() != visible) {
            needRelayout = true;
        }
        vBar.setVisible(visible);

        return needRelayout;
    }

    /**
     * Convert an SWT rectangle into an AWT rectangle.
     * 
     * @param rect
     * @return
     */
    private static java.awt.Rectangle convertRectangle(Rectangle rect) {
        return new java.awt.Rectangle(rect.x, rect.y, rect.width, rect.height);
    }

    public void paintControl(PaintEvent e) {
        if (_doc == null) {
            // just draw background
            e.gc.fillRectangle(getClientArea());
        }

        // if this is the first time painting this document, then calc layout
        Layer root = getRootLayer();
        if (root == null || _needRelayout) {
            doLayout();
            root = getRootLayer();
            if (_offscreen != null) {
                // invalidate offscreen image
                _offscreen.dispose();
                _offscreen = null;
            }
        }
        _needRelayout = false;
        if (root == null) {
            XRLog.render(Level.FINE, "skipping the actual painting");
        } else {
            Point size = getScreenSize();
            // make sure origin is within the bounds
            Point origin = checkOrigin(_origin);
            if (!origin.equals(_origin)) {
                // the origin has been corrected
                if (_offscreen != null) {
                    if (_hasFixedContent
                            || (_specialRedraw != null && !(_specialRedraw instanceof RedrawNewOrigin))) {
                        _offscreen.dispose();
                        _offscreen = null;
                    } else if (_specialRedraw == null) {
                        _specialRedraw = new RedrawNewOrigin(_origin);
                    }
                }
            }
            _origin = origin;
            // redraw offscreen if needed
            if (_offscreen == null) { // full redraw
                _offscreen = new Image(getDisplay(), size.x, size.y);
                GC gc = new GC(_offscreen);
                RenderingContext c = newRenderingContext(gc);
                c.getOutputDevice().setClip(new java.awt.Rectangle(0, 0, size.x, size.y));
                doRender(c);
                gc.dispose();
            } else if (_specialRedraw instanceof RedrawTarget) { // targetted
                Rectangle target = ((RedrawTarget) _specialRedraw)._target;
                GC gc = new GC(_offscreen);
                RenderingContext c = newRenderingContext(gc);
                c.getOutputDevice().setClip(convertRectangle(target));
                doRender(c);
                gc.dispose();
            } else if (_specialRedraw instanceof RedrawNewOrigin) { // scroll
                Point previousOrigin = ((RedrawNewOrigin) _specialRedraw)._previousOrigin;
                Image img = new Image(getDisplay(), size.x, size.y);
                GC gc = new GC(img);
                gc.drawImage(_offscreen, previousOrigin.x - _origin.x, previousOrigin.y
                                - _origin.y);
                Area a = new Area();
                if (_origin.x < previousOrigin.x) {
                    int width = Math.min(size.x, previousOrigin.x - _origin.x);
                    a.add(new Area(new java.awt.Rectangle(0, 0, width, size.y)));
                } else if (_origin.x > previousOrigin.x) {
                    int width = Math.min(size.x, _origin.x - previousOrigin.x);
                    a.add(new Area(new java.awt.Rectangle(size.x - width, 0, width, size.y)));
                }
                if (_origin.y < previousOrigin.y) {
                    int height = Math.min(size.y, previousOrigin.y - _origin.y);
                    a.add(new Area(new java.awt.Rectangle(0, 0, size.x, height)));
                } else if (_origin.y > previousOrigin.y) {
                    int height = Math.min(size.y, _origin.y - previousOrigin.y);
                    a.add(new Area(new java.awt.Rectangle(0, size.y - height, size.x, height)));
                }
                RenderingContext c = newRenderingContext(gc);
                c.getOutputDevice().setClip(a);
                doRender(c);
                gc.dispose();
                _offscreen.dispose();
                _offscreen = img;
            } else if (_specialRedraw instanceof RedrawNewSize) { // adjust
                // size
                Point previousSize = ((RedrawNewSize) _specialRedraw)._previousSize;
                Image img = new Image(getDisplay(), size.x, size.y);
                GC gc = new GC(img);
                gc.drawImage(_offscreen, 0, 0);
                if (size.x > previousSize.x || size.y > previousSize.y) {
                    Area a = new Area();
                    if (size.x > previousSize.x) {
                        a.add(new Area(new java.awt.Rectangle(previousSize.x, 0, size.x
                                - previousSize.x, size.y)));
                    }
                    if (size.y > previousSize.y) {
                        a.add(new Area(new java.awt.Rectangle(0, previousSize.y, size.x, size.y
                                - previousSize.y)));
                    }
                    RenderingContext c = newRenderingContext(gc);
                    c.getOutputDevice().setClip(a);
                    doRender(c);
                    gc.setClipping((Rectangle) null);
                }
                gc.dispose();
                _offscreen.dispose();
                _offscreen = img;
            }
            // draw on screen
            e.gc.drawImage(_offscreen, 0, 0);
        }
        _specialRedraw = null;
    }

    protected void doLayout() {
        if (_doc == null) {
            return;
        }

        _layout_context = newLayoutcontext();

        try {
            long start = System.currentTimeMillis();

            if (_rootBox != null && _needRelayout) {
                _rootBox.reset(_layout_context);
            } else {
                _rootBox = BoxBuilder.createRootBox(_layout_context, _doc);
            }

            _rootBox.setContainingBlock(new ViewportBox(getInitialExtents(_layout_context)));
            _rootBox.layout(_layout_context);

            long end = System.currentTimeMillis();
            XRLog.layout(Level.INFO, "Layout took " + (end - start) + "ms");
        } catch (Throwable e) {
            XRLog.exception(e.getMessage(), e);
            e.printStackTrace();
        }

        Layer rootLayer = _rootBox.getLayer();
        _hasFixedContent = rootLayer.containsFixedContent();

        XRLog.layout(Level.FINEST, "after layout: " + _rootBox);

        // update scrollbars
        Dimension intrinsic_size = rootLayer.getPaintingDimension(_layout_context);
        if (_layout_context.isPrint()) {
            rootLayer.trimEmptyPages(_layout_context, intrinsic_size.height);
            if (rootLayer.getLastPage() != null) {
                rootLayer.assignPagePaintingPositions(_layout_context, Layer.PAGED_MODE_SCREEN,
                        PAGE_PAINTING_CLEARANCE);
                _drawnSize = new Point(rootLayer.getMaxPageWidth(_layout_context,
                        PAGE_PAINTING_CLEARANCE), rootLayer.getLastPage().getPaintingBottom()
                        + PAGE_PAINTING_CLEARANCE);
            } else {
                _drawnSize = new Point(0, 0);
            }
        } else {
            _drawnSize = new Point(intrinsic_size.width, intrinsic_size.height);
        }

        _noResize = true;
        if (updateScrollBars()) {
            doLayout();
        }
        _noResize = false;

        // TODO call only once? in display.asyncExec?
        fireDocumentLoaded();
    }

    protected void doRender(RenderingContext c) {
        try {
            c.getOutputDevice().translate(-_origin.x, -_origin.y);
            long start = System.currentTimeMillis();
            if (c.isPrint()) {
                paintPagedView(c, _rootBox.getLayer());
            } else {
                _rootBox.getLayer().paint(c);
            }
            long after = System.currentTimeMillis();
            if (Configuration.isTrue("xr.incremental.repaint.print-timing", false)) {
                Uu.p("repaint took ms: " + (after - start));
            }
        } catch (Throwable e) {
            XRLog.exception(e.getMessage(), e);
        }
        ((SWTOutputDevice) c.getOutputDevice()).clean();
    }

    private void paintPagedView(RenderingContext c, Layer root) {
        if (root.getLastPage() == null) {
            return;
        }

        SWTOutputDevice out = (SWTOutputDevice) c.getOutputDevice();
        GC gc = out.getGC();
        Shape working = out.getClip();

        List pages = root.getPages();
        c.setPageCount(pages.size());
        for (int i = 0; i < pages.size(); i++) {
            PageBox page = (PageBox) pages.get(i);
            c.setPage(i, page);

            java.awt.Rectangle overall = page.getScreenPaintingBounds(c, PAGE_PAINTING_CLEARANCE);
            overall.x -= 1;
            overall.y -= 1;
            overall.width += 1;
            overall.height += 1;

            java.awt.Rectangle bounds = new java.awt.Rectangle(overall);
            bounds.width += 1;
            bounds.height += 1;
            if (working.intersects(bounds)) {
                page.paintBackground(c, PAGE_PAINTING_CLEARANCE, Layer.PAGED_MODE_SCREEN);
                page.paintMarginAreas(c, PAGE_PAINTING_CLEARANCE, Layer.PAGED_MODE_SCREEN);
                page.paintBorder(c, PAGE_PAINTING_CLEARANCE, Layer.PAGED_MODE_SCREEN);

                Color old = gc.getForeground();
                gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK));
                gc.drawRectangle(overall.x, overall.y, overall.width, overall.height);
                gc.setForeground(old);

                java.awt.Rectangle content = page.getPagedViewClippingBounds(c,
                        PAGE_PAINTING_CLEARANCE);
                out.clip(content);

                int left = PAGE_PAINTING_CLEARANCE
                        + page.getMarginBorderPadding(c, CalculatedStyle.LEFT);
                int top = page.getPaintingTop()
                        + page.getMarginBorderPadding(c, CalculatedStyle.TOP) - page.getTop();

                out.translate(left, top);
                root.paint(c);
                out.translate(-left, -top);

                out.setClip(working);
            }
        }

        out.setClip(working);
    }

    public Document getDocument() {
        return _doc;
    }

    /**
     * Reload the current document.
     */
    public void reload() {
        if (_doc == null) {
            return;
        }
        _rootBox = null;
        _active_element = null;
        _hovered_element = null;
        _focus_element = null;
        if (Configuration.isTrue("xr.cache.stylesheets", true)) {
            _sharedContext.getCss().flushStyleSheets();
        } else {
            _sharedContext.getCss().flushAllStyleSheets();
        }

        setCursor(null);
        _sharedContext.reset();
        if (_offscreen != null) {
            _offscreen.dispose();
            _offscreen = null;
        }
        _origin = new Point(0, 0);
        getHorizontalBar().setSelection(0);
        getVerticalBar().setSelection(0);
        redraw();
    }

    public void setDocument(Document doc, String url, NamespaceHandler nsh) {
        _rootBox = null;
        _doc = doc;

        _active_element = null;
        _hovered_element = null;
        _focus_element = null;

        // have to do this first
        if (Configuration.isTrue("xr.cache.stylesheets", true)) {
            _sharedContext.getCss().flushStyleSheets();
        } else {
            _sharedContext.getCss().flushAllStyleSheets();
        }

        setCursor(null);
        _sharedContext.reset();
        if (_offscreen != null) {
            _offscreen.dispose();
            _offscreen = null;
        }
        _origin = new Point(0, 0);
        getHorizontalBar().setSelection(0);
        getVerticalBar().setSelection(0);

        if (doc == null) {
            _drawnSize = new Point(1, 1);
            updateScrollBars();
        } else {
            _sharedContext.setBaseURL(url);
            _sharedContext.setNamespaceHandler(nsh);
            _sharedContext.getCss().setDocumentContext(_sharedContext,
                    _sharedContext.getNamespaceHandler(), doc, this);
        }

        redraw();
    }

    public void setDocument(InputStream stream, String url, NamespaceHandler nsh) {
        Document dom = XMLResource.load(stream).getDocument();

        setDocument(dom, url, nsh);
    }

    public void setDocumentFromString(String content, String url, NamespaceHandler nsh) {
        InputSource is = new InputSource(new BufferedReader(new StringReader(content)));
        Document dom = XMLResource.load(is).getDocument();

        setDocument(dom, url, nsh);
    }

    public void setDocument(Document doc, String url) {
        setDocument(doc, url, new NoNamespaceHandler());
    }

    public void setDocument(String url) {
        setDocument(loadDocument(url), url, new NoNamespaceHandler());
    }

    public void setDocument(String url, NamespaceHandler nsh) {
        setDocument(loadDocument(url), url, nsh);
    }

    public void setDocument(InputStream stream, String url) {
        setDocument(stream, url, new NoNamespaceHandler());
    }

    private boolean isAnchorInCurrentDocument(String str) {
        return str.charAt(0) == '#';
    }

    private String getAnchorId(String url) {
        return url.substring(1, url.length());
    }

    /**
     * Sets the new current document, where the new document is located
     * relative, e.g using a relative URL.
     * 
     * @param filename
     *            The new document to load
     */
    protected void setDocumentRelative(String filename) {
        String url = _sharedContext.getUac().resolveURI(filename);
        if (isAnchorInCurrentDocument(filename)) {
            String id = getAnchorId(filename);
            Box box = _sharedContext.getBoxById(id);
            if (box != null) {
                Point pt;
                if (box.getStyle().isInline()) {
                    pt = new Point(0 /* box.getAbsX() */, box.getAbsY());
                } else {
                    RectPropertySet margin = box.getMargin(_layout_context);
                    pt = new Point(0 /* box.getAbsX() + (int) margin.left() */, box.getAbsY()
                            + (int) margin.top());
                }
                setOrigin(pt);
                return;
            }
        }
        Document dom = loadDocument(url);
        setDocument(dom, url);
    }

    protected Document loadDocument(final String uri) {
        XMLResource xmlResource = _sharedContext.getUac().getXMLResource(uri);
        if (xmlResource == null) {
            return null;
        }
        return xmlResource.getDocument();
    }

    public String getDocumentTitle() {
        if (_doc == null) {
            return null;
        }
        NamespaceHandler nsh = getSharedContext().getNamespaceHandler();
        if (nsh == null) {
            return null;
        }
        return nsh.getDocumentTitle(_doc);
    }

    public Box getRootBox() {
        return _rootBox;
    }

    public Layer getRootLayer() {
        return getRootBox() == null ? null : getRootBox().getLayer();
    }

    public SharedContext getSharedContext() {
        return _sharedContext;
    }

    public LayoutContext getLayoutContext() {
        return _layout_context;
    }

    public Box find(int x, int y) {
        Layer l = getRootLayer();
        if (l != null) {
            return l.find(_layout_context, x + _origin.x, y + _origin.y, false);
        }
        return null;
    }

    private Element _hovered_element = null;

    private Element _active_element = null;

    private Element _focus_element = null;

    public boolean isHover(org.w3c.dom.Element e) {
        if (e == _hovered_element) {
            return true;
        }
        return false;
    }

    public Element getHovered_element() {
        return _hovered_element;
    }

    public void setHovered_element(Element hovered_element) {
        _hovered_element = hovered_element;
    }

    public boolean isActive(org.w3c.dom.Element e) {
        if (e == _active_element) {
            return true;
        }
        return false;
    }

    public Element getActive_element() {
        return _active_element;
    }

    public void setActive_element(Element active_element) {
        _active_element = active_element;
    }

    public boolean isFocus(org.w3c.dom.Element e) {
        if (e == _focus_element) {
            return true;
        }
        return false;
    }

    public Element getFocus_element() {
        return _focus_element;
    }

    public void setFocus_element(Element focus_element) {
        _focus_element = focus_element;
    }

    public boolean isPrint() {
        return _sharedContext.isPrint();
    }

    public void setPrint(boolean print) {
        _sharedContext.setPrint(print);
        _sharedContext.setInteractive(!print);
        _sharedContext.getReplacedElementFactory().reset();
        reload();
    }

    /**
     * Sets the scaling factor used by {@link #incrementFontSize()} and
     * {@link #decrementFontSize()}--both scale the font up or down by this
     * scaling factor. The scaling roughly modifies the font size as a
     * multiplier or divisor. A scaling factor of 1.2 applied against a font
     * size of 10pt results in a scaled font of 12pt. The default scaling factor
     * is 1.2F.
     */
    public void setFontScalingFactor(float scaling) {
        _fontScalingFactor = scaling;
    }

    /**
     * Increments all rendered fonts on the current document by the current
     * scaling factor for the panel. Scaling applies culmulatively, which means
     * that multiple calls to this method scale fonts larger and larger by
     * applying the current scaling factor against itself. You can modify the
     * scaling factor by {@link #setFontScalingFactor(float)}, and reset to the
     * document's specified font size with {@link #resetFontSize()}.
     */
    public void incrementFontSize() {
        scaleFont(_fontScalingFactor);
    }

    /**
     * Resets all rendered fonts on the current document to the font size
     * specified in the document's styling instructions.
     */
    public void resetFontSize() {
        getSharedContext().getTextRenderer().setFontScale(1f);
        reload();
    }

    /**
     * Decrements all rendered fonts on the current document by the current
     * scaling factor for the panel. Scaling applies culmulatively, which means
     * that multiple calls to this method scale fonts smaller and smaller by
     * applying the current scaling factor against itself. You can modify the
     * scaling factor by {@link #setFontScalingFactor(float)}, and reset to the
     * document's specified font size with {@link #resetFontSize()}.
     */
    public void decrementFontSize() {
        scaleFont(1 / _fontScalingFactor);
    }

    /**
     * Applies a change in scale for fonts using the rendering context's text
     * renderer.
     */
    private void scaleFont(float scaleBy) {
        TextRenderer tr = getSharedContext().getTextRenderer();
        float fs = tr.getFontScale() * scaleBy;
        if (fs < _minFontScale || fs > _maxFontScale) {
            return;
        }
        tr.setFontScale(fs);
        reload();
    }

    /**
     * Returns the maximum font scaling that may be applied, e.g. 3 times
     * assigned font size.
     */
    public float getMaxFontScale() {
        return _maxFontScale;
    }

    /**
     * Returns the minimum font scaling that may be applied, e.g. 0.5 times
     * assigned font size.
     */
    public float getMinFontScale() {
        return _minFontScale;
    }

    /**
     * Sets the maximum font scaling that may be applied, e.g. 3 times assigned
     * font size. Calling incrementFontSize() after this scale has been reached
     * doesn't have an effect.
     */
    public void setMaxFontScale(float f) {
        _maxFontScale = f;
    }

    /**
     * Sets the minimum font scaling that may be applied, e.g. 3 times assigned
     * font size. Calling decrementFontSize() after this scale has been reached
     * doesn't have an effect.
     */
    public void setMinFontScale(float f) {
        _minFontScale = f;
    }

    /**
     * Information about a special way of redrawing.
     */
    private abstract class SpecialRedraw {
        /**
         * @return <code>true</code> if this special redraw method can also be
         *         applied when there is fixed content
         */
        abstract boolean isForFixedContent();

        /**
         * @return <code>true</code> if special redraws of the same kind (but
         *         with other parameters) should be ignored
         */
        abstract boolean ignoreFurther();

        /**
         * Trigger redraw
         */
        void redraw() {
            BasicRenderer.this.redraw();
        }
    }

    private class RedrawNewSize extends SpecialRedraw {
        final Point _previousSize;

        RedrawNewSize(Point previousSize) {
            _previousSize = previousSize;
        }

        boolean isForFixedContent() {
            return false;
        }

        boolean ignoreFurther() {
            return true;
        }
    }

    private class RedrawNewOrigin extends SpecialRedraw {
        final Point _previousOrigin;

        RedrawNewOrigin(Point previousOrigin) {
            _previousOrigin = previousOrigin;
        }

        boolean isForFixedContent() {
            return false;
        }

        boolean ignoreFurther() {
            return true;
        }
    }

    private class RedrawTarget extends SpecialRedraw {
        final Rectangle _target;

        RedrawTarget(Rectangle target) {
            _target = target;
        }

        boolean isForFixedContent() {
            return true;
        }

        boolean ignoreFurther() {
            return false;
        }

        void redraw() {
            BasicRenderer.this.redraw(_target.x, _target.y, _target.width, _target.height, true);
        }
    }

}