📄 render_layer.h
字号:
RenderLayer *nextSibling() const { return m_next; }
RenderLayer *firstChild() const { return m_first; }
RenderLayer *lastChild() const { return m_last; }
void addChild(RenderLayer *newChild, RenderLayer* beforeChild = 0);
RenderLayer* removeChild(RenderLayer *oldChild);
void removeOnlyThisLayer();
void insertOnlyThisLayer();
void repaintIncludingDescendants();
void styleChanged();
Marquee* marquee() const { return m_marquee; }
void suspendMarquees();
#if APPLE_CHANGES
bool isTransparent();
RenderLayer* transparentAncestor();
void beginTransparencyLayers(QPainter* p);
#endif
#ifdef NOKIA_CHANGES
void getRenderersInRect(RenderLayer* rootLayer, QPtrList<LayerInfo>* boxInfoList,const QRect& rect,int deltaX, int deltaY, int layerZIndex = 0);
#endif
RenderLayer* root() {
RenderLayer* curr = this;
while (curr->parent()) curr = curr->parent();
return curr;
}
int xPos() const { return m_x; }
int yPos() const { return m_y; }
int width() const { return m_width; }
int height() const { return m_height; }
void setWidth(int w) { m_width = w; }
void setHeight(int h) { m_height = h; }
int scrollWidth();
int scrollHeight();
void setPos( int xPos, int yPos ) {
m_x = xPos;
m_y = yPos;
}
// Scrolling methods for layers that can scroll their overflow.
void scrollOffset(int& x, int& y);
void subtractScrollOffset(int& x, int& y);
int scrollXOffset() const { return m_scrollX; }
int scrollYOffset() const { return m_scrollY; }
void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);
void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
void scrollToYOffset(int y) { scrollToOffset(m_scrollX, y); }
void scrollRectToVisible(const QRect &r, const ScrollAlignment& alignX = gAlignCenterIfNeeded, const ScrollAlignment& alignY = gAlignCenterIfNeeded);
QRect getRectToExpose(const QRect &visibleRect, const QRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
void setHasHorizontalScrollbar(bool hasScrollbar);
void setHasVerticalScrollbar(bool hasScrollbar);
QScrollBar* horizontalScrollbar() { return m_hBar; }
QScrollBar* verticalScrollbar() { return m_vBar; }
int verticalScrollbarWidth();
int horizontalScrollbarHeight();
void moveScrollbarsAside();
void positionScrollbars(const QRect& absBounds);
#ifdef APPLE_CHANGES
void paintScrollbars(QPainter* p, const QRect& damageRect);
#endif
void updateScrollInfoAfterLayout();
void slotValueChanged(int);
void updateScrollPositionFromScrollbars();
bool scroll(KWQScrollDirection direction, KWQScrollGranularity granularity, float multiplier=1.0);
void updateLayerPosition();
void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint=true);
void computeRepaintRects();
void relativePositionOffset(int& relX, int& relY) {
relX += m_relX; relY += m_relY;
}
void clearClipRects();
void clearClipRect();
// Get the enclosing stacking context for this layer. A stacking context is a layer
// that has a non-auto z-index.
RenderLayer* stackingContext() const;
bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isCanvas(); }
void dirtyZOrderLists();
void updateZOrderLists();
QPtrVector<RenderLayer>* posZOrderList() const { return m_posZOrderList; }
QPtrVector<RenderLayer>* negZOrderList() const { return m_negZOrderList; }
// Gets the nearest enclosing positioned ancestor layer (also includes
// the <html> layer and the root layer).
RenderLayer* enclosingPositionedAncestor() const;
void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
int zIndex() const { return renderer()->style()->zIndex(); }
// The two main functions that use the layer system. The paint method
// paints the layers that intersect the damage rect from back to
// front. The hitTest method looks for mouse events by walking
// layers that intersect the point from front to back.
void paint(QPainter *p, const QRect& damageRect, bool selectionOnly=false, RenderObject *paintingRoot=0);
bool hitTest(RenderObject::NodeInfo& info, int x, int y);
// This method figures out our layerBounds in coordinates relative to
// |rootLayer}. It also computes our background and foreground clip rects
// for painting/event handling.
void calculateRects(const RenderLayer* rootLayer, const QRect& paintDirtyRect, QRect& layerBounds,
QRect& backgroundRect, QRect& foregroundRect);
void calculateClipRects(const RenderLayer* rootLayer);
ClipRects* clipRects() const { return m_clipRects; }
bool intersectsDamageRect(const QRect& layerBounds, const QRect& damageRect) const;
bool containsPoint(int x, int y, const QRect& damageRect) const;
void updateHoverActiveState(RenderObject::NodeInfo& info);
QRect repaintRect() const { return m_repaintRect; }
void detach(RenderArena* renderArena);
// Overloaded new operator. Derived classes must override operator new
// in order to allocate out of the RenderArena.
void* operator new(size_t sz, RenderArena* renderArena) throw();
// Overridden to prevent the normal delete from being called.
void operator delete(void* ptr, size_t sz);
private:
// The normal operator new is disallowed on all render objects.
void* operator new(size_t sz) throw();
private:
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
void setParent(RenderLayer* parent) { m_parent = parent; }
void setFirstChild(RenderLayer* first) { m_first = first; }
void setLastChild(RenderLayer* last) { m_last = last; }
void collectLayers(QPtrVector<RenderLayer>*&, QPtrVector<RenderLayer>*&);
void paintLayer(RenderLayer* rootLayer, QPainter *p, const QRect& paintDirtyRect,
bool haveTransparency, bool selectionOnly, RenderObject *paintingRoot);
RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderObject::NodeInfo& info,
int x, int y, const QRect& hitTestRect);
void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
protected:
RenderObject* m_object;
RenderLayer* m_parent;
RenderLayer* m_previous;
RenderLayer* m_next;
RenderLayer* m_first;
RenderLayer* m_last;
QRect m_repaintRect; // Cached repaint rects. Used by layout.
QRect m_fullRepaintRect;
// Our current relative position offset.
int m_relX;
int m_relY;
// Our (x,y) coordinates are in our parent layer's coordinate space.
int m_x;
int m_y;
// The layer's width/height
int m_width;
int m_height;
// Our scroll offsets if the view is scrolled.
int m_scrollX;
int m_scrollY;
// The width/height of our scrolled area.
int m_scrollWidth;
int m_scrollHeight;
// For layers with overflow, we have a pair of scrollbars.
QScrollBar* m_hBar;
QScrollBar* m_vBar;
RenderScrollMediator* m_scrollMediator;
// For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
// descendant layers within the stacking context that have z-indices of 0 or greater
// (auto will count as 0). m_negZOrderList holds descendants within our stacking context with negative
// z-indices.
QPtrVector<RenderLayer>* m_posZOrderList;
QPtrVector<RenderLayer>* m_negZOrderList;
ClipRects* m_clipRects; // Cached clip rects used when painting and hit testing.
bool m_scrollDimensionsDirty : 1;
bool m_zOrderListsDirty : 1;
#if APPLE_CHANGES
bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
// we ended up painting this layer or any descendants (and therefore need to
// blend).
#endif
Marquee* m_marquee; // Used by layers with overflow:marquee
};
}; // namespace
#endif
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -