void ScrollableArea::setScrollOffsetFromAnimation(const IntPoint& offset)
{
// Tell the derived class to scroll its contents.
setScrollOffset(offset);
Scrollbar* verticalScrollbar = this->verticalScrollbar();
// Tell the scrollbars to update their thumb postions.
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
horizontalScrollbar->offsetDidChange();
if (horizontalScrollbar->isOverlayScrollbar()) {
if (!verticalScrollbar)
horizontalScrollbar->invalidate();
else {
// If there is both a horizontalScrollbar and a verticalScrollbar,
// then we must also invalidate the corner between them.
IntRect boundsAndCorner = horizontalScrollbar->boundsRect();
boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width());
horizontalScrollbar->invalidateRect(boundsAndCorner);
}
}
}
if (verticalScrollbar) {
verticalScrollbar->offsetDidChange();
if (verticalScrollbar->isOverlayScrollbar())
verticalScrollbar->invalidate();
}
}
void ScrollableArea::scrollPositionChanged(const IntPoint& position)
{
IntPoint oldPosition = scrollPosition();
// Tell the derived class to scroll its contents.
setScrollOffset(position);
Scrollbar* verticalScrollbar = this->verticalScrollbar();
// Tell the scrollbars to update their thumb postions.
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
horizontalScrollbar->offsetDidChange();
if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) {
if (!verticalScrollbar)
horizontalScrollbar->invalidate();
else {
// If there is both a horizontalScrollbar and a verticalScrollbar,
// then we must also invalidate the corner between them.
IntRect boundsAndCorner = horizontalScrollbar->boundsRect();
boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width());
horizontalScrollbar->invalidateRect(boundsAndCorner);
}
}
}
if (verticalScrollbar) {
verticalScrollbar->offsetDidChange();
if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
verticalScrollbar->invalidate();
}
if (scrollPosition() != oldPosition)
scrollAnimator()->notifyContentAreaScrolled();
}
LayoutRect RootFrameViewport::scrollIntoView(const LayoutRect& rectInContent,
const ScrollAlignment& alignX,
const ScrollAlignment& alignY,
ScrollType scrollType) {
// We want to move the rect into the viewport that excludes the scrollbars so
// we intersect the visual viewport with the scrollbar-excluded frameView
// content rect. However, we don't use visibleContentRect directly since it
// floors the scroll offset. Instead, we use ScrollAnimatorBase::currentOffset
// and construct a LayoutRect from that.
LayoutRect frameRectInContent =
LayoutRect(FloatPoint(layoutViewport().scrollAnimator().currentOffset()),
FloatSize(layoutViewport().visibleContentRect().size()));
LayoutRect visualRectInContent =
LayoutRect(FloatPoint(scrollOffsetFromScrollAnimators()),
FloatSize(visualViewport().visibleContentRect().size()));
// Intersect layout and visual rects to exclude the scrollbar from the view
// rect.
LayoutRect viewRectInContent =
intersection(visualRectInContent, frameRectInContent);
LayoutRect targetViewport = ScrollAlignment::getRectToExpose(
viewRectInContent, rectInContent, alignX, alignY);
if (targetViewport != viewRectInContent) {
setScrollOffset(ScrollOffset(targetViewport.x(), targetViewport.y()),
scrollType);
}
// RootFrameViewport only changes the viewport relative to the document so we
// can't change the input rect's location relative to the document origin.
return rectInContent;
}
void MGMap::init(int w, int h, int tw, int th, int windowWidth, int windowHeight)
{
if(m_TileProperty) delete[] m_TileProperty;
if(m_Occupied) delete[] m_Occupied;
if(m_MarkedForRendering) delete[] m_MarkedForRendering;
m_TileProperty = new unsigned int[w * h];
m_Occupied = new int[w * h];
m_MarkedForRendering = new bool[w * h];
m_Width = w;
m_Height = h;
m_TileWidth = tw;
m_TileHeight = th;
setScrollOffset(0, 0);
m_WindowWidth = windowWidth;
m_WindowHeight = windowHeight;
// The proper way to populate the tile properties would be to
// for example read in a level file, or set hard coded values.
// Here is just an example.
for (int x = 0; x < getWidth(); x++)
{
for (int y = 0; y < getHeight(); y++)
{
setTileProperty(x, y, MGMAP_TP_PROPERTY_1 | MGMAP_TP_NOOBSTACLE);
unOccupy(x, y);
unmarkForRendering(x, y);
}
}
}
bool MGMap::mouseScrollingUpdate(int x, int y)
{
if(m_MouseScrollingOngoing)
{
int setY = getScrollY() + m_MouseScrollingYClick - y;
int setX = getScrollX() + m_MouseScrollingXClick - x;
if(setY > getTopEdge())
{
setY = getTopEdge();
}
else if(setY < getWindowHeight() - getHeight() * getTileHeight() - getBottomEdge())
{
setY = getWindowHeight() - getHeight() * getTileHeight() - getBottomEdge();
}
if(setX > getLeftEdge())
{
setX = getLeftEdge();
}
else if(setX < getWindowWidth() - getWidth() * getTileWidth() - getRightEdge())
{
setX = getWindowWidth() - getWidth() * getTileWidth() - getRightEdge();
}
setScrollOffset(setX, setY);
}
return m_MouseScrollingOngoing;
}
void ScrollableArea::setScrollOffsetFromAnimation(const IntPoint& offset)
{
// Tell the derived class to scroll its contents.
setScrollOffset(offset);
// Tell the scrollbars to update their thumb postions.
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar())
horizontalScrollbar->offsetDidChange();
if (Scrollbar* verticalScrollbar = this->verticalScrollbar())
verticalScrollbar->offsetDidChange();
}
void Flickable::tick()
{
if (d->state == FlickablePrivate:: AutoScroll) {
d->speed = deaccelerate(d->speed);
setScrollOffset(d->offset - d->speed);
d->offset = scrollOffset();
if (d->speed == QPoint(0, 0)) {
d->state = FlickablePrivate::Steady;
d->ticker->stop();
}
} else {
d->ticker->stop();
}
}
void RenderLayerScrollableArea::setScrollOffset(const IntPoint& newScrollOffset)
{
// Ensure that the dimensions will be computed if they need to be (for overflow:hidden blocks).
if (m_scrollDimensionsDirty)
computeScrollDimensions();
if (scrollOffset() == toIntSize(newScrollOffset))
return;
setScrollOffset(toIntSize(newScrollOffset));
LocalFrame* frame = box().frame();
ASSERT(frame);
RefPtr<FrameView> frameView = box().frameView();
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ScrollLayer", "data", InspectorScrollLayerEvent::data(&box()));
const RenderLayerModelObject* paintInvalidationContainer = box().containerForPaintInvalidation();
// Update the positions of our child layers (if needed as only fixed layers should be impacted by a scroll).
// We don't update compositing layers, because we need to do a deep update from the compositing ancestor.
if (!frameView->isInPerformLayout()) {
// If we're in the middle of layout, we'll just update layers once layout has finished.
layer()->clipper().clearClipRectsIncludingDescendants();
box().setPreviousPaintInvalidationRect(box().boundsRectForPaintInvalidation(paintInvalidationContainer));
updateCompositingLayersAfterScroll();
}
// The caret rect needs to be invalidated after scrolling
frame->selection().setCaretRectNeedsUpdate();
FloatQuad quadForFakeMouseMoveEvent = FloatQuad(layer()->renderer()->previousPaintInvalidationRect());
quadForFakeMouseMoveEvent = paintInvalidationContainer->localToAbsoluteQuad(quadForFakeMouseMoveEvent);
frame->eventHandler().dispatchFakeMouseMoveEventSoonInQuad(quadForFakeMouseMoveEvent);
// For querying RenderLayer::compositingState()
// This code appears correct, since scrolling outside of layout happens during activities that do not dirty compositing state.
DisableCompositingQueryAsserts disabler;
if (box().frameView()->isInPerformLayout())
box().setShouldDoFullPaintInvalidation(true);
else
box().invalidatePaintUsingContainer(paintInvalidationContainer, layer()->renderer()->previousPaintInvalidationRect(), InvalidationScroll);
// Schedule the scroll DOM event.
if (box().node())
box().node()->document().enqueueScrollEventForNode(box().node());
}
void Flickable::handleMouseMove(QMouseEvent *event)
{
event->ignore();
if (!(event->buttons() & Qt::LeftButton))
return;
if (d->ignoreList.removeAll(event))
return;
QPoint delta;
switch (d->state) {
case FlickablePrivate::Pressed:
/* Steady Should be one situation */
case FlickablePrivate::Steady:
case FlickablePrivate::Stop:
delta = event->pos() - d->pressPos;
if (delta.x() > d->threshold || delta.x() < -d->threshold ||
delta.y() > d->threshold || delta.y() < -d->threshold) {
d->timeStamp = QTime::currentTime();
d->state = FlickablePrivate::ManualScroll;
d->delta = QPoint(0, 0);
d->pressPos = event->pos();
event->accept();
}
break;
case FlickablePrivate::ManualScroll:
event->accept();
delta = event->pos() - d->pressPos;
setScrollOffset(d->offset - delta);
if (d->timeStamp.elapsed() > 100) {
d->timeStamp = QTime::currentTime();
d->speed = delta - d->delta;
d->delta = delta;
}
break;
default:
break;
}
}
void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollType scrollType)
{
TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged");
DoublePoint oldPosition = scrollPositionDouble();
DoublePoint truncatedPosition = shouldUseIntegerScrollOffset() ? flooredIntPoint(position) : position;
// Tell the derived class to scroll its contents.
setScrollOffset(truncatedPosition, scrollType);
Scrollbar* verticalScrollbar = this->verticalScrollbar();
// Tell the scrollbars to update their thumb postions.
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
horizontalScrollbar->offsetDidChange();
if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) {
if (!verticalScrollbar)
horizontalScrollbar->invalidate();
else {
// If there is both a horizontalScrollbar and a verticalScrollbar,
// then we must also invalidate the corner between them.
IntRect boundsAndCorner = horizontalScrollbar->boundsRect();
boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width());
horizontalScrollbar->invalidateRect(boundsAndCorner);
}
}
}
if (verticalScrollbar) {
verticalScrollbar->offsetDidChange();
if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
verticalScrollbar->invalidate();
}
if (scrollPositionDouble() != oldPosition) {
// FIXME: Pass in DoubleSize. crbug.com/414283.
scrollAnimator()->notifyContentAreaScrolled(toFloatSize(scrollPositionDouble() - oldPosition));
}
scrollAnimator()->setCurrentPosition(toFloatPoint(position));
}
void VisualViewport::setScrollOffset(const IntPoint& offset, ScrollType scrollType)
{
setScrollOffset(DoublePoint(offset), scrollType);
}
void RootFrameViewport::setScrollOffset(const IntPoint& offset, ScrollType scrollType)
{
setScrollOffset(DoublePoint(offset), scrollType);
}
//-----------------------------------------------------------------------------
void CScrollContainer::setContainerSize (const CRect& cs)
{
containerSize = cs;
setScrollOffset (offset, false);
}
