to view(), isView(). Rename the frame view accessor on the old canvas
from view() to frameView() (to avoid view()->view(), since that just looks
stupid). :)
Reviewed by andersca
* WebCore.vcproj/WebCore/WebCore.vcproj:
* WebCore.xcodeproj/project.pbxproj:
* bindings/js/kjs_dom.cpp:
* bindings/js/kjs_window.cpp:
* bridge/mac/FrameMac.mm:
* bridge/mac/WebCoreFrameBridge.mm:
(-[WebCoreFrameBridge _setupRootForPrinting:]):
(-[WebCoreFrameBridge computePageRectsWithPrintWidthScaleFactor:printHeight:]):
(-[WebCoreFrameBridge selectionColor]):
(-[WebCoreFrameBridge accessibilityTree]):
* dom/Document.cpp:
(WebCore::Document::attach):
(WebCore::Document::updateSelection):
(WebCore::Document::prepareMouseEvent):
* editing/SelectionController.cpp:
* kcanvas/device/quartz/KRenderingDeviceQuartz.mm:
* ksvg2/svg/SVGClipPathElement.cpp:
(SVGClipPathElement::canvasResource):
* ksvg2/svg/SVGFEFloodElement.cpp:
(SVGFEFloodElement::filterEffect):
* ksvg2/svg/SVGGradientElement.cpp:
(SVGGradientElement::rebuildStops):
* ksvg2/svg/SVGHelper.cpp:
(SVGHelper::PercentageOfViewport):
* ksvg2/svg/SVGPathElement.cpp:
(WebCore::SVGPathElement::getPointAtLength):
* ksvg2/svg/SVGSVGElement.cpp:
(WebCore::SVGSVGElement::currentTranslate):
* ksvg2/svg/SVGStyledElement.cpp:
(WebCore::SVGStyledElement::view):
(WebCore::SVGStyledElement::pushAttributeContext):
* ksvg2/svg/SVGStyledElement.h:
* kwq/WebCoreAXObject.mm:
(-[WebCoreAXObject accessibilityShouldUseUniqueId]):
(-[WebCoreAXObject role]):
(-[WebCoreAXObject value]):
(-[WebCoreAXObject position]):
(-[WebCoreAXObject accessibilityIsIgnored]):
(-[WebCoreAXObject accessibilityAttributeNames]):
(-[WebCoreAXObject topView]):
(-[WebCoreAXObject accessibilityAttributeValue:]):
* page/Frame.cpp:
(WebCore::Frame::selectionRect):
(WebCore::Frame::paint):
(WebCore::Frame::adjustPageHeight):
(WebCore::Frame::forceLayoutWithPageWidthRange):
* page/FrameView.cpp:
(WebCore::FrameView::adjustViewSize):
(WebCore::FrameView::layout):
* page/FrameView.h:
* rendering/AutoTableLayout.cpp:
(WebCore::shouldScaleColumns):
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::MarginInfo::MarginInfo):
(WebCore::RenderBlock::isSelfCollapsingBlock):
(WebCore::RenderBlock::layoutBlock):
(WebCore::RenderBlock::paintChildren):
(WebCore::RenderBlock::setSelectionState):
(WebCore::RenderBlock::isSelectionRoot):
(WebCore::RenderBlock::fillInlineSelectionGaps):
(WebCore::RenderBlock::lowestPosition):
(WebCore::RenderBlock::rightmostPosition):
(WebCore::RenderBlock::leftmostPosition):
(WebCore::RenderBlock::clearFloats):
(WebCore::RenderBlock::nodeAtPoint):
(WebCore::RenderBlock::calcBlocminMaxWidth):
(WebCore::RenderBlock::inRootBlockContext):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::setStyle):
(WebCore::RenderBox::paintRootBoxDecorations):
(WebCore::RenderBox::paintBackgroundExtended):
(WebCore::RenderBox::calcHeight):
(WebCore::RenderBox::calcPercentageHeight):
(WebCore::RenderBox::availableHeightUsing):
* rendering/RenderCanvas.cpp: Removed.
* rendering/RenderCanvas.h: Removed.
* rendering/RenderContainer.cpp:
(WebCore::RenderContainer::removeChildNode):
* rendering/RenderFileButton.cpp:
(WebCore::RenderFileButton::RenderFileButton):
* rendering/RenderFlow.cpp:
(WebCore::RenderFlow::destroy):
(WebCore::RenderFlow::paintLines):
* rendering/RenderFrameSet.cpp:
(WebCore::RenderFrameSet::layout):
(WebCore::RenderFrameSet::userResize):
(WebCore::RenderFrameSet::setResizing):
* rendering/RenderImage.cpp:
(WebCore::RenderImage::paint):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::updateLayerPositions):
(WebCore::RenderLayer::updateLayerPosition):
(WebCore::RenderLayer::stackingContext):
(WebCore::RenderLayer::enclosingPositionedAncestor):
(WebCore::RenderLayer::convertToLayerCoords):
(WebCore::RenderLayer::scrollToOffset):
(WebCore::isSubframeCanvas):
(WebCore::RenderLayer::intersectsDamageRect):
* rendering/RenderLayer.h:
(WebCore::RenderLayer::isStackingContext):
* rendering/RenderListMarker.cpp:
(WebCore::RenderListMarker::paint):
* rendering/RenderObject.cpp:
(WebCore::RenderObject::scroll):
(WebCore::RenderObject::containingBlock):
(WebCore::RenderObject::repaint):
(WebCore::RenderObject::repaintRectangle):
(WebCore::RenderObject::repaintAfterLayoutIfNeeded):
(WebCore::RenderObject::draggableNode):
(WebCore::RenderObject::selectionStartEnd):
(WebCore::RenderObject::setStyle):
(WebCore::RenderObject::viewRect):
(WebCore::RenderObject::view):
(WebCore::RenderObject::container):
(WebCore::RenderObject::removeFromObjectLists):
(WebCore::RenderObject::scheduleRelayout):
(WebCore::RenderObject::imageChanged):
(WebCore::RenderObject::maximalOutlineSize):
* rendering/RenderObject.h:
(WebCore::RenderObject::isRenderView):
* rendering/RenderTextArea.cpp:
(WebCore::RenderTextArea::RenderTextArea):
* rendering/RenderThemeMac.mm:
(WebCore::RenderThemeMac::paintCheckbox):
(WebCore::RenderThemeMac::paintRadio):
(WebCore::RenderThemeMac::paintButton):
* rendering/RenderTreeAsText.cpp:
(externalRepresentation):
* rendering/RenderView.cpp: Added.
(WebCore::RenderView::RenderView):
(WebCore::RenderView::~RenderView):
(WebCore::RenderView::calcHeight):
(WebCore::RenderView::calcWidth):
(WebCore::RenderView::calcMinMaxWidth):
(WebCore::RenderView::layout):
(WebCore::RenderView::absolutePosition):
(WebCore::RenderView::paint):
(WebCore::RenderView::paintBoxDecorations):
(WebCore::RenderView::repaintViewRectangle):
(WebCore::RenderView::getAbsoluteRepaintRect):
(WebCore::RenderView::computeAbsoluteRepaintRect):
(WebCore::RenderView::absoluteRects):
(WebCore::RenderView::selectionRect):
(WebCore::RenderView::setSelection):
(WebCore::RenderView::clearSelection):
(WebCore::RenderView::selectionStartEnd):
(WebCore::RenderView::updateWidgetPositions):
(WebCore::RenderView::addWidget):
(WebCore::RenderView::removeWidget):
(WebCore::RenderView::viewRect):
(WebCore::RenderView::docHeight):
(WebCore::RenderView::docWidth):
(WebCore::RenderView::setBestTruncatedAt):
* rendering/RenderView.h: Added.
(WebCore::RenderView::renderName):
(WebCore::RenderView::isRenderView):
(WebCore::RenderView::frameView):
* rendering/RenderWidget.cpp:
(WebCore::RenderWidget::RenderWidget):
(WebCore::RenderWidget::destroy):
(WebCore::RenderWidget::updateWidgetPosition):
* rendering/RenderWidget.h:
(WebCore::RenderWidget::widget):
* rendering/bidi.cpp:
(WebCore::RenderBlock::layoutInlineChildren):
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@14638
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2006-05-30 David Hyatt <hyatt@apple.com>
+
+ Rename RenderCanvas to RenderView. Rename canvas(), isCanvas()
+ to view(), isView(). Rename the frame view accessor on the old canvas
+ from view() to frameView() (to avoid view()->view(), since that just looks
+ stupid). :)
+
+ Reviewed by andersca
+
+ * WebCore.vcproj/WebCore/WebCore.vcproj:
+ * WebCore.xcodeproj/project.pbxproj:
+ * bindings/js/kjs_dom.cpp:
+ * bindings/js/kjs_window.cpp:
+ * bridge/mac/FrameMac.mm:
+ * bridge/mac/WebCoreFrameBridge.mm:
+ (-[WebCoreFrameBridge _setupRootForPrinting:]):
+ (-[WebCoreFrameBridge computePageRectsWithPrintWidthScaleFactor:printHeight:]):
+ (-[WebCoreFrameBridge selectionColor]):
+ (-[WebCoreFrameBridge accessibilityTree]):
+ * dom/Document.cpp:
+ (WebCore::Document::attach):
+ (WebCore::Document::updateSelection):
+ (WebCore::Document::prepareMouseEvent):
+ * editing/SelectionController.cpp:
+ * kcanvas/device/quartz/KRenderingDeviceQuartz.mm:
+ * ksvg2/svg/SVGClipPathElement.cpp:
+ (SVGClipPathElement::canvasResource):
+ * ksvg2/svg/SVGFEFloodElement.cpp:
+ (SVGFEFloodElement::filterEffect):
+ * ksvg2/svg/SVGGradientElement.cpp:
+ (SVGGradientElement::rebuildStops):
+ * ksvg2/svg/SVGHelper.cpp:
+ (SVGHelper::PercentageOfViewport):
+ * ksvg2/svg/SVGPathElement.cpp:
+ (WebCore::SVGPathElement::getPointAtLength):
+ * ksvg2/svg/SVGSVGElement.cpp:
+ (WebCore::SVGSVGElement::currentTranslate):
+ * ksvg2/svg/SVGStyledElement.cpp:
+ (WebCore::SVGStyledElement::view):
+ (WebCore::SVGStyledElement::pushAttributeContext):
+ * ksvg2/svg/SVGStyledElement.h:
+ * kwq/WebCoreAXObject.mm:
+ (-[WebCoreAXObject accessibilityShouldUseUniqueId]):
+ (-[WebCoreAXObject role]):
+ (-[WebCoreAXObject value]):
+ (-[WebCoreAXObject position]):
+ (-[WebCoreAXObject accessibilityIsIgnored]):
+ (-[WebCoreAXObject accessibilityAttributeNames]):
+ (-[WebCoreAXObject topView]):
+ (-[WebCoreAXObject accessibilityAttributeValue:]):
+ * page/Frame.cpp:
+ (WebCore::Frame::selectionRect):
+ (WebCore::Frame::paint):
+ (WebCore::Frame::adjustPageHeight):
+ (WebCore::Frame::forceLayoutWithPageWidthRange):
+ * page/FrameView.cpp:
+ (WebCore::FrameView::adjustViewSize):
+ (WebCore::FrameView::layout):
+ * page/FrameView.h:
+ * rendering/AutoTableLayout.cpp:
+ (WebCore::shouldScaleColumns):
+ * rendering/RenderBlock.cpp:
+ (WebCore::RenderBlock::MarginInfo::MarginInfo):
+ (WebCore::RenderBlock::isSelfCollapsingBlock):
+ (WebCore::RenderBlock::layoutBlock):
+ (WebCore::RenderBlock::paintChildren):
+ (WebCore::RenderBlock::setSelectionState):
+ (WebCore::RenderBlock::isSelectionRoot):
+ (WebCore::RenderBlock::fillInlineSelectionGaps):
+ (WebCore::RenderBlock::lowestPosition):
+ (WebCore::RenderBlock::rightmostPosition):
+ (WebCore::RenderBlock::leftmostPosition):
+ (WebCore::RenderBlock::clearFloats):
+ (WebCore::RenderBlock::nodeAtPoint):
+ (WebCore::RenderBlock::calcBlocminMaxWidth):
+ (WebCore::RenderBlock::inRootBlockContext):
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::setStyle):
+ (WebCore::RenderBox::paintRootBoxDecorations):
+ (WebCore::RenderBox::paintBackgroundExtended):
+ (WebCore::RenderBox::calcHeight):
+ (WebCore::RenderBox::calcPercentageHeight):
+ (WebCore::RenderBox::availableHeightUsing):
+ * rendering/RenderCanvas.cpp: Removed.
+ * rendering/RenderCanvas.h: Removed.
+ * rendering/RenderContainer.cpp:
+ (WebCore::RenderContainer::removeChildNode):
+ * rendering/RenderFileButton.cpp:
+ (WebCore::RenderFileButton::RenderFileButton):
+ * rendering/RenderFlow.cpp:
+ (WebCore::RenderFlow::destroy):
+ (WebCore::RenderFlow::paintLines):
+ * rendering/RenderFrameSet.cpp:
+ (WebCore::RenderFrameSet::layout):
+ (WebCore::RenderFrameSet::userResize):
+ (WebCore::RenderFrameSet::setResizing):
+ * rendering/RenderImage.cpp:
+ (WebCore::RenderImage::paint):
+ * rendering/RenderLayer.cpp:
+ (WebCore::RenderLayer::updateLayerPositions):
+ (WebCore::RenderLayer::updateLayerPosition):
+ (WebCore::RenderLayer::stackingContext):
+ (WebCore::RenderLayer::enclosingPositionedAncestor):
+ (WebCore::RenderLayer::convertToLayerCoords):
+ (WebCore::RenderLayer::scrollToOffset):
+ (WebCore::isSubframeCanvas):
+ (WebCore::RenderLayer::intersectsDamageRect):
+ * rendering/RenderLayer.h:
+ (WebCore::RenderLayer::isStackingContext):
+ * rendering/RenderListMarker.cpp:
+ (WebCore::RenderListMarker::paint):
+ * rendering/RenderObject.cpp:
+ (WebCore::RenderObject::scroll):
+ (WebCore::RenderObject::containingBlock):
+ (WebCore::RenderObject::repaint):
+ (WebCore::RenderObject::repaintRectangle):
+ (WebCore::RenderObject::repaintAfterLayoutIfNeeded):
+ (WebCore::RenderObject::draggableNode):
+ (WebCore::RenderObject::selectionStartEnd):
+ (WebCore::RenderObject::setStyle):
+ (WebCore::RenderObject::viewRect):
+ (WebCore::RenderObject::view):
+ (WebCore::RenderObject::container):
+ (WebCore::RenderObject::removeFromObjectLists):
+ (WebCore::RenderObject::scheduleRelayout):
+ (WebCore::RenderObject::imageChanged):
+ (WebCore::RenderObject::maximalOutlineSize):
+ * rendering/RenderObject.h:
+ (WebCore::RenderObject::isRenderView):
+ * rendering/RenderTextArea.cpp:
+ (WebCore::RenderTextArea::RenderTextArea):
+ * rendering/RenderThemeMac.mm:
+ (WebCore::RenderThemeMac::paintCheckbox):
+ (WebCore::RenderThemeMac::paintRadio):
+ (WebCore::RenderThemeMac::paintButton):
+ * rendering/RenderTreeAsText.cpp:
+ (externalRepresentation):
+ * rendering/RenderView.cpp: Added.
+ (WebCore::RenderView::RenderView):
+ (WebCore::RenderView::~RenderView):
+ (WebCore::RenderView::calcHeight):
+ (WebCore::RenderView::calcWidth):
+ (WebCore::RenderView::calcMinMaxWidth):
+ (WebCore::RenderView::layout):
+ (WebCore::RenderView::absolutePosition):
+ (WebCore::RenderView::paint):
+ (WebCore::RenderView::paintBoxDecorations):
+ (WebCore::RenderView::repaintViewRectangle):
+ (WebCore::RenderView::getAbsoluteRepaintRect):
+ (WebCore::RenderView::computeAbsoluteRepaintRect):
+ (WebCore::RenderView::absoluteRects):
+ (WebCore::RenderView::selectionRect):
+ (WebCore::RenderView::setSelection):
+ (WebCore::RenderView::clearSelection):
+ (WebCore::RenderView::selectionStartEnd):
+ (WebCore::RenderView::updateWidgetPositions):
+ (WebCore::RenderView::addWidget):
+ (WebCore::RenderView::removeWidget):
+ (WebCore::RenderView::viewRect):
+ (WebCore::RenderView::docHeight):
+ (WebCore::RenderView::docWidth):
+ (WebCore::RenderView::setBestTruncatedAt):
+ * rendering/RenderView.h: Added.
+ (WebCore::RenderView::renderName):
+ (WebCore::RenderView::isRenderView):
+ (WebCore::RenderView::frameView):
+ * rendering/RenderWidget.cpp:
+ (WebCore::RenderWidget::RenderWidget):
+ (WebCore::RenderWidget::destroy):
+ (WebCore::RenderWidget::updateWidgetPosition):
+ * rendering/RenderWidget.h:
+ (WebCore::RenderWidget::widget):
+ * rendering/bidi.cpp:
+ (WebCore::RenderBlock::layoutInlineChildren):
+
2006-05-30 Tim Omernick <timo@apple.com>
Reviewed by Geoff.
>\r
</File>\r
<File\r
- RelativePath="..\..\rendering\RenderCanvas.cpp"\r
+ RelativePath="..\..\rendering\RenderView.cpp"\r
>\r
</File>\r
<File\r
- RelativePath="..\..\rendering\RenderCanvas.h"\r
+ RelativePath="..\..\rendering\RenderView.h"\r
>\r
</File>\r
<File\r
BCEA4864097D93020094C9E4 /* RenderBR.h in Headers */ = {isa = PBXBuildFile; fileRef = BCEA4825097D93020094C9E4 /* RenderBR.h */; };
BCEA4865097D93020094C9E4 /* RenderButton.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCEA4826097D93020094C9E4 /* RenderButton.cpp */; };
BCEA4866097D93020094C9E4 /* RenderButton.h in Headers */ = {isa = PBXBuildFile; fileRef = BCEA4827097D93020094C9E4 /* RenderButton.h */; };
- BCEA4867097D93020094C9E4 /* RenderCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCEA4828097D93020094C9E4 /* RenderCanvas.cpp */; };
- BCEA4868097D93020094C9E4 /* RenderCanvas.h in Headers */ = {isa = PBXBuildFile; fileRef = BCEA4829097D93020094C9E4 /* RenderCanvas.h */; };
+ BCEA4867097D93020094C9E4 /* RenderView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCEA4828097D93020094C9E4 /* RenderView.cpp */; };
+ BCEA4868097D93020094C9E4 /* RenderView.h in Headers */ = {isa = PBXBuildFile; fileRef = BCEA4829097D93020094C9E4 /* RenderView.h */; };
BCEA4869097D93020094C9E4 /* RenderHTMLCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCEA482A097D93020094C9E4 /* RenderHTMLCanvas.cpp */; };
BCEA486A097D93020094C9E4 /* RenderHTMLCanvas.h in Headers */ = {isa = PBXBuildFile; fileRef = BCEA482B097D93020094C9E4 /* RenderHTMLCanvas.h */; };
BCEA486B097D93020094C9E4 /* RenderContainer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCEA482C097D93020094C9E4 /* RenderContainer.cpp */; };
BCEA4825097D93020094C9E4 /* RenderBR.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderBR.h; sourceTree = "<group>"; };
BCEA4826097D93020094C9E4 /* RenderButton.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderButton.cpp; sourceTree = "<group>"; };
BCEA4827097D93020094C9E4 /* RenderButton.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderButton.h; sourceTree = "<group>"; };
- BCEA4828097D93020094C9E4 /* RenderCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderCanvas.cpp; sourceTree = "<group>"; };
- BCEA4829097D93020094C9E4 /* RenderCanvas.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderCanvas.h; sourceTree = "<group>"; };
+ BCEA4828097D93020094C9E4 /* RenderView.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderView.cpp; sourceTree = "<group>"; };
+ BCEA4829097D93020094C9E4 /* RenderView.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderView.h; sourceTree = "<group>"; };
BCEA482A097D93020094C9E4 /* RenderHTMLCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderHTMLCanvas.cpp; sourceTree = "<group>"; };
BCEA482B097D93020094C9E4 /* RenderHTMLCanvas.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderHTMLCanvas.h; sourceTree = "<group>"; };
BCEA482C097D93020094C9E4 /* RenderContainer.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderContainer.cpp; sourceTree = "<group>"; };
BCEA4825097D93020094C9E4 /* RenderBR.h */,
BCEA4826097D93020094C9E4 /* RenderButton.cpp */,
BCEA4827097D93020094C9E4 /* RenderButton.h */,
- BCEA4828097D93020094C9E4 /* RenderCanvas.cpp */,
- BCEA4829097D93020094C9E4 /* RenderCanvas.h */,
+ BCEA4828097D93020094C9E4 /* RenderView.cpp */,
+ BCEA4829097D93020094C9E4 /* RenderView.h */,
BCEA482C097D93020094C9E4 /* RenderContainer.cpp */,
BCEA482D097D93020094C9E4 /* RenderContainer.h */,
93B70EB009EEE5B5009D8468 /* RenderEmptyApplet.cpp */,
BCEA4862097D93020094C9E4 /* RenderBox.h in Headers */,
BCEA4864097D93020094C9E4 /* RenderBR.h in Headers */,
BCEA4866097D93020094C9E4 /* RenderButton.h in Headers */,
- BCEA4868097D93020094C9E4 /* RenderCanvas.h in Headers */,
+ BCEA4868097D93020094C9E4 /* RenderView.h in Headers */,
BCEA486A097D93020094C9E4 /* RenderHTMLCanvas.h in Headers */,
BCEA486C097D93020094C9E4 /* RenderContainer.h in Headers */,
BCEA486E097D93020094C9E4 /* RenderFlexibleBox.h in Headers */,
BCEA4861097D93020094C9E4 /* RenderBox.cpp in Sources */,
BCEA4863097D93020094C9E4 /* RenderBR.cpp in Sources */,
BCEA4865097D93020094C9E4 /* RenderButton.cpp in Sources */,
- BCEA4867097D93020094C9E4 /* RenderCanvas.cpp in Sources */,
+ BCEA4867097D93020094C9E4 /* RenderView.cpp in Sources */,
BCEA4869097D93020094C9E4 /* RenderHTMLCanvas.cpp in Sources */,
BCEA486B097D93020094C9E4 /* RenderContainer.cpp in Sources */,
BCEA486D097D93020094C9E4 /* RenderFlexibleBox.cpp in Sources */,
#include "Notation.h"
#include "ProcessingInstruction.h"
#include "Range.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "dom2_eventsimpl.h"
#include "kjs_css.h"
#include "kjs_events.h"
#include "Logging.h"
#include "Page.h"
#include "PlugInInfoStore.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "Screen.h"
#include "SelectionController.h"
#include "dom2_eventsimpl.h"
#import "PlatformWheelEvent.h"
#import "Plugin.h"
#import "RegularExpression.h"
-#import "RenderCanvas.h"
+#import "RenderView.h"
#import "RenderImage.h"
#import "RenderListItem.h"
#import "RenderPart.h"
#import "ModifySelectionListLevel.h"
#import "MoveSelectionCommand.h"
#import "Page.h"
-#import "RenderCanvas.h"
+#import "RenderView.h"
#import "RenderImage.h"
#import "RenderPart.h"
#import "RenderTreeAsText.h"
- (void)_setupRootForPrinting:(BOOL)onOrOff
{
if (nowPrinting(self)) {
- RenderCanvas *root = static_cast<RenderCanvas *>(m_frame->document()->renderer());
+ RenderView *root = static_cast<RenderView *>(m_frame->document()->renderer());
if (root) {
root->setPrintingMode(onOrOff);
}
}
if (!m_frame || !m_frame->document() || !m_frame->view()) return pages;
- RenderCanvas* root = static_cast<RenderCanvas *>(m_frame->document()->renderer());
+ RenderView* root = static_cast<RenderView *>(m_frame->document()->renderer());
if (!root) return pages;
FrameView* view = m_frame->view();
- (NSColor *)selectionColor
{
- RenderCanvas* root = static_cast<RenderCanvas *>(m_frame->document()->renderer());
+ RenderView* root = static_cast<RenderView *>(m_frame->document()->renderer());
if (root) {
RenderStyle *pseudoStyle = root->getPseudoStyle(RenderStyle::SELECTION);
if (pseudoStyle && pseudoStyle->backgroundColor().isValid()) {
AccessibilityObjectCache::enableAccessibility();
if (!m_frame || !m_frame->document())
return nil;
- RenderCanvas* root = static_cast<RenderCanvas *>(m_frame->document()->renderer());
+ RenderView* root = static_cast<RenderView *>(m_frame->document()->renderer());
if (!root)
return nil;
return m_frame->document()->getAccObjectCache()->get(root);
#include "ProcessingInstruction.h"
#include "RegularExpression.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderWidget.h"
#include "SegmentedString.h"
#include "SelectionController.h"
m_renderArena = new RenderArena();
// Create the rendering tree
- setRenderer(new (m_renderArena) RenderCanvas(this, m_view));
+ setRenderer(new (m_renderArena) RenderView(this, m_view));
recalcStyle(Force);
if (!renderer())
return;
- RenderCanvas *canvas = static_cast<RenderCanvas*>(renderer());
+ RenderView *canvas = static_cast<RenderView*>(renderer());
SelectionController s = frame()->selection();
if (!s.isRange()) {
canvas->clearSelection();
if (startPos.isNotNull() && endPos.isNotNull()) {
RenderObject *startRenderer = startPos.node()->renderer();
RenderObject *endRenderer = endPos.node()->renderer();
- static_cast<RenderCanvas*>(renderer())->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
+ static_cast<RenderView*>(renderer())->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
}
}
if (!renderer())
return MouseEventWithHitTestResults(event, 0, false);
- assert(renderer()->isCanvas());
+ assert(renderer()->isRenderView());
RenderObject::NodeInfo renderInfo(readonly, active, mouseMove);
renderer()->layer()->hitTest(renderInfo, point);
#include "EventNames.h"
#include "Frame.h"
#include "GraphicsContext.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "TextIterator.h"
#include "dom2_eventsimpl.h"
#include "htmlediting.h"
#import "KRenderingStrokePainter.h"
#import "Logging.h"
#import "QuartzSupport.h"
-#import "RenderCanvas.h"
+#import "RenderView.h"
#import <Cocoa/Cocoa.h>
namespace WebCore {
#include "Attr.h"
#include "Document.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "SVGAnimatedEnumeration.h"
#include "SVGHelper.h"
#include "SVGNames.h"
KCanvasClipper *SVGClipPathElement::canvasResource()
{
- if (!canvas())
+ if (!view())
return 0;
if (!m_clipper)
m_clipper = static_cast<KCanvasClipper *>(renderingDevice()->createResource(RS_CLIPPER));
RenderStyle *pathStyle = document()->styleSelector()->styleForElement(styled, clipPathStyle);
if (KCanvasPath* pathData = styled->toPathData())
m_clipper->addClipData(pathData, (KCWindRule) pathStyle->svgStyle()->clipRule(), bbox);
- pathStyle->deref(canvas()->renderArena());
+ pathStyle->deref(view()->renderArena());
}
}
- clipPathStyle->deref(canvas()->renderArena());
+ clipPathStyle->deref(view()->renderArena());
return m_clipper;
}
#include "Attr.h"
#include "DeprecatedStringList.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "SVGAnimatedString.h"
#include "SVGDOMImplementation.h"
#include "SVGHelper.h"
const SVGRenderStyle *svgStyle = filterStyle->svgStyle();
m_filterEffect->setFloodColor(svgStyle->floodColor());
m_filterEffect->setFloodOpacity(svgStyle->floodOpacity());
- filterStyle->deref(canvas()->renderArena());
+ filterStyle->deref(view()->renderArena());
return m_filterEffect;
}
#include "Attr.h"
#include "Document.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "SVGAnimatedEnumeration.h"
#include "SVGAnimatedNumber.h"
#include "SVGAnimatedTransformList.h"
float opacity = stopStyle->svgStyle()->stopOpacity();
stops.append(makeGradientStop(stopOffset, makeRGBA(c.red(), c.green(), c.blue(), int(opacity * 255.))));
- stopStyle->deref(canvas()->renderArena());
+ stopStyle->deref(view()->renderArena());
}
}
- gradientStyle->deref(canvas()->renderArena());
+ gradientStyle->deref(view()->renderArena());
m_resource->setGradientStops(stops);
}
}
#include "Document.h"
#include "FrameView.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "SVGAnimatedLength.h"
#include "SVGAnimatedRect.h"
#include "SVGSVGElement.h"
if(doc->documentElement() == svg)
{
// We have to ask the canvas for the full "canvas size"...
- RenderCanvas *canvas = static_cast<RenderCanvas *>(doc->renderer());
- if(canvas)
- {
- width = canvas->view()->visibleWidth(); // TODO: recheck!
- height = canvas->view()->visibleHeight(); // TODO: recheck!
+ RenderView* view = static_cast<RenderView *>(doc->renderer());
+ if(view) {
+ width = view->frameView()->visibleWidth(); // TODO: recheck!
+ height = view->frameView()->visibleHeight(); // TODO: recheck!
}
}
}
{
SVGPoint *ret = SVGSVGElement::createSVGPoint();
/*double totalDistance = getTotalLength();
- T2P::BezierPath *path = ownerDoc()->canvas()->toBezierPath(m_item);
+ T2P::BezierPath *path = ownerDoc()->view()->toBezierPath(m_item);
if(path)
{
T2P::Point p;
SVGPoint *SVGSVGElement::currentTranslate() const
{
- //if(!canvas())
+ //if(!view())
return 0;
//return createSVGPoint(canvasView()->pan());
#include "KCanvasRenderingStyle.h"
#include "KRenderingDevice.h"
#include "PlatformString.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderPath.h"
#include "SVGAnimatedString.h"
#include "SVGDOMImplementation.h"
notifyAttributeChange();
}
-RenderCanvas* SVGStyledElement::canvas() const
+RenderView* SVGStyledElement::view() const
{
- return static_cast<RenderCanvas*>(document()->renderer());
+ return static_cast<RenderView*>(document()->renderer());
}
void SVGStyledElement::updateCanvasItem()
const SVGStyledElement* SVGStyledElement::pushAttributeContext(const SVGStyledElement*)
{
- if (canvas())
+ if (view())
static_cast<RenderPath*>(renderer())->setPath(toPathData());
return 0;
class KCanvasResource;
class KCanvasRenderingStyle;
class CSSStyleDeclaration;
- class RenderCanvas;
+ class RenderView;
class SVGStyledElement : public SVGElement
{
public:
virtual void parseMappedAttribute(MappedAttribute *attr);
- RenderCanvas *canvas() const;
+ RenderView *view() const;
virtual void notifyAttributeChange() const;
virtual void attributeChanged(Attribute *attr, bool preserveDecls = false);
#import "HTMLInputElement.h"
#import "HTMLMapElement.h"
#import "HTMLNames.h"
-#import "RenderCanvas.h"
+#import "RenderView.h"
#import "RenderImage.h"
#import "RenderListMarker.h"
#import "RenderTheme.h"
// appropriate place (e.g. dealloc) to remove these non-retained references from
// AppKit's id mapping tables.
- (BOOL)accessibilityShouldUseUniqueId {
- return m_renderer && m_renderer->isCanvas();
+ return m_renderer && m_renderer->isRenderView();
}
-(void)detach
return NSAccessibilityButtonRole;
return NSAccessibilityImageRole;
}
- if (m_renderer->isCanvas())
+ if (m_renderer->isRenderView())
return @"AXWebArea";
if (m_renderer->element() && m_renderer->element()->hasTagName(inputTag)) {
if (m_renderer->isListMarker())
return static_cast<RenderListMarker*>(m_renderer)->text().getNSString();
- if (m_renderer->isCanvas()) {
+ if (m_renderer->isRenderView()) {
if (m_renderer->document()->frame())
return nil;
// The Cocoa accessibility API wants the lower-left corner.
NSPoint point = NSMakePoint(rect.x(), rect.bottom());
- if (m_renderer && m_renderer->canvas() && m_renderer->canvas()->view()) {
- NSView* view = m_renderer->canvas()->view()->getDocumentView();
+ if (m_renderer && m_renderer->view() && m_renderer->view()->view()) {
+ NSView* view = m_renderer->view()->frameView()->getDocumentView();
point = [[view window] convertBaseToScreen: [view convertPoint: point toView:nil]];
}
return [NSValue valueWithPoint: point];
if (m_renderer->isBlockFlow() && m_renderer->childrenInline())
return !static_cast<RenderBlock*>(m_renderer)->firstLineBox() && ![self mouseButtonListener];
- return (!m_renderer->isListMarker() && !m_renderer->isCanvas() &&
+ return (!m_renderer->isListMarker() && !m_renderer->isRenderView() &&
!m_renderer->isImage() &&
!(m_renderer->element() && m_renderer->element()->isHTMLElement() &&
m_renderer->element()->hasTagName(buttonTag)));
nil];
}
- if (m_renderer && m_renderer->isCanvas())
+ if (m_renderer && m_renderer->isRenderView())
return webAreaAttrs;
if (m_areaElement || (m_renderer && !m_renderer->isImage() && m_renderer->element() && m_renderer->element()->isLink()))
return anchorAttrs;
- (FrameView *)topView
{
- return m_renderer->document()->topDocument()->renderer()->canvas()->view();
+ return m_renderer->document()->topDocument()->renderer()->view()->frameView();
}
- (id)accessibilityAttributeValue:(NSString *)attributeName
return [self roleDescription];
if ([attributeName isEqualToString: NSAccessibilityParentAttribute]) {
- if (m_renderer->isCanvas() && m_renderer->canvas() && m_renderer->canvas()->view())
- return m_renderer->canvas()->view()->getView();
+ if (m_renderer->isRenderView() && m_renderer->view() && m_renderer->view()->view())
+ return m_renderer->view()->frameView()->getView();
return [self parentObjectUnignored];
}
return m_children;
}
- if (m_renderer->isCanvas()) {
+ if (m_renderer->isRenderView()) {
if ([attributeName isEqualToString: @"AXLinkUIElements"]) {
NSMutableArray *links = [NSMutableArray arrayWithCapacity: 32];
HTMLCollection *coll = new HTMLCollection(m_renderer->document(), HTMLCollection::DOC_LINKS);
if ([attributeName isEqualToString: @"AXLoaded"])
return [NSNumber numberWithBool: (!m_renderer->document()->tokenizer())];
if ([attributeName isEqualToString: @"AXLayoutCount"])
- return [NSNumber numberWithInt: (static_cast<RenderCanvas*>(m_renderer)->view()->layoutCount())];
+ return [NSNumber numberWithInt: (static_cast<RenderView*>(m_renderer)->frameView()->layoutCount())];
}
if ([attributeName isEqualToString: @"AXURL"] &&
return [self position];
if ([attributeName isEqualToString: NSAccessibilityWindowAttribute]) {
- if (m_renderer && m_renderer->canvas() && m_renderer->canvas()->view())
- return [m_renderer->canvas()->view()->getView() window];
+ if (m_renderer && m_renderer->view() && m_renderer->view()->view())
+ return [m_renderer->view()->frameView()->getView() window];
return nil;
}
// Trouble is we need to know which document view to ask.
SelectionController sel = [self topView]->frame()->selection();
if (sel.isNone()) {
- sel = m_renderer->document()->renderer()->canvas()->view()->frame()->selection();
+ sel = m_renderer->document()->renderer()->view()->frameView()->frame()->selection();
if (sel.isNone())
return nil;
}
#include "NodeList.h"
#include "Page.h"
#include "Plugin.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderPart.h"
#include "RenderTheme.h"
#include "SegmentedString.h"
IntRect Frame::selectionRect() const
{
- RenderCanvas *root = static_cast<RenderCanvas*>(renderer());
+ RenderView *root = static_cast<RenderView*>(renderer());
if (!root)
return IntRect();
#if __APPLE__
// Regions may have changed as a result of the visibility/z-index of element changing.
if (renderer()->document()->dashboardRegionsDirty())
- renderer()->canvas()->view()->updateDashboardRegions();
+ renderer()->view()->frameView()->updateDashboardRegions();
#endif
} else
LOG_ERROR("called Frame::paint with nil renderer");
void Frame::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float bottomLimit)
{
- RenderCanvas *root = static_cast<RenderCanvas*>(document()->renderer());
+ RenderView *root = static_cast<RenderView*>(document()->renderer());
if (root) {
// Use a context with painting disabled.
GraphicsContext context(0);
{
// Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
// the state of things before and after the layout
- RenderCanvas *root = static_cast<RenderCanvas*>(document()->renderer());
+ RenderView *root = static_cast<RenderView*>(document()->renderer());
if (root) {
// This magic is basically copied from khtmlview::print
int pageW = (int)ceilf(minPageWidth);
#include "HTMLDocument.h"
#include "HTMLNames.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
namespace WebCore {
if (m_frame->document()) {
Document *document = m_frame->document();
- RenderCanvas* root = static_cast<RenderCanvas *>(document->renderer());
+ RenderView* root = static_cast<RenderView *>(document->renderer());
if (!root)
return;
if (document->hasChangedChild())
document->recalcStyle();
- RenderCanvas* root = static_cast<RenderCanvas*>(document->renderer());
+ RenderView* root = static_cast<RenderView*>(document->renderer());
if (!root) {
// FIXME: Do we need to set m_size here?
d->layoutSchedulingEnabled = true;
class MouseEventWithHitTestResults;
class Node;
class RenderBox;
-class RenderCanvas;
+class RenderView;
class RenderLineEdit;
class RenderObject;
class RenderPart;
friend class HTMLTitleElement;
friend class FrameMac;
friend class RenderBox;
- friend class RenderCanvas;
+ friend class RenderView;
friend class RenderLineEdit;
friend class RenderObject;
friend class RenderPart;
Length tw = table->style()->width();
if ((tw.isAuto() || tw.isPercent()) && !table->isPositioned()) {
RenderBlock* cb = table->containingBlock();
- while (cb && !cb->isCanvas() && !cb->isTableCell() &&
+ while (cb && !cb->isRenderView() && !cb->isTableCell() &&
cb->style()->width().isAuto() && !cb->isPositioned())
cb = cb->containingBlock();
#include "RenderTextFragment.h"
#include "SelectionController.h"
#include "HTMLNames.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderTheme.h"
#include "KWQTextStream.h"
// Whether or not we can collapse our own margins with our children. We don't do this
// if we had any border/padding (obviously), if we're the root or HTML elements, or if
// we're positioned, floating, a table cell.
- m_canCollapseWithChildren = !block->isCanvas() && !block->isRoot() && !block->isPositioned() &&
+ m_canCollapseWithChildren = !block->isRenderView() && !block->isRoot() && !block->isPositioned() &&
!block->isFloating() && !block->isTableCell() && !block->hasOverflowClip() && !block->isInlineBlockOrInlineTable();
m_canCollapseTopWithChildren = m_canCollapseWithChildren && (top == 0) && block->style()->marginTopCollapse() != MSEPARATE;
bool hasAutoHeight = style()->height().isAuto();
if (style()->height().isPercent() && !style()->htmlHacks()) {
hasAutoHeight = true;
- for (RenderBlock* cb = containingBlock(); !cb->isCanvas(); cb = cb->containingBlock()) {
+ for (RenderBlock* cb = containingBlock(); !cb->isRenderView(); cb = cb->containingBlock()) {
if (cb->style()->height().isFixed() || cb->isTableCell())
hasAutoHeight = false;
}
if (checkForRepaint)
didFullRepaint = repaintAfterLayoutIfNeeded(oldBounds, oldFullBounds);
if (!didFullRepaint && !repaintRect.isEmpty()) {
- RenderCanvas* c = canvas();
- if (c && c->view()) {
+ RenderView* v = view();
+ if (v && v->view()) {
repaintRect.inflate(maximalOutlineSize(PaintPhaseOutline));
- c->view()->addRepaintInfo(this, repaintRect); // We need to do a partial repaint of our content.
+ v->frameView()->addRepaintInfo(this, repaintRect); // We need to do a partial repaint of our content.
}
}
setNeedsLayout(false);
if (isPrinting && !childrenInline() && child->style()->pageBreakBefore() == PBALWAYS &&
inRootBlockContext() && (_ty + child->yPos()) > i.r.y() &&
(_ty + child->yPos()) < i.r.bottom()) {
- canvas()->setBestTruncatedAt(_ty + child->yPos(), this, true);
+ view()->setBestTruncatedAt(_ty + child->yPos(), this, true);
return;
}
if (isPrinting && !childrenInline() && child->style()->pageBreakAfter() == PBALWAYS &&
inRootBlockContext() && (_ty + child->yPos() + child->height()) > i.r.y() &&
(_ty + child->yPos() + child->height()) < i.r.bottom()) {
- canvas()->setBestTruncatedAt(_ty + child->yPos() + child->height() + child->collapsedMarginBottom(), this, true);
+ view()->setBestTruncatedAt(_ty + child->yPos() + child->height() + child->collapsedMarginBottom(), this, true);
return;
}
}
m_selectionState = s;
RenderBlock* cb = containingBlock();
- if (cb && !cb->isCanvas())
+ if (cb && !cb->isRenderView())
cb->setSelectionState(s);
}
isFloatingOrPositioned() || isTableCell() || isInlineBlockOrInlineTable())
return true;
- if (canvas() && canvas()->selectionStart()) {
- Node* startElement = canvas()->selectionStart()->element();
+ if (view() && view()->selectionStart()) {
+ Node* startElement = view()->selectionStart()->element();
if (startElement && startElement->rootEditableElement() == element())
return true;
}
{
GapRects result;
- RenderObject* selStart = canvas()->selectionStart();
+ RenderObject* selStart = view()->selectionStart();
// If there is no selection, don't try to get the selection's containing block.
// If we do, we'll crash.
bool containsStart = (selStart && (selStart == this || selStart->containingBlock() == this));
// Fixed positioned objects do not scroll and thus should not constitute
// part of the lowest position.
- if (m_positionedObjects && !isCanvas()) {
+ if (m_positionedObjects && !isRenderView()) {
RenderObject* r;
DeprecatedPtrListIterator<RenderObject> it(*m_positionedObjects);
for ( ; (r = it.current()); ++it ) {
}
}
- if (m_positionedObjects && !isCanvas()) {
+ if (m_positionedObjects && !isRenderView()) {
RenderObject* r;
DeprecatedPtrListIterator<RenderObject> it(*m_positionedObjects);
for ( ; (r = it.current()); ++it ) {
}
}
- if (m_positionedObjects && !isCanvas()) {
+ if (m_positionedObjects && !isRenderView()) {
RenderObject* r;
DeprecatedPtrListIterator<RenderObject> it(*m_positionedObjects);
for ( ; (r = it.current()); ++it ) {
m_floatingObjects->clear();
// Inline blocks are covered by the isReplaced() check in the avoidFloats method.
- if (avoidsFloats() || isRoot() || isCanvas() || isFloatingOrPositioned() || isTableCell())
+ if (avoidsFloats() || isRoot() || isRenderView() || isFloatingOrPositioned() || isTableCell())
return;
// Attempt to locate a previous sibling with overhanging floats. We skip any elements that are
// Hit test floats.
if (hitTestAction == HitTestFloat && m_floatingObjects) {
- if (isCanvas()) {
- scrolledX += static_cast<RenderCanvas*>(this)->view()->contentsX();
- scrolledY += static_cast<RenderCanvas*>(this)->view()->contentsY();
+ if (isRenderView()) {
+ scrolledX += static_cast<RenderView*>(this)->frameView()->contentsX();
+ scrolledY += static_cast<RenderView*>(this)->frameView()->contentsY();
}
FloatingObject* o;
if (style()->htmlHacks() && child->style()->width().isPercent() &&
!isTableCell() && child->isTable() && m_maxWidth < BLOCK_MAX_WIDTH) {
RenderBlock* cb = containingBlock();
- while (!cb->isCanvas() && !cb->isTableCell())
+ while (!cb->isRenderView() && !cb->isTableCell())
cb = cb->containingBlock();
if (!cb->isTableCell())
m_maxWidth = BLOCK_MAX_WIDTH;
if (isTableCell() || isFloatingOrPositioned() || hasOverflowClip())
return false;
- if (isRoot() || isCanvas())
+ if (isRoot() || isRenderView())
return true;
return containingBlock()->inRootBlockContext();
#include "HTMLElement.h"
#include "HTMLNames.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderFlexibleBox.h"
#include "RenderTableCell.h"
#include "RenderTheme.h"
m_layer->updateLayerPositions();
}
}
- else if (m_layer && !isRoot() && !isCanvas()) {
+ else if (m_layer && !isRoot() && !isRenderView()) {
assert(m_layer->parent());
RenderLayer *layer = m_layer;
m_layer = 0;
element()->document()->setTextColor(_style->color());
if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintPhaseOutline))
- static_cast<RenderCanvas*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
+ static_cast<RenderView*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
}
RenderBox::~RenderBox()
int h = height();
int rw, rh;
- if (canvas()->view()) {
- rw = canvas()->view()->contentsWidth();
- rh = canvas()->view()->contentsHeight();
+ if (view()->frameView()) {
+ rw = view()->frameView()->contentsWidth();
+ rh = view()->frameView()->contentsHeight();
}
else {
- rw = canvas()->width();
- rh = canvas()->height();
+ rw = view()->width();
+ rh = view()->height();
}
int bx = _tx - marginLeft();
// Only fill with a base color (e.g., white) if we're the root document, since iframes/frames with
// no background in the child document should show the parent's background.
- if (!bgLayer->next() && isRoot() && !(bgColor.isValid() && bgColor.alpha() > 0) && canvas()->view()) {
+ if (!bgLayer->next() && isRoot() && !(bgColor.isValid() && bgColor.alpha() > 0) && view()->view()) {
bool isTransparent;
WebCore::Node* elt = document()->ownerElement();
if (elt) {
isTransparent = !body || !body->hasLocalName(framesetTag); // Can't scroll a frameset document anyway.
}
} else
- isTransparent = canvas()->view()->isTransparent();
+ isTransparent = view()->view()->isTransparent();
if (isTransparent)
- canvas()->view()->useSlowRepaints(); // The parent must show behind the child.
+ view()->frameView()->useSlowRepaints(); // The parent must show behind the child.
else
bgColor = Color::white;
}
if (!bgLayer->next() && bgColor.isValid() && bgColor.alpha() > 0) {
IntRect rect(_tx, clipy, w, cliph);
// If we have an alpha and we are painting the root element, go ahead and blend with white.
- if (bgColor.alpha() < 0xFF && isRoot() && !canvas()->view()->isTransparent())
+ if (bgColor.alpha() < 0xFF && isRoot() && !view()->view()->isTransparent())
p->fillRect(rect, Color(Color::white));
p->fillRect(rect, bgColor);
}
if (style()->htmlHacks() && style()->height().isAuto() &&
!isFloatingOrPositioned() && (isRoot() || isBody())) {
int margins = collapsedMarginTop() + collapsedMarginBottom();
- int visHeight = canvas()->view()->visibleHeight();
+ int visHeight = view()->frameView()->visibleHeight();
if (isRoot())
m_height = max(m_height, visHeight - margins);
else
// block that may have a specified height and then use it. In strict mode, this violates the
// specification, which states that percentage heights just revert to auto if the containing
// block has an auto height.
- for ( ; !cb->isCanvas() && !cb->isBody() && !cb->isTableCell() && !cb->isPositioned() &&
+ for ( ; !cb->isRenderView() && !cb->isBody() && !cb->isTableCell() && !cb->isPositioned() &&
cb->style()->height().isAuto(); cb = cb->containingBlock());
}
result = cb->calcPercentageHeight(cb->style()->height());
if (result != -1)
result = cb->calcContentBoxHeight(result);
- } else if (cb->isCanvas() || (cb->isBody() && style()->htmlHacks()) ||
+ } else if (cb->isRenderView() || (cb->isBody() && style()->htmlHacks()) ||
(cb->isPositioned() && !(cb->style()->top().isAuto() || cb->style()->bottom().isAuto()))) {
// Don't allow this to affect the block' m_height member variable, since this
// can get called while the block is still laying out its kids.
if (h.isFixed())
return calcContentBoxHeight(h.value());
- if (isCanvas())
- return static_cast<const RenderCanvas*>(this)->view()->visibleHeight();
+ if (isRenderView())
+ return static_cast<const RenderView*>(this)->frameView()->visibleHeight();
// We need to stop here, since we don't want to increase the height of the table
// artificially. We're going to rely on this cell getting expanded to some new
#include "RenderTable.h"
#include "RenderTextFragment.h"
#include "RenderImage.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "Document.h"
// For accessibility
// FIXME: The SelectionController should be responsible for this when it
// is notified of DOM mutations.
if (oldChild->isSelectionBorder())
- canvas()->clearSelection();
+ view()->clearSelection();
// renumber ordered lists
if (oldChild->isListItem())
RenderFileButton::RenderFileButton(HTMLInputElement* element)
: RenderFormElement(element)
{
- setWidget(new KWQFileButton(view()->frame()));
+ setWidget(new KWQFileButton(m_view->frame()));
}
void RenderFileButton::calcMinMaxWidth()
#include "InlineTextBox.h"
#include "HTMLNames.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderInline.h"
using namespace std;
// FIXME: The SelectionController should be responsible for this when it
// is notified of DOM mutations.
if (isSelectionBorder())
- canvas()->clearSelection();
+ view()->clearSelection();
// If line boxes are contained inside a root, that means we're an inline.
// In that case, we need to remove all the line boxes so that the parent
// FIXME: This is a feeble effort to avoid splitting a line across two pages.
// It is utterly inadequate, and this should not be done at paint time at all.
// The whole way objects break across pages needs to be redone.
- RenderCanvas* c = canvas();
+ RenderView* c = view();
// Try to avoid splitting a line vertically, but only if it's less than the height
// of the entire page.
if (curr->root()->bottomOverflow() - curr->root()->topOverflow() <= c->printRect().height()) {
#include "HTMLNames.h"
#include "HTMLFrameSetElement.h"
#include "dom2_eventsimpl.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderFrame.h"
#include "KWQTextStream.h"
KHTMLAssert(minMaxKnown());
if (!parent()->isFrameSet()) {
- FrameView* view = canvas()->view();
- m_width = view->visibleWidth();
- m_height = view->visibleHeight();
+ FrameView* v = view()->frameView();
+ m_width = v->visibleWidth();
+ m_height = v->visibleHeight();
}
int remainingLen[2];
m_hSplitPos = _y;
m_oldpos = -1;
} else
- canvas()->view()->setCursor(pointerCursor());
+ view()->frameView()->setCursor(pointerCursor());
}
// ### check the resize is not going out of bounds.
// important, otherwise the moving indicator is not correctly erased
setNeedsLayout(true);
} else if (m_resizing || evt->type() == mouseupEvent) {
- FrameView* v = canvas()->view();
+ FrameView* v = view()->frameView();
v->disableFlushDrawing();
GraphicsContext* context = v->lockDrawingFocus();
for (RenderObject* p = parent(); p; p = p->parent())
if (p->isFrameSet())
static_cast<RenderFrameSet*>(p)->m_clientResizing = m_resizing;
- canvas()->view()->setResizingFrameSet(e ? element() : 0);
+ view()->frameView()->setResizingFrameSet(e ? element() : 0);
}
bool RenderFrameSet::canResize(int _x, int _y)
#include "HTMLInputElement.h"
#include "HTMLMapElement.h"
#include "HTMLNames.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
using namespace std;
int leftPad = paddingLeft();
int topPad = paddingTop();
- if (isPrinting && !canvas()->printImages())
+ if (isPrinting && !view()->printImages())
return;
if (!m_cachedImage || image()->isNull() || errorOccurred()) {
#include "HTMLMarqueeElement.h"
#include "HTMLNames.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderInline.h"
#include "RenderTheme.h"
#include "SelectionController.h"
// FIXME: Child object could override visibility.
if (checkForRepaint && (m_object->style()->visibility() == VISIBLE)) {
- RenderCanvas *c = m_object->canvas();
+ RenderView *c = m_object->view();
if (c && !c->printingMode()) {
int x, y;
m_object->absolutePosition(x, y);
// Clear our cached clip rect information.
clearClipRect();
- // The canvas is sized to the docWidth/Height over in RenderCanvas::layout, so we
+ // The canvas is sized to the docWidth/Height over in RenderView::layout, so we
// don't need to ever update our layer position here.
- if (renderer()->isCanvas())
+ if (renderer()->isRenderView())
return;
int x = m_object->xPos();
RenderLayer *RenderLayer::stackingContext() const
{
RenderLayer* curr = parent();
- for ( ; curr && !curr->m_object->isCanvas() && !curr->m_object->isRoot() &&
+ for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&
curr->m_object->style()->hasAutoZIndex();
curr = curr->parent());
return curr;
RenderLayer::enclosingPositionedAncestor() const
{
RenderLayer* curr = parent();
- for ( ; curr && !curr->m_object->isCanvas() && !curr->m_object->isRoot() &&
+ for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&
!curr->m_object->isPositioned() && !curr->m_object->isRelPositioned();
curr = curr->parent());
if (m_object->style()->position() == FixedPosition) {
// Add in the offset of the view. We can obtain this by calling
- // absolutePosition() on the RenderCanvas.
+ // absolutePosition() on the RenderView.
int xOff, yOff;
m_object->absolutePosition(xOff, yOff, true);
x += xOff;
for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
child->updateLayerPositions(false, false);
- RenderCanvas *canvas = renderer()->canvas();
- if (canvas) {
+ RenderView* view = renderer()->view();
+ if (view) {
#if __APPLE__
// Update dashboard regions, scrolling may change the clip of a
// particular region.
- canvas->view()->updateDashboardRegions();
+ view->frameView()->updateDashboardRegions();
#endif
- m_object->canvas()->updateWidgetPositions();
+ m_object->view()->updateWidgetPositions();
}
// Just schedule a full repaint of our object.
static inline bool isSubframeCanvas(RenderObject* renderer)
{
- return renderer->isCanvas() && renderer->node()->document()->frame()->tree()->parent();
+ return renderer->isRenderView() && renderer->node()->document()->frame()->tree()->parent();
}
static inline IntRect frameVisibleRect(RenderObject* renderer)
bool RenderLayer::intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect) const
{
// Always examine the canvas and the root.
- if (renderer()->isCanvas() || renderer()->isRoot())
+ if (renderer()->isRenderView() || renderer()->isRoot())
return true;
// If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we
namespace WebCore {
class CachedObject;
-class RenderCanvas;
+class RenderView;
class RenderFrameSet;
class RenderObject;
class RenderStyle;
// 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(); }
+ bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
void dirtyZOrderLists();
void updateZOrderLists();
#include "Document.h"
#include "GraphicsContext.h"
#include "ListMarkerBox.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderListItem.h"
using namespace std;
// This has been printed already we suppose.
return;
- RenderCanvas* c = canvas();
+ RenderView* c = view();
if (box.y() + box.height() + paddingBottom() + borderBottom() >= c->printRect().bottom()) {
if (box.y() < c->truncatedAt())
c->setBestTruncatedAt(box.y(), this);
#include "KWQWMatrix.h"
#include "Position.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderFlexibleBox.h"
#include "RenderInline.h"
#include "RenderListItem.h"
return true;
}
RenderBlock *b = containingBlock();
- if (b != 0 && !b->isCanvas()) {
+ if (b != 0 && !b->isRenderView()) {
return b->scroll(direction, granularity, multiplier);
}
return false;
{
if(isTableCell())
return static_cast<const RenderTableCell *>(this)->table();
- if (isCanvas())
+ if (isRenderView())
return (RenderBlock*)this;
RenderObject *o = parent();
if (!isText() && m_style->position() == FixedPosition) {
- while ( o && !o->isCanvas() )
+ while ( o && !o->isRenderView() )
o = o->parent();
}
else if (!isText() && m_style->position() == AbsolutePosition) {
while (o && (o->style()->position() == StaticPosition || (o->isInline() && !o->isReplaced()))
- && !o->isRoot() && !o->isCanvas()) {
+ && !o->isRoot() && !o->isRenderView()) {
// For relpositioned inlines, we return the nearest enclosing block. We don't try
// to return the inline itself. This allows us to avoid having a positioned objects
// list in all RenderInlines and lets us return a strongly-typed RenderBlock* result
void RenderObject::repaint(bool immediate)
{
- // Can't use canvas(), since we might be unrooted.
+ // Can't use view(), since we might be unrooted.
RenderObject* o = this;
while ( o->parent() ) o = o->parent();
- if (!o->isCanvas())
+ if (!o->isRenderView())
return;
- RenderCanvas* c = static_cast<RenderCanvas*>(o);
+ RenderView* c = static_cast<RenderView*>(o);
if (c->printingMode())
return; // Don't repaint if we're printing.
c->repaintViewRectangle(getAbsoluteRepaintRect(), immediate);
void RenderObject::repaintRectangle(const IntRect& r, bool immediate)
{
- // Can't use canvas(), since we might be unrooted.
+ // Can't use view(), since we might be unrooted.
RenderObject* o = this;
while ( o->parent() ) o = o->parent();
- if (!o->isCanvas())
+ if (!o->isRenderView())
return;
- RenderCanvas* c = static_cast<RenderCanvas*>(o);
+ RenderView* c = static_cast<RenderView*>(o);
if (c->printingMode())
return; // Don't repaint if we're printing.
IntRect absRect(r);
bool RenderObject::repaintAfterLayoutIfNeeded(const IntRect& oldBounds, const IntRect& oldFullBounds)
{
- RenderCanvas* c = canvas();
+ RenderView* c = view();
if (c->printingMode())
return false; // Don't repaint if we're printing.
if (elt && elt->nodeType() == Node::TEXT_NODE) {
// Since there's no way for the author to address the -webkit-user-drag style for a text node,
// we use our own judgement.
- if (uaOK && canvas()->view()->frame()->shouldDragAutoNode(curr->node(), IntPoint(x, y))) {
+ if (uaOK && view()->frameView()->frame()->shouldDragAutoNode(curr->node(), IntPoint(x, y))) {
dhtmlWillDrag = false;
return curr->node();
} else if (curr->shouldSelect()) {
dhtmlWillDrag = true;
return curr->node();
} else if (uaOK && dragMode == DRAG_AUTO
- && canvas()->view()->frame()->shouldDragAutoNode(curr->node(), IntPoint(x, y)))
+ && view()->frameView()->frame()->shouldDragAutoNode(curr->node(), IntPoint(x, y)))
{
dhtmlWillDrag = false;
return curr->node();
void RenderObject::selectionStartEnd(int& spos, int& epos)
{
- canvas()->selectionStartEnd(spos, epos);
+ view()->selectionStartEnd(spos, epos);
}
RenderBlock* RenderObject::createAnonymousBlock()
// the canvas. Just dirty the entire canvas when our style changes substantially.
if (d >= RenderStyle::Repaint && element() &&
(element()->hasTagName(htmlTag) || element()->hasTagName(bodyTag)))
- canvas()->repaint();
+ view()->repaint();
else if (m_parent && !isText()) {
// Do a repaint with the old style first, e.g., for example if we go from
// having an outline to not having an outline.
IntRect RenderObject::viewRect() const
{
- return canvas()->viewRect();
+ return view()->viewRect();
}
bool RenderObject::absolutePosition(int &xPos, int &yPos, bool f)
return containingBlock()->tabWidth(true);
}
-RenderCanvas* RenderObject::canvas() const
+RenderView* RenderObject::view() const
{
- return static_cast<RenderCanvas*>(document()->renderer());
+ return static_cast<RenderView*>(document()->renderer());
}
RenderObject *RenderObject::container() const
RenderObject *o = 0;
if (!isText() && pos == FixedPosition) {
// container() can be called on an object that is not in the
- // tree yet. We don't call canvas() since it will assert if it
+ // tree yet. We don't call view() since it will assert if it
// can't get back to the canvas. Instead we just walk as high up
// as we can. If we're in the tree, we'll get the root. If we
// aren't we'll get the root of our little subtree (most likely
// we may not have one if we're part of an uninstalled subtree. We'll
// climb as high as we can though.
o = parent();
- while (o && o->style()->position() == StaticPosition && !o->isRoot() && !o->isCanvas())
+ while (o && o->style()->position() == StaticPosition && !o->isRoot() && !o->isRenderView())
o = o->parent();
}
else
{
if (isFloating()) {
RenderBlock* outermostBlock = containingBlock();
- for (RenderBlock* p = outermostBlock; p && !p->isCanvas(); p = p->containingBlock()) {
+ for (RenderBlock* p = outermostBlock; p && !p->isRenderView(); p = p->containingBlock()) {
if (p->containsFloat(this))
outermostBlock = p;
}
void RenderObject::scheduleRelayout()
{
- if (!isCanvas())
+ if (!isRenderView())
return;
- FrameView *view = static_cast<RenderCanvas *>(this)->view();
+ FrameView *view = static_cast<RenderView *>(this)->frameView();
if (view)
view->scheduleRelayout();
}
// subclasses). It would be even better to find a more elegant way of doing this that
// would avoid putting this function and the CachedObjectClient base class into RenderObject.
if (image && image->canRender() && parent()) {
- if (canvas() && element() && (element()->hasTagName(htmlTag) || element()->hasTagName(bodyTag)))
- canvas()->repaint(); // repaint the entire canvas since the background gets propagated up
+ if (view() && element() && (element()->hasTagName(htmlTag) || element()->hasTagName(bodyTag)))
+ view()->repaint(); // repaint the entire canvas since the background gets propagated up
else
repaint(); // repaint object, which is a box or a container with boxes inside it
}
{
if (p != PaintPhaseOutline && p != PaintPhaseSelfOutline)
return 0;
- return static_cast<RenderCanvas*>(document()->renderer())->maximalOutlineSize();
+ return static_cast<RenderView*>(document()->renderer())->maximalOutlineSize();
}
int RenderObject::caretMinOffset() const
class InlineFlowBox;
class Position;
class RenderBlock;
-class RenderCanvas;
+class RenderView;
class RenderFlow;
class RenderFrameSet;
class RenderLayer;
virtual bool isListItem() const { return false; }
virtual bool isListMarker() const { return false; }
- virtual bool isCanvas() const { return false; }
+ virtual bool isRenderView() const { return false; }
bool isRoot() const;
bool isBody() const;
bool isHR() const;
void updateDragState(bool dragOn);
- RenderCanvas* canvas() const;
+ RenderView* view() const;
// don't even think about making this method virtual!
Node* element() const { return m_isAnonymous ? 0 : m_node; }
// note: do not add unnecessary bitflags, we have 32 bit already!
friend class RenderListItem;
friend class RenderContainer;
- friend class RenderCanvas;
+ friend class RenderView;
};
, m_dirty(false)
, m_updating(false)
{
- QTextEdit* edit = new QTextEdit(view());
+ QTextEdit* edit = new QTextEdit(m_view);
if (element->wrap() != HTMLTextAreaElement::ta_NoWrap)
edit->setWordWrap(QTextEdit::WidgetWidth);
#import "Document.h"
#import "FoundationExtras.h"
#import "FrameView.h"
-#import "RenderCanvas.h"
+#import "RenderView.h"
#import "WebCoreSystemInterface.h"
#import "cssstyleselector.h"
// We inflate the rect as needed to account for padding included in the cell to accommodate the checkbox
// shadow" and the check. We don't consider this part of the bounds of the control in WebKit.
IntRect inflatedRect = inflateRect(r, checkboxSizes()[[checkbox controlSize]], checkboxMargins());
- [checkbox drawWithFrame:NSRect(inflatedRect) inView:o->canvas()->view()->getDocumentView()];
+ [checkbox drawWithFrame:NSRect(inflatedRect) inView:o->view()->frameView()->getDocumentView()];
[checkbox setControlView: nil];
return false;
// We inflate the rect as needed to account for padding included in the cell to accommodate the checkbox
// shadow" and the check. We don't consider this part of the bounds of the control in WebKit.
IntRect inflatedRect = inflateRect(r, radioSizes()[[radio controlSize]], radioMargins());
- [radio drawWithFrame:NSRect(inflatedRect) inView:o->canvas()->view()->getDocumentView()];
+ [radio drawWithFrame:NSRect(inflatedRect) inView:o->view()->frameView()->getDocumentView()];
[radio setControlView: nil];
return false;
inflatedRect = inflateRect(inflatedRect, size, buttonMargins());
}
- [button drawWithFrame:NSRect(inflatedRect) inView:o->canvas()->view()->getDocumentView()];
+ [button drawWithFrame:NSRect(inflatedRect) inView:o->view()->frameView()->getDocumentView()];
[button setControlView:nil];
return false;
#include "InlineTextBox.h"
#include "JSEditor.h"
#include "RenderBR.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "RenderTableCell.h"
#include "RenderWidget.h"
#include "SelectionController.h"
ts.precision(2);
writeRenderResources(ts, o->document());
#endif
- o->canvas()->view()->layout();
+ o->view()->view()->layout();
RenderLayer* l = o->layer();
if (l) {
writeLayers(ts, l, l, IntRect(l->xPos(), l->yPos(), l->width(), l->height()));
--- /dev/null
+/**
+ * This file is part of the HTML widget for KDE.
+ *
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+#include "RenderView.h"
+
+#include "Document.h"
+#include "Element.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+
+namespace WebCore {
+
+//#define BOX_DEBUG
+
+RenderView::RenderView(Node* node, FrameView *view)
+ : RenderBlock(node)
+{
+ // Clear our anonymous bit, set because RenderObject assumes
+ // any renderer with document as the node is anonymous.
+ setIsAnonymous(false);
+
+ // init RenderObject attributes
+ setInline(false);
+
+ m_frameView = view;
+ // try to contrain the width to the views width
+
+ m_minWidth = 0;
+ m_height = 0;
+
+ m_width = m_minWidth;
+ m_maxWidth = m_minWidth;
+
+ setPositioned(true); // to 0,0 :)
+
+ m_printingMode = false;
+ m_printImages = true;
+
+ m_maximalOutlineSize = 0;
+
+ m_selectionStart = 0;
+ m_selectionEnd = 0;
+ m_selectionStartPos = -1;
+ m_selectionEndPos = -1;
+
+ // Create a new root layer for our layer hierarchy.
+ m_layer = new (node->document()->renderArena()) RenderLayer(this);
+}
+
+RenderView::~RenderView()
+{
+}
+
+void RenderView::calcHeight()
+{
+ if (!m_printingMode && m_frameView)
+ m_height = m_frameView->visibleHeight();
+}
+
+void RenderView::calcWidth()
+{
+ if (!m_printingMode && m_frameView)
+ m_width = m_frameView->visibleWidth();
+ m_marginLeft = 0;
+ m_marginRight = 0;
+}
+
+void RenderView::calcMinMaxWidth()
+{
+ KHTMLAssert( !minMaxKnown() );
+
+ RenderBlock::calcMinMaxWidth();
+
+ m_maxWidth = m_minWidth;
+
+ setMinMaxKnown();
+}
+
+void RenderView::layout()
+{
+ KHTMLAssert(!frameView()->inLayout());
+
+ if (m_printingMode)
+ m_minWidth = m_width;
+
+ setChildNeedsLayout(true);
+ setMinMaxKnown(false);
+ for (RenderObject *c = firstChild(); c; c = c->nextSibling())
+ c->setChildNeedsLayout(true);
+
+ if ( recalcMinMax() )
+ recalcMinMaxWidths();
+
+ RenderBlock::layout();
+
+ int docw = docWidth();
+ int doch = docHeight();
+
+ if (!m_printingMode) {
+ setWidth(m_frameView->visibleWidth());
+ setHeight(m_frameView->visibleHeight());
+ }
+
+ // ### we could maybe do the call below better and only pass true if the docsize changed.
+ layoutPositionedObjects( true );
+
+ layer()->setHeight(max(doch, m_height));
+ layer()->setWidth(max(docw, m_width));
+
+ setNeedsLayout(false);
+}
+
+bool RenderView::absolutePosition(int &xPos, int &yPos, bool f)
+{
+ if ( f && m_frameView) {
+ xPos = m_frameView->contentsX();
+ yPos = m_frameView->contentsY();
+ } else
+ xPos = yPos = 0;
+ return true;
+}
+
+void RenderView::paint(PaintInfo& i, int _tx, int _ty)
+{
+#ifdef DEBUG_LAYOUT
+ kdDebug( 6040 ) << renderName() << "(RenderView) " << this << " ::paintObject() w/h = (" << width() << "/" << height() << ")" << endl;
+#endif
+
+ // Cache the print rect because the dirty rect could get changed during painting.
+ if (m_printingMode)
+ setPrintRect(i.r);
+
+ // 1. paint background, borders etc
+ if (i.phase == PaintPhaseBlockBackground) {
+ paintBoxDecorations(i, _tx, _ty);
+ return;
+ }
+
+ // 2. paint contents
+ for (RenderObject *child = firstChild(); child; child = child->nextSibling())
+ if (!child->layer() && !child->isFloating())
+ child->paint(i, _tx, _ty);
+
+ if (m_frameView) {
+ _tx += m_frameView->contentsX();
+ _ty += m_frameView->contentsY();
+ }
+
+ // 3. paint floats.
+ if (i.phase == PaintPhaseFloat)
+ paintFloats(i, _tx, _ty);
+
+#ifdef BOX_DEBUG
+ outlineBox(i.p, _tx, _ty);
+#endif
+}
+
+void RenderView::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
+{
+ // Check to see if we are enclosed by a transparent layer. If so, we cannot blit
+ // when scrolling, and we need to use slow repaints.
+ Element* elt = element()->document()->ownerElement();
+ if (view() && elt) {
+ RenderLayer* layer = elt->renderer()->enclosingLayer();
+ if (layer->isTransparent() || layer->transparentAncestor())
+ frameView()->useSlowRepaints();
+ }
+
+ if ((firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
+ return;
+
+ // This code typically only executes if the root element's visibility has been set to hidden.
+ // Only fill with white if we're the root document, since iframes/frames with
+ // no background in the child document should show the parent's background.
+ if (elt || view()->isTransparent())
+ frameView()->useSlowRepaints(); // The parent must show behind the child.
+ else
+ i.p->fillRect(i.r, Color(Color::white));
+}
+
+void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
+{
+ if (m_printingMode || ur.width() == 0 || ur.height() == 0) return;
+
+ IntRect vr = viewRect();
+ if (m_frameView && ur.intersects(vr)) {
+ // We always just invalidate the root view, since we could be an iframe that is clipped out
+ // or even invisible.
+ IntRect r = intersection(ur, vr);
+ Element* elt = element()->document()->ownerElement();
+ if (!elt)
+ m_frameView->repaintRectangle(r, immediate);
+ else {
+ // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
+ // rectangle.
+ r.move(-m_frameView->contentsX(), -m_frameView->contentsY());
+
+ RenderObject* obj = elt->renderer();
+ // FIXME: Hardcoded offsets here are not good.
+ int yFrameOffset = m_frameView->hasBorder() ? 2 : 0;
+ int xFrameOffset = m_frameView->hasBorder() ? 1 : 0;
+ r.move(obj->borderLeft() + obj->paddingLeft() + xFrameOffset,
+ obj->borderTop() + obj->paddingTop() + yFrameOffset);
+ obj->repaintRectangle(r, immediate);
+ }
+ }
+}
+
+IntRect RenderView::getAbsoluteRepaintRect()
+{
+ IntRect result;
+ if (m_frameView && !m_printingMode)
+ result = IntRect(m_frameView->contentsX(), m_frameView->contentsY(),
+ m_frameView->visibleWidth(), m_frameView->visibleHeight());
+ return result;
+}
+
+void RenderView::computeAbsoluteRepaintRect(IntRect& r, bool f)
+{
+ if (m_printingMode)
+ return;
+
+ if (f && m_frameView)
+ r.move(m_frameView->contentsX(), m_frameView->contentsY());
+}
+
+void RenderView::absoluteRects(DeprecatedValueList<IntRect>& rects, int _tx, int _ty)
+{
+ rects.append(IntRect(_tx, _ty, m_layer->width(), m_layer->height()));
+}
+
+RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
+{
+ if (!object)
+ return 0;
+ RenderObject* child = object->childAt(offset);
+ return child ? child : object->nextInPreOrderAfterChildren();
+}
+
+IntRect RenderView::selectionRect() const
+{
+ typedef HashMap<RenderObject*, SelectionInfo*> SelectionMap;
+ SelectionMap selectedObjects;
+
+ RenderObject* os = m_selectionStart;
+ RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+ while (os && os != stop) {
+
+ if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+ // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+// assert(!selectedObjects.get(os));
+ selectedObjects.set(os, new SelectionInfo(os));
+ RenderBlock* cb = os->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ SelectionInfo* blockInfo = selectedObjects.get(cb);
+ if (blockInfo)
+ break;
+ selectedObjects.set(cb, new SelectionInfo(cb));
+ cb = cb->containingBlock();
+ }
+ }
+
+ os = os->nextInPreOrder();
+ }
+
+ // Now create a single bounding box rect that encloses the whole selection.
+ IntRect selRect;
+ SelectionMap::iterator end = selectedObjects.end();
+ for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
+ SelectionInfo* info = i->second;
+ selRect.unite(info->rect());
+ delete info;
+ }
+ return selRect;
+}
+
+void RenderView::setSelection(RenderObject *s, int sp, RenderObject *e, int ep)
+{
+ // Make sure both our start and end objects are defined.
+ // Check www.msnbc.com and try clicking around to find the case where this happened.
+ if ((s && !e) || (e && !s))
+ return;
+
+ // Just return if the selection hasn't changed.
+ if (m_selectionStart == s && m_selectionStartPos == sp &&
+ m_selectionEnd == e && m_selectionEndPos == ep)
+ return;
+
+ // Record the old selected objects. These will be used later
+ // when we compare against the new selected objects.
+ int oldStartPos = m_selectionStartPos;
+ int oldEndPos = m_selectionEndPos;
+
+ // Objects each have a single selection rect to examine.
+ typedef HashMap<RenderObject*, SelectionInfo*> SelectedObjectMap;
+ SelectedObjectMap oldSelectedObjects;
+ SelectedObjectMap newSelectedObjects;
+
+ // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
+ // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
+ // the union of those rects might remain the same even when changes have occurred.
+ typedef HashMap<RenderBlock*, BlockSelectionInfo*> SelectedBlockMap;
+ SelectedBlockMap oldSelectedBlocks;
+ SelectedBlockMap newSelectedBlocks;
+
+ RenderObject* os = m_selectionStart;
+ RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+ while (os && os != stop) {
+ if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+ // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+ oldSelectedObjects.set(os, new SelectionInfo(os));
+ RenderBlock* cb = os->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ BlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
+ if (blockInfo)
+ break;
+ oldSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+ cb = cb->containingBlock();
+ }
+ }
+
+ os = os->nextInPreOrder();
+ }
+
+ // Now clear the selection.
+ SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
+ for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
+ i->first->setSelectionState(SelectionNone);
+
+ // set selection start and end
+ m_selectionStart = s;
+ m_selectionStartPos = sp;
+ m_selectionEnd = e;
+ m_selectionEndPos = ep;
+
+ // Update the selection status of all objects between m_selectionStart and m_selectionEnd
+ if (s && s == e)
+ s->setSelectionState(SelectionBoth);
+ else {
+ if (s)
+ s->setSelectionState(SelectionStart);
+ if (e)
+ e->setSelectionState(SelectionEnd);
+ }
+
+ RenderObject* o = s;
+ stop = rendererAfterPosition(e, ep);
+
+ while (o && o != stop) {
+ if (o != s && o != e && o->canBeSelectionLeaf())
+ o->setSelectionState(SelectionInside);
+ o = o->nextInPreOrder();
+ }
+
+ // Now that the selection state has been updated for the new objects, walk them again and
+ // put them in the new objects list.
+ o = s;
+ while (o && o != stop) {
+
+ if ((o->canBeSelectionLeaf() || o == s || o == e) && o->selectionState() != SelectionNone) {
+ newSelectedObjects.set(o, new SelectionInfo(o));
+ RenderBlock* cb = o->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ BlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
+ if (blockInfo)
+ break;
+ newSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+ cb = cb->containingBlock();
+ }
+ }
+
+ o = o->nextInPreOrder();
+ }
+
+ if (!m_frameView)
+ return;
+
+ // Have any of the old selected objects changed compared to the new selection?
+ for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
+ RenderObject* obj = i->first;
+ SelectionInfo* newInfo = newSelectedObjects.get(obj);
+ SelectionInfo* oldInfo = i->second;
+ if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
+ (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
+ (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
+ m_frameView->updateContents(oldInfo->rect());
+ if (newInfo) {
+ m_frameView->updateContents(newInfo->rect());
+ newSelectedObjects.remove(obj);
+ delete newInfo;
+ }
+ }
+ delete oldInfo;
+ }
+
+ // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
+ SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
+ for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
+ SelectionInfo* newInfo = i->second;
+ m_frameView->updateContents(newInfo->rect());
+ delete newInfo;
+ }
+
+ // Have any of the old blocks changed?
+ SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
+ for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
+ RenderBlock* block = i->first;
+ BlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
+ BlockSelectionInfo* oldInfo = i->second;
+ if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
+ m_frameView->updateContents(oldInfo->rects());
+ if (newInfo) {
+ m_frameView->updateContents(newInfo->rects());
+ newSelectedBlocks.remove(block);
+ delete newInfo;
+ }
+ }
+ delete oldInfo;
+ }
+
+ // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
+ SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
+ for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
+ BlockSelectionInfo* newInfo = i->second;
+ m_frameView->updateContents(newInfo->rects());
+ delete newInfo;
+ }
+}
+
+void RenderView::clearSelection()
+{
+ setSelection(0, -1, 0, -1);
+}
+
+void RenderView::selectionStartEnd(int& spos, int& epos)
+{
+ spos = m_selectionStartPos;
+ epos = m_selectionEndPos;
+}
+
+void RenderView::updateWidgetPositions()
+{
+ RenderObjectSet::iterator end = m_widgets.end();
+ for (RenderObjectSet::iterator it = m_widgets.begin(); it != end; ++it) {
+ (*it)->updateWidgetPosition();
+ }
+}
+
+void RenderView::addWidget(RenderObject *o)
+{
+ m_widgets.add(o);
+}
+
+void RenderView::removeWidget(RenderObject *o)
+{
+ m_widgets.remove(o);
+}
+
+IntRect RenderView::viewRect() const
+{
+ if (m_printingMode)
+ return IntRect(0, 0, m_width, m_height);
+ if (m_frameView)
+ return IntRect(m_frameView->contentsX(),
+ m_frameView->contentsY(),
+ m_frameView->visibleWidth(),
+ m_frameView->visibleHeight());
+ return IntRect();
+}
+
+int RenderView::docHeight() const
+{
+ int h;
+ if (m_printingMode || !m_frameView)
+ h = m_height;
+ else
+ h = m_frameView->visibleHeight();
+
+ int lowestPos = lowestPosition();
+ if( lowestPos > h )
+ h = lowestPos;
+
+ // FIXME: This doesn't do any margin collapsing.
+ // Instead of this dh computation we should keep the result
+ // when we call RenderBlock::layout.
+ int dh = 0;
+ for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
+ dh += c->height() + c->marginTop() + c->marginBottom();
+ }
+ if( dh > h )
+ h = dh;
+
+ return h;
+}
+
+int RenderView::docWidth() const
+{
+ int w;
+ if (m_printingMode || !m_frameView)
+ w = m_width;
+ else
+ w = m_frameView->visibleWidth();
+
+ int rightmostPos = rightmostPosition();
+ if( rightmostPos > w )
+ w = rightmostPos;
+
+ for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
+ int dw = c->width() + c->marginLeft() + c->marginRight();
+ if( dw > w )
+ w = dw;
+ }
+ return w;
+}
+
+// The idea here is to take into account what object is moving the pagination point, and
+// thus choose the best place to chop it.
+void RenderView::setBestTruncatedAt(int y, RenderObject *forRenderer, bool forcedBreak)
+{
+ // Nobody else can set a page break once we have a forced break.
+ if (m_forcedPageBreak) return;
+
+ // Forced breaks always win over unforced breaks.
+ if (forcedBreak) {
+ m_forcedPageBreak = true;
+ m_bestTruncatedAt = y;
+ return;
+ }
+
+ // prefer the widest object who tries to move the pagination point
+ int width = forRenderer->width();
+ if (width > m_truncatorWidth) {
+ m_truncatorWidth = width;
+ m_bestTruncatedAt = y;
+ }
+}
+
+}
class FrameView;
-class RenderCanvas : public RenderBlock {
+class RenderView : public RenderBlock {
public:
- RenderCanvas(WebCore::Node* node, FrameView *view);
- virtual ~RenderCanvas();
+ RenderView(WebCore::Node* node, FrameView *view);
+ virtual ~RenderView();
- virtual const char *renderName() const { return "RenderCanvas"; }
+ virtual const char *renderName() const { return "RenderView"; }
- virtual bool isCanvas() const { return true; }
+ virtual bool isRenderView() const { return true; }
virtual void layout();
virtual void calcWidth();
int docHeight() const;
int docWidth() const;
- FrameView *view() const { return m_view; }
+ FrameView* frameView() const { return m_frameView; }
virtual bool hasOverhangingFloats() { return false; }
protected:
- FrameView *m_view;
+ FrameView* m_frameView;
RenderObject* m_selectionStart;
RenderObject* m_selectionEnd;
#include "EventNames.h"
#include "FrameView.h"
#include "GraphicsContext.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
using namespace std;
ASSERT(node);
m_view = node->document()->view();
- canvas()->addWidget(this);
+ view()->addWidget(this);
// this is no real reference counting, its just there
// to make sure that we're not deleted while we're recursed
// both RenderBox::destroy() and RenderObject::destroy().
// Fix originally made for <rdar://problem/4228818>.
- if (RenderCanvas *c = canvas())
+ if (RenderView *c = view())
c->removeWidget(this);
remove();
if (newBounds != oldBounds) {
// The widget changed positions. Update the frame geometry.
if (checkForRepaintDuringLayout()) {
- RenderCanvas* c = canvas();
+ RenderView* c = view();
if (!c->printingMode()) {
c->repaintViewRectangle(oldBounds);
c->repaintViewRectangle(newBounds);
virtual void layout( );
Widget* widget() const { return m_widget; }
- FrameView* view() const { return m_view; }
RenderArena* ref() { ++m_refCount; return renderArena(); }
void deref(RenderArena*);
#include "FrameView.h"
#include "InlineTextBox.h"
#include "RenderArena.h"
-#include "RenderCanvas.h"
+#include "RenderView.h"
#include "break_lines.h"
#include <wtf/AlwaysInline.h>
// that the block really needed a full layout, we missed our chance to repaint the layer
// before layout started. Luckily the layer has cached the repaint rect for its original
// position and size, and so we can use that to make a repaint happen now.
- RenderCanvas* c = canvas();
+ RenderView* c = view();
if (c && !c->printingMode())
c->repaintViewRectangle(m_layer->repaintRect());
}
git://git.webkit.org / WebKit-https.git / commitdiff