--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/platform/graphics/GraphicsContext.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,450 @@
+/*
+ * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+#include "GraphicsContext.h"
+
+#include "BidiResolver.h"
+#include "Font.h"
+#include "TextStyle.h"
+
+using namespace std;
+
+namespace WebCore {
+
+class TextRunIterator {
+public:
+    TextRunIterator()
+        : m_textRun(0)
+        , m_offset(0)
+    {
+    }
+
+    TextRunIterator(const TextRun* textRun, unsigned offset)
+        : m_textRun(textRun)
+        , m_offset(offset)
+    {
+    }
+
+    TextRunIterator(const TextRunIterator& other)
+        : m_textRun(other.m_textRun)
+        , m_offset(other.m_offset)
+    {
+    }
+
+    unsigned offset() const { return m_offset; }
+    void increment(BidiResolver<TextRunIterator, BidiCharacterRun>&) { m_offset++; }
+    bool atEnd() const { return !m_textRun || m_offset >= m_textRun->length(); }
+    UChar current() const { return (*m_textRun)[m_offset]; }
+    WTF::Unicode::Direction direction() const { return atEnd() ? WTF::Unicode::OtherNeutral : WTF::Unicode::direction(current()); }
+
+    bool operator==(const TextRunIterator& other)
+    {
+        return m_offset == other.m_offset && m_textRun == other.m_textRun;
+    }
+
+    bool operator!=(const TextRunIterator& other) { return !operator==(other); }
+
+private:
+    const TextRun* m_textRun;
+    int m_offset;
+};
+
+struct GraphicsContextState {
+    GraphicsContextState() 
+    : strokeStyle(SolidStroke)
+    , strokeThickness(0)
+    , strokeColor(Color::black)
+    , fillColor(Color::black)
+    , textDrawingMode(cTextFill)
+    , paintingDisabled(false)
+    {}
+    
+    Font font;
+    StrokeStyle strokeStyle;
+    float strokeThickness;
+    Color strokeColor;
+    Color fillColor;
+    int textDrawingMode;
+    bool paintingDisabled;
+};
+        
+class GraphicsContextPrivate {
+public:
+    GraphicsContextPrivate();
+    
+    GraphicsContextState state;
+    Vector<GraphicsContextState> stack;
+    Vector<IntRect> m_focusRingRects;
+    int m_focusRingWidth;
+    int m_focusRingOffset;
+    bool m_updatingControlTints;
+};
+
+GraphicsContextPrivate::GraphicsContextPrivate()
+    : m_focusRingWidth(0)
+    , m_focusRingOffset(0)
+    , m_updatingControlTints(false)
+{
+}
+
+GraphicsContextPrivate* GraphicsContext::createGraphicsContextPrivate()
+{
+    return new GraphicsContextPrivate;
+}
+
+void GraphicsContext::destroyGraphicsContextPrivate(GraphicsContextPrivate* deleteMe)
+{
+    delete deleteMe;
+}
+
+void GraphicsContext::save()
+{
+    if (paintingDisabled())
+        return;
+
+    m_common->stack.append(m_common->state);
+    
+    savePlatformState();
+}
+
+void GraphicsContext::restore()
+{
+    if (paintingDisabled())
+        return;
+
+    if (m_common->stack.isEmpty()) {
+        LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
+        return;
+    }
+    m_common->state = m_common->stack.last();
+    m_common->stack.removeLast();
+    
+    restorePlatformState();
+}
+
+const Font& GraphicsContext::font() const
+{
+    return m_common->state.font;
+}
+
+void GraphicsContext::setFont(const Font& aFont)
+{
+    m_common->state.font = aFont;
+    setPlatformFont(aFont);
+}
+
+void GraphicsContext::setStrokeThickness(float thickness)
+{
+    m_common->state.strokeThickness = thickness;
+    setPlatformStrokeThickness(thickness);
+}
+
+void GraphicsContext::setStrokeStyle(const StrokeStyle& style)
+{
+    m_common->state.strokeStyle = style;
+    setPlatformStrokeStyle(style);
+}
+
+void GraphicsContext::setStrokeColor(const Color& color)
+{
+    m_common->state.strokeColor = color;
+    setPlatformStrokeColor(color);
+}
+
+float GraphicsContext::strokeThickness() const
+{
+    return m_common->state.strokeThickness;
+}
+
+StrokeStyle GraphicsContext::strokeStyle() const
+{
+    return m_common->state.strokeStyle;
+}
+
+Color GraphicsContext::strokeColor() const
+{
+    return m_common->state.strokeColor;
+}
+
+void GraphicsContext::setFillColor(const Color& color)
+{
+    m_common->state.fillColor = color;
+    setPlatformFillColor(color);
+}
+
+Color GraphicsContext::fillColor() const
+{
+    return m_common->state.fillColor;
+}
+
+bool GraphicsContext::updatingControlTints() const
+{
+    return m_common->m_updatingControlTints;
+}
+
+void GraphicsContext::setUpdatingControlTints(bool b)
+{
+    setPaintingDisabled(b);
+    m_common->m_updatingControlTints = b;
+}
+
+void GraphicsContext::setPaintingDisabled(bool f)
+{
+    m_common->state.paintingDisabled = f;
+}
+
+bool GraphicsContext::paintingDisabled() const
+{
+    return m_common->state.paintingDisabled;
+}
+
+void GraphicsContext::drawImage(Image* image, const IntPoint& p, CompositeOperator op)
+{        
+    drawImage(image, p, IntRect(0, 0, -1, -1), op);
+}
+
+void GraphicsContext::drawImage(Image* image, const IntRect& r, CompositeOperator op, bool useLowQualityScale)
+{
+    drawImage(image, r, IntRect(0, 0, -1, -1), op, useLowQualityScale);
+}
+
+void GraphicsContext::drawImage(Image* image, const IntPoint& dest, const IntRect& srcRect, CompositeOperator op)
+{
+    drawImage(image, IntRect(dest, srcRect.size()), srcRect, op);
+}
+
+void GraphicsContext::drawImage(Image* image, const IntRect& dest, const IntRect& srcRect, CompositeOperator op, bool useLowQualityScale)
+{
+    drawImage(image, FloatRect(dest), srcRect, op, useLowQualityScale);
+}
+
+void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, int from, int to)
+{
+    drawText(run, point, TextStyle(), from, to);
+}
+
+void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, const TextStyle& style, int from, int to)
+{
+    if (paintingDisabled())
+        return;
+    
+    font().drawText(this, run, style, point, from, to);
+}
+
+void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point, const TextStyle& style)
+{
+    if (paintingDisabled())
+        return;
+
+    BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
+    WTF::Unicode::Direction paragraphDirection = style.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
+
+    bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, new BidiContext(style.ltr() ? 0 : 1, paragraphDirection, style.directionalOverride())));
+
+    bidiResolver.createBidiRunsForLine(TextRunIterator(&run, 0), TextRunIterator(&run, run.length()));
+
+    if (!bidiResolver.runCount())
+        return;
+
+    FloatPoint currPoint = point;
+    BidiCharacterRun* bidiRun = bidiResolver.firstRun();
+    while (bidiRun) {
+        TextStyle subrunStyle(style);
+        subrunStyle.setRTL(bidiRun->level() % 2);
+        subrunStyle.setDirectionalOverride(bidiRun->dirOverride(false));
+
+        TextRun subrun(run.data(bidiRun->start()), bidiRun->stop() - bidiRun->start());
+
+        font().drawText(this, subrun, subrunStyle, currPoint);
+
+        bidiRun = bidiRun->next();
+        // FIXME: Have Font::drawText return the width of what it drew so that we don't have to re-measure here.
+        if (bidiRun)
+            currPoint.move(font().floatWidth(subrun, subrunStyle), 0.f);
+    }
+
+    bidiResolver.deleteRuns();
+}
+
+void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const TextStyle& style, const Color& backgroundColor, int from, int to)
+{
+    if (paintingDisabled())
+        return;
+
+    fillRect(font().selectionRectForText(run, style, point, h, from, to), backgroundColor);
+}
+
+void GraphicsContext::initFocusRing(int width, int offset)
+{
+    if (paintingDisabled())
+        return;
+    clearFocusRing();
+    
+    m_common->m_focusRingWidth = width;
+    m_common->m_focusRingOffset = offset;
+}
+
+void GraphicsContext::clearFocusRing()
+{
+    m_common->m_focusRingRects.clear();
+}
+
+IntRect GraphicsContext::focusRingBoundingRect()
+{
+    IntRect result = IntRect(0, 0, 0, 0);
+    
+    const Vector<IntRect>& rects = focusRingRects();
+    unsigned rectCount = rects.size();
+    for (unsigned i = 0; i < rectCount; i++)
+        result.unite(rects[i]);
+        
+    return result;
+}
+
+void GraphicsContext::addFocusRingRect(const IntRect& rect)
+{
+    if (paintingDisabled() || rect.isEmpty())
+        return;
+    m_common->m_focusRingRects.append(rect);
+}
+
+int GraphicsContext::focusRingWidth() const
+{
+    return m_common->m_focusRingWidth;
+}
+
+int GraphicsContext::focusRingOffset() const
+{
+    return m_common->m_focusRingOffset;
+}
+
+const Vector<IntRect>& GraphicsContext::focusRingRects() const
+{
+    return m_common->m_focusRingRects;
+}
+
+static const int cInterpolationCutoff = 800 * 800;
+
+void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, bool useLowQualityScale)
+{
+    if (paintingDisabled())
+        return;
+
+    float tsw = src.width();
+    float tsh = src.height();
+    float tw = dest.width();
+    float th = dest.height();
+        
+    if (tsw == -1)
+        tsw = image->width();
+    if (tsh == -1)
+        tsh = image->height();
+
+    if (tw == -1)
+        tw = image->width();
+    if (th == -1)
+        th = image->height();
+
+    bool shouldUseLowQualityInterpolation = useLowQualityScale && (tsw != tw || tsh != th) && tsw * tsh > cInterpolationCutoff;
+    if (shouldUseLowQualityInterpolation) {
+        save();
+        setUseLowQualityImageInterpolation(true);
+    }
+    image->draw(this, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), op);
+    if (shouldUseLowQualityInterpolation)
+        restore();
+}
+
+void GraphicsContext::drawTiledImage(Image* image, const IntRect& rect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op)
+{
+    if (paintingDisabled())
+        return;
+
+    image->drawTiled(this, rect, srcPoint, tileSize, op);
+}
+
+void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect, Image::TileRule hRule, Image::TileRule vRule, CompositeOperator op)
+{
+    if (paintingDisabled())
+        return;
+
+    if (hRule == Image::StretchTile && vRule == Image::StretchTile)
+        // Just do a scale.
+        return drawImage(image, dest, srcRect);
+
+    image->drawTiled(this, dest, srcRect, hRule, vRule, op);
+}
+
+void GraphicsContext::addRoundedRectClip(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
+    const IntSize& bottomLeft, const IntSize& bottomRight)
+{
+    if (paintingDisabled())
+        return;
+
+    clip(Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight));
+}
+
+void GraphicsContext::clipOutRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
+                                         const IntSize& bottomLeft, const IntSize& bottomRight)
+{
+    if (paintingDisabled())
+        return;
+
+    clipOut(Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight));
+}
+
+int GraphicsContext::textDrawingMode()
+{
+    return m_common->state.textDrawingMode;
+}
+
+void GraphicsContext::setTextDrawingMode(int mode)
+{
+    m_common->state.textDrawingMode = mode;
+    if (paintingDisabled())
+        return;
+    setPlatformTextDrawingMode(mode);
+}
+
+#if !PLATFORM(CG)
+// Implement this if you want to go ahead and push the drawing mode into your native context
+// immediately.
+void GraphicsContext::setPlatformTextDrawingMode(int mode)
+{
+}
+#endif
+
+#if !PLATFORM(QT) && !PLATFORM(CAIRO)
+void GraphicsContext::setPlatformStrokeStyle(const StrokeStyle&)
+{
+}
+
+void GraphicsContext::setPlatformFont(const Font&)
+{
+}
+#endif
+
+}