| /* |
| * Copyright 2010, The Android Open Source Project |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * 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 THE COPYRIGHT HOLDERS ``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 THE COPYRIGHT OWNER 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. |
| */ |
| |
| #ifndef TiledPage_h |
| #define TiledPage_h |
| |
| #if USE(ACCELERATED_COMPOSITING) |
| |
| #include "BaseTile.h" |
| #include "SkCanvas.h" |
| #include "SkRegion.h" |
| |
| #include "TilePainter.h" |
| |
| namespace WebCore { |
| |
| class GLWebViewState; |
| class IntRect; |
| |
| /** |
| * The TiledPage represents a map of BaseTiles covering the viewport. Each |
| * GLWebViewState contains two TiledPages, one to display the page at the |
| * current scale factor, and another in the background that we use to paint the |
| * page at a different scale factor. For instance, when we zoom using one |
| * TiledPage its tiles are scaled in hardware and therefore are subject to a |
| * loss of quality. To address this when the user finishes zooming we paint the |
| * background TilePage at the new scale factor. When the background TilePage is |
| * ready, we swap it with the currently displaying TiledPage. |
| */ |
| class TiledPage : public TilePainter { |
| public: |
| enum PrepareBounds { |
| ExpandedBounds = 0, |
| VisibleBounds = 1 |
| }; |
| |
| TiledPage(int id, GLWebViewState* state); |
| ~TiledPage(); |
| |
| // returns the other TiledPage who shares the same GLWebViewState |
| TiledPage* sibling(); |
| |
| // prepare the page for display on the screen |
| void prepare(bool goingDown, bool goingLeft, const SkIRect& tileBounds, PrepareBounds bounds); |
| |
| // update tiles with inval information, return true if visible ones are |
| // dirty (and thus repaint needed) |
| bool updateTileDirtiness(const SkIRect& tileBounds); |
| |
| // returns true if the page can't draw the entire region (may still be stale) |
| bool hasMissingContent(const SkIRect& tileBounds); |
| |
| bool isReady(const SkIRect& tileBounds); |
| |
| // swap 'buffers' by swapping each modified texture |
| bool swapBuffersIfReady(const SkIRect& tileBounds, float scale); |
| // save the transparency and bounds to be drawn in drawGL() |
| void prepareForDrawGL(float transparency, const SkIRect& tileBounds); |
| // draw the page on the screen |
| void drawGL(); |
| |
| // TilePainter implementation |
| // used by individual tiles to generate the bitmap for their tile |
| bool paint(BaseTile*, SkCanvas*, unsigned int*); |
| |
| // used by individual tiles to get the information about the current picture |
| GLWebViewState* glWebViewState() { return m_glWebViewState; } |
| |
| float scale() const { return m_scale; } |
| |
| //TODO: clear all textures if this is called with a new value |
| void setScale(float scale) { m_scale = scale; m_invScale = 1 / scale; } |
| |
| void invalidateRect(const IntRect& invalRect, const unsigned int pictureCount); |
| void discardTextures(); |
| void updateBaseTileSize(); |
| bool scrollingDown() { return m_scrollingDown; } |
| bool isPrefetchPage() { return m_isPrefetchPage; } |
| void setIsPrefetchPage(bool isPrefetch) { m_isPrefetchPage = isPrefetch; } |
| |
| private: |
| void prepareRow(bool goingLeft, int tilesInRow, int firstTileX, int y, const SkIRect& tileBounds); |
| |
| BaseTile* getBaseTile(int x, int y) const; |
| |
| // array of tiles used to compose a page. The tiles are allocated in the |
| // constructor to prevent them from potentially being allocated on the stack |
| BaseTile* m_baseTiles; |
| // stores the number of tiles in the m_baseTiles array. This enables us to |
| // quickly iterate over the array without have to check it's size |
| int m_baseTileSize; |
| int m_id; |
| float m_scale; |
| float m_invScale; |
| GLWebViewState* m_glWebViewState; |
| |
| // used to identify the tiles that have been invalidated (marked dirty) since |
| // the last time updateTileState() has been called. The region is stored in |
| // terms of the (x,y) coordinates used to determine the location of the tile |
| // within the page, not in content/view pixel coordinates. |
| SkRegion m_invalRegion; |
| |
| // inval regions in content coordinates |
| SkRegion m_invalTilesRegion; |
| unsigned int m_latestPictureInval; |
| bool m_prepare; |
| bool m_scrollingDown; |
| bool m_isPrefetchPage; |
| |
| // info saved in prepare, used in drawGL() |
| bool m_willDraw; |
| SkIRect m_tileBounds; |
| float m_transparency; |
| }; |
| |
| } // namespace WebCore |
| |
| #endif // USE(ACCELERATED_COMPOSITING) |
| #endif // TiledPage_h |