diff options
author | Steve Block <steveblock@google.com> | 2011-05-06 11:45:16 +0100 |
---|---|---|
committer | Steve Block <steveblock@google.com> | 2011-05-12 13:44:10 +0100 |
commit | cad810f21b803229eb11403f9209855525a25d57 (patch) | |
tree | 29a6fd0279be608e0fe9ffe9841f722f0f4e4269 /Source/WebCore/page/FrameView.h | |
parent | 121b0cf4517156d0ac5111caf9830c51b69bae8f (diff) | |
download | external_webkit-cad810f21b803229eb11403f9209855525a25d57.zip external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.gz external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.bz2 |
Merge WebKit at r75315: Initial merge by git.
Change-Id: I570314b346ce101c935ed22a626b48c2af266b84
Diffstat (limited to 'Source/WebCore/page/FrameView.h')
-rw-r--r-- | Source/WebCore/page/FrameView.h | 410 |
1 files changed, 410 insertions, 0 deletions
diff --git a/Source/WebCore/page/FrameView.h b/Source/WebCore/page/FrameView.h new file mode 100644 index 0000000..ed45d00 --- /dev/null +++ b/Source/WebCore/page/FrameView.h @@ -0,0 +1,410 @@ +/* + Copyright (C) 1997 Martin Jones (mjones@kde.org) + (C) 1998 Waldo Bastian (bastian@kde.org) + (C) 1998, 1999 Torben Weis (weis@kde.org) + (C) 1999 Lars Knoll (knoll@kde.org) + (C) 1999 Antti Koivisto (koivisto@kde.org) + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef FrameView_h +#define FrameView_h + +#include "Frame.h" +#include "IntSize.h" +#include "Page.h" +#include "RenderObject.h" // For PaintBehavior +#include "ScrollView.h" +#include <wtf/Forward.h> +#include <wtf/OwnPtr.h> + +namespace WebCore { + +class Color; +class Event; +class FrameViewPrivate; +class IntRect; +class Node; +class PlatformMouseEvent; +class RenderLayer; +class RenderObject; +class RenderEmbeddedObject; +class RenderScrollbarPart; +struct ScheduledEvent; + +template <typename T> class Timer; + +class FrameView : public ScrollView { +public: + friend class RenderView; + + static PassRefPtr<FrameView> create(Frame*); + static PassRefPtr<FrameView> create(Frame*, const IntSize& initialSize); + + virtual ~FrameView(); + + virtual HostWindow* hostWindow() const; + + virtual void invalidateRect(const IntRect&); + virtual void setFrameRect(const IntRect&); + + Frame* frame() const { return m_frame.get(); } + void clearFrame(); + + int marginWidth() const { return m_margins.width(); } // -1 means default + int marginHeight() const { return m_margins.height(); } // -1 means default + void setMarginWidth(int); + void setMarginHeight(int); + + virtual void setCanHaveScrollbars(bool); + void updateCanHaveScrollbars(); + + virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation); + + virtual bool avoidScrollbarCreation() const; + + virtual void setContentsSize(const IntSize&); + + void layout(bool allowSubtree = true); + bool didFirstLayout() const; + void layoutTimerFired(Timer<FrameView>*); + void scheduleRelayout(); + void scheduleRelayoutOfSubtree(RenderObject*); + void unscheduleRelayout(); + bool layoutPending() const; + bool isInLayout() const { return m_inLayout; } + + RenderObject* layoutRoot(bool onlyDuringLayout = false) const; + int layoutCount() const { return m_layoutCount; } + + bool needsLayout() const; + void setNeedsLayout(); + + bool needsFullRepaint() const { return m_doFullRepaint; } + +#if PLATFORM(ANDROID) + void updatePositionedObjects(); +#endif + +#if USE(ACCELERATED_COMPOSITING) + void updateCompositingLayers(); + + // Called when changes to the GraphicsLayer hierarchy have to be synchronized with + // content rendered via the normal painting path. + void setNeedsOneShotDrawingSynchronization(); +#endif +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + bool hasOverflowScroll() const { return m_hasOverflowScroll; } +#endif + + bool hasCompositedContent() const; + bool hasCompositedContentIncludingDescendants() const; + bool hasCompositingAncestor() const; + void enterCompositingMode(); + bool isEnclosedInCompositingLayer() const; + + // Only used with accelerated compositing, but outside the #ifdef to make linkage easier. + // Returns true if the sync was completed. + bool syncCompositingStateRecursive(); + + // Returns true when a paint with the PaintBehaviorFlattenCompositingLayers flag set gives + // a faithful representation of the content. + bool isSoftwareRenderable() const; + + void didMoveOnscreen(); + void willMoveOffscreen(); + + void resetScrollbars(); + void detachCustomScrollbars(); + + void clear(); + + bool isTransparent() const; + void setTransparent(bool isTransparent); + + Color baseBackgroundColor() const; + void setBaseBackgroundColor(Color); + void updateBackgroundRecursively(const Color&, bool); + + bool shouldUpdateWhileOffscreen() const; + void setShouldUpdateWhileOffscreen(bool); + bool shouldUpdate(bool = false) const; + + void adjustViewSize(); + + virtual IntRect windowClipRect(bool clipToContents = true) const; + IntRect windowClipRectForLayer(const RenderLayer*, bool clipToLayerContents) const; + + virtual IntRect windowResizerRect() const; + + void setScrollPosition(const IntPoint&); + void scrollPositionChangedViaPlatformWidget(); + virtual void repaintFixedElementsAfterScrolling(); + + String mediaType() const; + void setMediaType(const String&); + void adjustMediaTypeForPrinting(bool printing); + + void setUseSlowRepaints(); + void setIsOverlapped(bool); + bool isOverlapped() const { return m_isOverlapped; } + bool isOverlappedIncludingAncestors() const; + void setContentIsOpaque(bool); + + void addSlowRepaintObject(); + void removeSlowRepaintObject(); + + void addFixedObject(); + void removeFixedObject(); + + void beginDeferredRepaints(); + void endDeferredRepaints(); + void checkStopDelayingDeferredRepaints(); + void resetDeferredRepaintDelay(); + +#if ENABLE(DASHBOARD_SUPPORT) + void updateDashboardRegions(); +#endif + void updateControlTints(); + + void restoreScrollbar(); + + void scheduleEvent(PassRefPtr<Event>, PassRefPtr<Node>); + void pauseScheduledEvents(); + void resumeScheduledEvents(); + void postLayoutTimerFired(Timer<FrameView>*); + + bool wasScrolledByUser() const; + void setWasScrolledByUser(bool); + + void addWidgetToUpdate(RenderEmbeddedObject*); + void removeWidgetToUpdate(RenderEmbeddedObject*); + + virtual void paintContents(GraphicsContext*, const IntRect& damageRect); + void setPaintBehavior(PaintBehavior); + PaintBehavior paintBehavior() const; + bool isPainting() const; + void setNodeToDraw(Node*); + + static double currentPaintTimeStamp() { return sCurrentPaintTimeStamp; } // returns 0 if not painting + + void updateLayoutAndStyleIfNeededRecursive(); + void flushDeferredRepaints(); + + void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; } + + void forceLayout(bool allowSubtree = false); + void forceLayoutForPagination(const FloatSize& pageSize, float maximumShrinkFactor, Frame::AdjustViewSizeOrNot); + + // FIXME: This method is retained because of embedded WebViews in AppKit. When a WebView is embedded inside + // some enclosing view with auto-pagination, no call happens to resize the view. The new pagination model + // needs the view to resize as a result of the breaks, but that means that the enclosing view has to potentially + // resize around that view. Auto-pagination uses the bounds of the actual view that's being printed to determine + // the edges of the print operation, so the resize is necessary if the enclosing view's bounds depend on the + // web document's bounds. + // + // This is already a problem if the view needs to be a different size because of printer fonts or because of print stylesheets. + // Mail/Dictionary work around this problem by using the _layoutForPrinting SPI + // to at least get print stylesheets and printer fonts into play, but since WebKit doesn't know about the page offset or + // page size, it can't actually paginate correctly during _layoutForPrinting. + // + // We can eventually move Mail to a newer SPI that would let them opt in to the layout-time pagination model, + // but that doesn't solve the general problem of how other AppKit views could opt in to the better model. + // + // NO OTHER PLATFORM BESIDES MAC SHOULD USE THIS METHOD. + void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit); + + bool scrollToFragment(const KURL&); + bool scrollToAnchor(const String&); + void maintainScrollPositionAtAnchor(Node*); + + // Methods to convert points and rects between the coordinate space of the renderer, and this view. + virtual IntRect convertFromRenderer(const RenderObject*, const IntRect&) const; + virtual IntRect convertToRenderer(const RenderObject*, const IntRect&) const; + virtual IntPoint convertFromRenderer(const RenderObject*, const IntPoint&) const; + virtual IntPoint convertToRenderer(const RenderObject*, const IntPoint&) const; + + bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; } + void invalidateScrollCorner(); + + void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode); + + // Normal delay + static void setRepaintThrottlingDeferredRepaintDelay(double p); + // Negative value would mean that first few repaints happen without a delay + static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p); + // The delay grows on each repaint to this maximum value + static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p); + // On each repaint the delay increses by this amount + static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p); + +protected: + virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect); + virtual void scrollContentsSlowPath(const IntRect& updateRect); + + virtual bool isVerticalDocument() const; + virtual bool isFlippedDocument() const; + +private: + FrameView(Frame*); + + void reset(); + void init(); + + virtual bool isFrameView() const; + + friend class RenderWidget; + bool useSlowRepaints() const; + bool useSlowRepaintsIfNotOverlapped() const; + void updateCanBlitOnScrollRecursively(); + + bool hasFixedObjects() const { return m_fixedObjectCount > 0; } + + void applyOverflowToViewport(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode); + + void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow); + + void dispatchScheduledEvents(); + void performPostLayoutTasks(); + + virtual void repaintContentRectangle(const IntRect&, bool immediate); + virtual void contentsResized() { setNeedsLayout(); } + virtual void visibleContentsResized(); + + // Override ScrollView methods to do point conversion via renderers, in order to + // take transforms into account. + virtual IntRect convertToContainingView(const IntRect&) const; + virtual IntRect convertFromContainingView(const IntRect&) const; + virtual IntPoint convertToContainingView(const IntPoint&) const; + virtual IntPoint convertFromContainingView(const IntPoint&) const; + + // ScrollBarClient interface + virtual void valueChanged(Scrollbar*); + virtual void valueChanged(const IntSize&); + virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&); + virtual bool isActive() const; + virtual void getTickmarks(Vector<IntRect>&) const; + + void deferredRepaintTimerFired(Timer<FrameView>*); + void doDeferredRepaints(); + void updateDeferredRepaintDelay(); + double adjustedDeferredRepaintDelay() const; + + bool updateWidgets(); + void updateWidget(RenderEmbeddedObject*); + void scrollToAnchor(); + void scrollPositionChanged(); + + bool hasCustomScrollbars() const; + + virtual void updateScrollCorner(); + virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect); + + virtual AXObjectCache* axObjectCache() const; + void notifyWidgetsInAllFrames(WidgetNotification); + + static double sCurrentPaintTimeStamp; // used for detecting decoded resource thrash in the cache + + IntSize m_size; + IntSize m_margins; + + typedef HashSet<RenderEmbeddedObject*> RenderEmbeddedObjectSet; + OwnPtr<RenderEmbeddedObjectSet> m_widgetUpdateSet; + RefPtr<Frame> m_frame; + + bool m_doFullRepaint; + + bool m_canHaveScrollbars; + bool m_useSlowRepaints; + bool m_isOverlapped; + bool m_contentIsOpaque; + unsigned m_slowRepaintObjectCount; + unsigned m_fixedObjectCount; + + int m_borderX; + int m_borderY; + + Timer<FrameView> m_layoutTimer; + bool m_delayedLayout; + RenderObject* m_layoutRoot; + + bool m_layoutSchedulingEnabled; + bool m_inLayout; + bool m_hasPendingPostLayoutTasks; + bool m_inSynchronousPostLayout; + int m_layoutCount; + unsigned m_nestedLayoutCount; + Timer<FrameView> m_postLayoutTasksTimer; + bool m_firstLayoutCallbackPending; + + bool m_firstLayout; + bool m_isTransparent; + Color m_baseBackgroundColor; + IntSize m_lastLayoutSize; + float m_lastZoomFactor; + + String m_mediaType; + String m_mediaTypeWhenNotPrinting; + + unsigned m_enqueueEvents; + Vector<ScheduledEvent*> m_scheduledEvents; + + bool m_overflowStatusDirty; + bool m_horizontalOverflow; + bool m_verticalOverflow; + RenderObject* m_viewportRenderer; + + bool m_wasScrolledByUser; + bool m_inProgrammaticScroll; + + unsigned m_deferringRepaints; + unsigned m_repaintCount; + Vector<IntRect> m_repaintRects; + Timer<FrameView> m_deferredRepaintTimer; + double m_deferredRepaintDelay; + double m_lastPaintTime; + + bool m_shouldUpdateWhileOffscreen; + + unsigned m_deferSetNeedsLayouts; + bool m_setNeedsLayoutWasDeferred; + + RefPtr<Node> m_nodeToDraw; + PaintBehavior m_paintBehavior; + bool m_isPainting; + + bool m_isVisuallyNonEmpty; + bool m_firstVisuallyNonEmptyLayoutCallbackPending; + + RefPtr<Node> m_maintainScrollPositionAnchor; + + // Renderer to hold our custom scroll corner. + RenderScrollbarPart* m_scrollCorner; + + static double s_deferredRepaintDelay; + static double s_initialDeferredRepaintDelayDuringLoading; + static double s_maxDeferredRepaintDelayDuringLoading; + static double s_deferredRepaintDelayIncrementDuringLoading; +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + bool m_hasOverflowScroll; +#endif +}; + +} // namespace WebCore + +#endif // FrameView_h |