#ifndef FrameView_h
#define FrameView_h
#include "AdjustViewSizeOrNot.h"
#include "Color.h"
#include "Frame.h"
#include "LayoutRect.h"
#include "Pagination.h"
#include "PaintPhase.h"
#include "ScrollView.h"
#include <wtf/Forward.h>
#include <wtf/OwnPtr.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class AXObjectCache;
class Element;
class Event;
class FloatSize;
class FrameActionScheduler;
class KURL;
class Node;
class Page;
class RenderBox;
class RenderEmbeddedObject;
class RenderLayer;
class RenderObject;
class RenderScrollbarPart;
class RenderStyle;
Pagination::Mode paginationModeForRenderStyle(RenderStyle*);
typedef unsigned long long DOMTimeStamp;
class FrameView : public ScrollView {
public:
friend class RenderView;
friend class Internals;
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&);
#if ENABLE(REQUEST_ANIMATION_FRAME)
virtual bool scheduleAnimation();
#endif
Frame* frame() const { return m_frame.get(); }
void clearFrame();
RenderView* renderView() const { return m_frame ? m_frame->contentRenderer() : 0; }
int mapFromLayoutToCSSUnits(LayoutUnit);
LayoutUnit mapFromCSSToLayoutUnits(int);
LayoutUnit marginWidth() const { return m_margins.width(); } LayoutUnit marginHeight() const { return m_margins.height(); } void setMarginWidth(LayoutUnit);
void setMarginHeight(LayoutUnit);
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;
void clearLayoutRoot() { m_layoutRoot = 0; }
int layoutCount() const { return m_layoutCount; }
bool needsLayout() const;
void setNeedsLayout();
void setViewportConstrainedObjectsNeedLayout();
bool needsFullRepaint() const { return m_doFullRepaint; }
#if ENABLE(REQUEST_ANIMATION_FRAME)
void serviceScriptedAnimations(double monotonicAnimationStartTime);
#endif
#if USE(ACCELERATED_COMPOSITING)
void updateCompositingLayersAfterStyleChange();
void updateCompositingLayersAfterLayout();
bool flushCompositingStateForThisFrame(Frame* rootFrameForFlush);
void clearBackingStores();
void restoreBackingStores();
void setNeedsOneShotDrawingSynchronization();
virtual TiledBacking* tiledBacking() OVERRIDE;
uint64_t scrollLayerID() const;
#endif
bool hasCompositedContent() const;
bool hasCompositedContentIncludingDescendants() const;
bool hasCompositingAncestor() const;
void enterCompositingMode();
bool isEnclosedInCompositingLayer() const;
bool flushCompositingStateIncludingSubframes();
bool isSoftwareRenderable() const;
void didMoveOnscreen();
void willMoveOffscreen();
void setIsInWindow(bool);
void resetScrollbars();
void resetScrollbarsAndClearContentsSize();
void prepareForDetach();
void detachCustomScrollbars();
virtual void recalculateScrollbarOverlayStyle();
void clear();
bool isTransparent() const;
void setTransparent(bool isTransparent);
bool hasOpaqueBackground() const;
Color baseBackgroundColor() const;
void setBaseBackgroundColor(const 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 windowClipRectForFrameOwner(const HTMLFrameOwnerElement*, bool clipToLayerContents) const;
virtual IntRect windowResizerRect() const;
virtual float visibleContentScaleFactor() const OVERRIDE;
virtual void setFixedVisibleContentRect(const IntRect&) OVERRIDE;
virtual void setScrollPosition(const IntPoint&) OVERRIDE;
void scrollPositionChangedViaPlatformWidget();
virtual void repaintFixedElementsAfterScrolling();
virtual void updateFixedElementsAfterScrolling();
virtual bool shouldRubberBandInDirection(ScrollDirection) const;
virtual bool requestScrollPositionUpdate(const IntPoint&) OVERRIDE;
virtual bool isRubberBandInProgress() const OVERRIDE;
virtual IntPoint minimumScrollPosition() const OVERRIDE;
virtual IntPoint maximumScrollPosition() const OVERRIDE;
LayoutRect viewportConstrainedVisibleContentRect() const;
String mediaType() const;
void setMediaType(const String&);
void adjustMediaTypeForPrinting(bool printing);
void setCannotBlitToWindow();
void setIsOverlapped(bool);
bool isOverlapped() const { return m_isOverlapped; }
bool isOverlappedIncludingAncestors() const;
void setContentIsOpaque(bool);
void addSlowRepaintObject(RenderObject*);
void removeSlowRepaintObject(RenderObject*);
bool hasSlowRepaintObject(RenderObject* o) const { return m_slowRepaintObjects && m_slowRepaintObjects->contains(o); }
bool hasSlowRepaintObjects() const { return m_slowRepaintObjects && m_slowRepaintObjects->size(); }
typedef HashSet<RenderObject*> ViewportConstrainedObjectSet;
void addViewportConstrainedObject(RenderObject*);
void removeViewportConstrainedObject(RenderObject*);
const ViewportConstrainedObjectSet* viewportConstrainedObjects() const { return m_viewportConstrainedObjects.get(); }
bool hasViewportConstrainedObjects() const { return m_viewportConstrainedObjects && m_viewportConstrainedObjects->size() > 0; }
IntSize scrollOffsetForFixedPosition() const;
static IntSize scrollOffsetForFixedPosition(const IntRect& visibleContentRect, const IntSize& totalContentsSize, const IntPoint& scrollPosition, const IntPoint& scrollOrigin, float frameScaleFactor, bool fixedElementsLayoutRelativeToFrame, int headerHeight, int footerHeight);
bool fixedElementsLayoutRelativeToFrame() const;
void beginDeferredRepaints();
void endDeferredRepaints();
void handleLoadCompleted();
void flushDeferredRepaints();
void startDeferredRepaintTimer(double delay);
void resetDeferredRepaintDelay();
void updateLayerFlushThrottlingInAllFrames();
void adjustTiledBackingCoverage();
void beginDisableRepaints();
void endDisableRepaints();
bool repaintsDisabled() { return m_disableRepaints > 0; }
#if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
void updateAnnotatedRegions();
#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);
bool safeToPropagateScrollToParent() const { return m_safeToPropagateScrollToParent; }
void setSafeToPropagateScrollToParent(bool isSafe) { m_safeToPropagateScrollToParent = isSafe; }
void addWidgetToUpdate(RenderObject*);
void removeWidgetToUpdate(RenderObject*);
virtual void paintContents(GraphicsContext*, const IntRect& damageRect);
void setPaintBehavior(PaintBehavior);
PaintBehavior paintBehavior() const;
bool isPainting() const;
bool hasEverPainted() const { return m_lastPaintTime; }
void setLastPaintTime(double lastPaintTime) { m_lastPaintTime = lastPaintTime; }
void setNodeToDraw(Node*);
enum SelectionInSnaphot { IncludeSelection, ExcludeSelection };
enum CoordinateSpaceForSnapshot { DocumentCoordinates, ViewCoordinates };
void paintContentsForSnapshot(GraphicsContext*, const IntRect& imageRect, SelectionInSnaphot shouldPaintSelection, CoordinateSpaceForSnapshot);
virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);
virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
virtual void paintScrollbar(GraphicsContext*, Scrollbar*, const IntRect&) OVERRIDE;
Color documentBackgroundColor() const;
bool isInChildFrameWithFrameFlattening() const;
static double currentPaintTimeStamp() { return sCurrentPaintTimeStamp; }
void updateLayoutAndStyleIfNeededRecursive();
void incrementVisuallyNonEmptyCharacterCount(unsigned);
void incrementVisuallyNonEmptyPixelCount(const IntSize&);
void setIsVisuallyNonEmpty();
bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
void enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize);
void setAutoSizeFixedMinimumHeight(int fixedMinimumHeight);
IntSize autoSizingIntrinsicContentSize() const { return m_autoSizeContentSize; }
void forceLayout(bool allowSubtree = false);
void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor, AdjustViewSizeOrNot);
void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit);
bool scrollToFragment(const KURL&);
bool scrollToAnchor(const String&);
void maintainScrollPositionAtAnchor(Node*);
void scrollElementToRect(Element*, const IntRect&);
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; }
bool isScrollable();
enum ScrollbarModesCalculationStrategy { RulesFromWebContentOnly, AnyRule };
void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);
static void setRepaintThrottlingDeferredRepaintDelay(double p);
static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p);
static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p);
static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p);
virtual IntPoint lastKnownMousePosition() const;
virtual bool isHandlingWheelEvent() const OVERRIDE;
bool shouldSetCursor() const;
virtual bool scrollbarsCanBeActive() const OVERRIDE;
void flushAnyPendingPostLayoutTasks();
virtual bool shouldSuspendScrollAnimations() const;
virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate);
void setAnimatorsAreActive();
RenderBox* embeddedContentBox() const;
void setTracksRepaints(bool);
bool isTrackingRepaints() const { return m_isTrackingRepaints; }
void resetTrackedRepaints();
const Vector<IntRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
String trackedRepaintRectsAsText() const;
typedef HashSet<ScrollableArea*> ScrollableAreaSet;
bool addScrollableArea(ScrollableArea*);
bool removeScrollableArea(ScrollableArea*);
bool containsScrollableArea(ScrollableArea*) const;
const ScrollableAreaSet* scrollableAreas() const { return m_scrollableAreas.get(); }
virtual void removeChild(Widget*) OVERRIDE;
bool wheelEvent(const PlatformWheelEvent&);
void setScrollingPerformanceLoggingEnabled(bool);
const Pagination& pagination() const;
void setPagination(const Pagination&);
bool inProgrammaticScroll() const { return m_inProgrammaticScroll; }
void setInProgrammaticScroll(bool programmaticScroll) { m_inProgrammaticScroll = programmaticScroll; }
#if ENABLE(CSS_FILTERS)
void setHasSoftwareFilters(bool hasSoftwareFilters) { m_hasSoftwareFilters = hasSoftwareFilters; }
bool hasSoftwareFilters() const { return m_hasSoftwareFilters; }
#endif
#if ENABLE(CSS_DEVICE_ADAPTATION)
IntSize initialViewportSize() const { return m_initialViewportSize; }
void setInitialViewportSize(const IntSize& size) { m_initialViewportSize = size; }
#endif
virtual bool isActive() const OVERRIDE;
#if ENABLE(RUBBER_BANDING)
GraphicsLayer* setWantsLayerForTopOverHangArea(bool) const;
GraphicsLayer* setWantsLayerForBottomOverHangArea(bool) const;
#endif
virtual int headerHeight() const OVERRIDE { return m_headerHeight; }
void setHeaderHeight(int);
virtual int footerHeight() const OVERRIDE { return m_footerHeight; }
void setFooterHeight(int);
virtual void willStartLiveResize() OVERRIDE;
virtual void willEndLiveResize() OVERRIDE;
#if USE(ACCELERATED_COMPOSITING)
virtual bool scrollbarAnimationsAreSuppressed() const OVERRIDE;
#endif
void addPaintPendingMilestones(LayoutMilestones);
void firePaintRelatedMilestones();
LayoutMilestones milestonesPendingPaint() const { return m_milestonesPendingPaint; }
bool visualUpdatesAllowedByClient() const { return m_visualUpdatesAllowedByClient; }
void setVisualUpdatesAllowedByClient(bool);
void resumeAnimatingImages();
void setScrollPinningBehavior(ScrollPinningBehavior);
protected:
virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
virtual void scrollContentsSlowPath(const IntRect& updateRect);
void repaintSlowRepaintObjects();
virtual bool isVerticalDocument() const;
virtual bool isFlippedDocument() const;
private:
explicit FrameView(Frame*);
void reset();
void init();
virtual bool isFrameView() const OVERRIDE { return true; }
friend class RenderWidget;
bool useSlowRepaints(bool considerOverlap = true) const;
bool useSlowRepaintsIfNotOverlapped() const;
void updateCanBlitOnScrollRecursively();
bool contentsInCompositedLayer() const;
bool shouldUpdateFixedElementsAfterScrolling();
void applyOverflowToViewport(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
void applyPaginationToViewport();
void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
void paintControlTints();
void forceLayoutParentViewIfNeeded();
void performPostLayoutTasks();
void autoSizeIfEnabled();
virtual void repaintContentRectangle(const IntRect&, bool immediate);
virtual void contentsResized() OVERRIDE;
virtual void visibleContentsResized();
virtual void delegatesScrollingDidChange();
virtual IntRect convertToContainingView(const IntRect&) const OVERRIDE;
virtual IntRect convertFromContainingView(const IntRect&) const OVERRIDE;
virtual IntPoint convertToContainingView(const IntPoint&) const OVERRIDE;
virtual IntPoint convertFromContainingView(const IntPoint&) const OVERRIDE;
virtual PlatformDisplayID windowDisplayID() const OVERRIDE;
virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) OVERRIDE;
virtual void getTickmarks(Vector<IntRect>&) const OVERRIDE;
virtual void scrollTo(const IntSize&) OVERRIDE;
virtual void setVisibleScrollerThumbRect(const IntRect&) OVERRIDE;
virtual ScrollableArea* enclosingScrollableArea() const OVERRIDE;
virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
virtual bool scrollAnimatorEnabled() const OVERRIDE;
#if USE(ACCELERATED_COMPOSITING)
virtual bool usesCompositedScrolling() const OVERRIDE;
virtual GraphicsLayer* layerForScrolling() const OVERRIDE;
virtual GraphicsLayer* layerForHorizontalScrollbar() const OVERRIDE;
virtual GraphicsLayer* layerForVerticalScrollbar() const OVERRIDE;
virtual GraphicsLayer* layerForScrollCorner() const OVERRIDE;
#if ENABLE(RUBBER_BANDING)
virtual GraphicsLayer* layerForOverhangAreas() const OVERRIDE;
#endif
#endif
virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation) OVERRIDE;
virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation) OVERRIDE;
void sendResizeEventIfNeeded();
void updateScrollableAreaSet();
virtual void notifyPageThatContentAreaWillPaint() const;
bool shouldUseLoadTimeDeferredRepaintDelay() const;
void deferredRepaintTimerFired(Timer<FrameView>*);
void doDeferredRepaints();
void updateDeferredRepaintDelayAfterRepaint();
double adjustedDeferredRepaintDelay() const;
bool updateWidgets();
void updateWidget(RenderObject*);
void scrollToAnchor();
void scrollPositionChanged();
bool hasCustomScrollbars() const;
virtual void updateScrollCorner();
FrameView* parentFrameView() const;
bool doLayoutWithFrameFlattening(bool allowSubtree);
virtual AXObjectCache* axObjectCache() const;
void notifyWidgetsInAllFrames(WidgetNotification);
void removeFromAXObjectCache();
static double sCurrentPaintTimeStamp;
LayoutSize m_size;
LayoutSize m_margins;
typedef HashSet<RenderObject*> RenderObjectSet;
OwnPtr<RenderObjectSet> m_widgetUpdateSet;
RefPtr<Frame> m_frame;
OwnPtr<RenderObjectSet> m_slowRepaintObjects;
bool m_doFullRepaint;
bool m_canHaveScrollbars;
bool m_cannotBlitToWindow;
bool m_isOverlapped;
bool m_contentIsOpaque;
int m_borderX;
int m_borderY;
Timer<FrameView> m_layoutTimer;
bool m_delayedLayout;
RenderObject* m_layoutRoot;
bool m_layoutSchedulingEnabled;
bool m_inLayout;
bool m_doingPreLayoutStyleUpdate;
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_lastViewportSize;
float m_lastZoomFactor;
String m_mediaType;
String m_mediaTypeWhenNotPrinting;
OwnPtr<FrameActionScheduler> m_actionScheduler;
bool m_overflowStatusDirty;
bool m_horizontalOverflow;
bool m_verticalOverflow;
RenderObject* m_viewportRenderer;
Pagination m_pagination;
bool m_wasScrolledByUser;
bool m_inProgrammaticScroll;
bool m_safeToPropagateScrollToParent;
unsigned m_deferringRepaints;
unsigned m_repaintCount;
Vector<LayoutRect> m_repaintRects;
Timer<FrameView> m_deferredRepaintTimer;
double m_deferredRepaintDelay;
double m_lastPaintTime;
unsigned m_disableRepaints;
bool m_isTrackingRepaints; Vector<IntRect> m_trackedRepaintRects;
bool m_shouldUpdateWhileOffscreen;
unsigned m_deferSetNeedsLayouts;
bool m_setNeedsLayoutWasDeferred;
RefPtr<Node> m_nodeToDraw;
PaintBehavior m_paintBehavior;
bool m_isPainting;
unsigned m_visuallyNonEmptyCharacterCount;
unsigned m_visuallyNonEmptyPixelCount;
bool m_isVisuallyNonEmpty;
bool m_firstVisuallyNonEmptyLayoutCallbackPending;
RefPtr<Node> m_maintainScrollPositionAnchor;
RenderScrollbarPart* m_scrollCorner;
bool m_shouldAutoSize;
bool m_inAutoSize;
bool m_didRunAutosize;
IntSize m_minAutoSize;
IntSize m_maxAutoSize;
int m_autoSizeFixedMinimumHeight;
IntSize m_autoSizeContentSize;
OwnPtr<ScrollableAreaSet> m_scrollableAreas;
OwnPtr<ViewportConstrainedObjectSet> m_viewportConstrainedObjects;
int m_headerHeight;
int m_footerHeight;
LayoutMilestones m_milestonesPendingPaint;
static double s_normalDeferredRepaintDelay;
static double s_initialDeferredRepaintDelayDuringLoading;
static double s_maxDeferredRepaintDelayDuringLoading;
static double s_deferredRepaintDelayIncrementDuringLoading;
#if ENABLE(CSS_FILTERS)
bool m_hasSoftwareFilters;
#endif
#if ENABLE(CSS_DEVICE_ADAPTATION)
IntSize m_initialViewportSize;
#endif
bool m_visualUpdatesAllowedByClient;
ScrollPinningBehavior m_scrollPinningBehavior;
};
inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
{
if (m_isVisuallyNonEmpty)
return;
m_visuallyNonEmptyCharacterCount += count;
static const unsigned visualCharacterThreshold = 200;
if (m_visuallyNonEmptyCharacterCount > visualCharacterThreshold)
setIsVisuallyNonEmpty();
}
inline void FrameView::incrementVisuallyNonEmptyPixelCount(const IntSize& size)
{
if (m_isVisuallyNonEmpty)
return;
m_visuallyNonEmptyPixelCount += size.width() * size.height();
static const unsigned visualPixelThreshold = 32 * 32;
if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
setIsVisuallyNonEmpty();
}
inline int FrameView::mapFromLayoutToCSSUnits(LayoutUnit value)
{
return value / (m_frame->pageZoomFactor() * m_frame->frameScaleFactor());
}
inline LayoutUnit FrameView::mapFromCSSToLayoutUnits(int value)
{
return value * m_frame->pageZoomFactor() * m_frame->frameScaleFactor();
}
inline FrameView* toFrameView(Widget* widget)
{
ASSERT(!widget || widget->isFrameView());
return static_cast<FrameView*>(widget);
}
inline const FrameView* toFrameView(const Widget* widget)
{
ASSERT(!widget || widget->isFrameView());
return static_cast<const FrameView*>(widget);
}
void toFrameView(const FrameView*);
}
#endif // FrameView_h