bool Camera::checkVisibility(const Matrix4& transform, const AABB2& boundingBox)
{
Size2 size = sharedEngine->getRenderer()->getSize();
Rectangle visibleRect(0.0f, 0.0f, size.width, size.height);
// transform center point to screen space
Vector2 diff = boundingBox.max - boundingBox.min;
Vector3 v3p(boundingBox.min.x + diff.x / 2.0f, boundingBox.min.y + diff.y / 2.0f, 0.0f);
diff *= zoom;
diff.x *= contentScale.x;
diff.y *= contentScale.y;
transform.transformPoint(v3p);
Vector2 v2p = projectPoint(v3p);
Size2 halfSize(diff.x / 2.0f, diff.y / 2.0f);
// convert content size to world coordinates
Size2 halfWorldSize;
halfWorldSize.width = std::max(fabsf(halfSize.width * transform.m[0] + halfSize.height * transform.m[4]), fabsf(halfSize.width * transform.m[0] - halfSize.height * transform.m[4]));
halfWorldSize.height = std::max(fabsf(halfSize.width * transform.m[1] + halfSize.height * transform.m[5]), fabsf(halfSize.width * transform.m[1] - halfSize.height * transform.m[5]));
// enlarge visible rect half size in screen coord
visibleRect.x -= halfWorldSize.width;
visibleRect.y -= halfWorldSize.height;
visibleRect.width += halfWorldSize.width * 2.0f;
visibleRect.height += halfWorldSize.height * 2.0f;
return visibleRect.containsPoint(v2p);
}
/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumScrollPosition()
*/
void QAbstractKineticScroller::ensureVisible(const QPoint &pos, int xmargin, int ymargin)
{
QSize visible = viewportSize();
QPoint currentPos = scrollPosition();
qKSDebug() << "QAbstractKineticScroller::ensureVisible(" << pos << ", " << xmargin << ", " << ymargin << ") - position: " << scrollPosition();
QRect posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRect visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPoint newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setX(posRect.right() - visible.width());
scrollTo(newPos);
}
/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumContentPosition()
*/
void QKineticScroller::ensureVisible(const QPointF &pos, int xmargin, int ymargin, int scrollTime)
{
QSizeF visible = viewportSize();
QPointF currentPos = contentPosition();
qKSDebug() << "QKS::ensureVisible(" << pos << " [pix], " << xmargin << " [pix], " << ymargin << " [pix], " << scrollTime << "[ms])";
qKSDebug() << " --> content position:" << contentPosition();
QRectF posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRectF visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPointF newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setY(posRect.right() - visible.width());
scrollTo(newPos, scrollTime);
}
void TabWidget::checkVisibility()
{
bool hasVisibleRect = (visibleRect().width()>1) &&
(visibleRect().height()>1);
if (0) qDebug("TabWidget %s: VR (%dx%d) HasVisibleRect: %s => %s",
objectName().toLatin1().constData(),
visibleRect().width(), visibleRect().height(),
_hasVisibleRect ? "Yes":"No",
hasVisibleRect ? "Yes":"No");
if (hasVisibleRect != _hasVisibleRect) {
_hasVisibleRect = hasVisibleRect;
emit visibleRectChanged(this);
}
}
double VisualViewport::scrollTop() {
if (!mainFrame())
return 0;
updateStyleAndLayoutIgnorePendingStylesheets();
return adjustScrollForAbsoluteZoom(visibleRect().y(),
mainFrame()->pageZoomFactor());
}
void ResizableLayer::onAppResized( CCObject* app )
{
CCNode* parent(getParent());
if(dynamic_cast<CCScene*>(parent) != nullptr) {
CCRect visibleRect(VisibleRect::getVisibleRect());
parent->setContentSize(visibleRect.size);
setContentSize(visibleRect.size);
}
}
void PhotoView::updatePanner( const QSizeF & vpSize )
{
QSizeF viewportSize = vpSize;
if ( ! viewportSize.isValid() )
viewportSize = size();
if ( viewportSize.width() < _panner->size().width() * 2 ||
viewportSize.height() < _panner->size().height() * 2 )
{
// If the panner would take up more than half the available space
// in any direction, don't show it.
_panner->hide();
}
else
{
Photo * photo = _photoDir->current();
if ( ! photo )
{
_panner->hide();
}
else
{
QSizeF origSize = photo->size();
QPointF canvasPos = _canvas->pos();
QSizeF canvasSize = _canvas->size();
qreal pannerX = 0.0;
qreal pannerY = -_panner->size().height();
if ( canvasSize.width() < viewportSize.width() )
pannerX = canvasPos.x();
if ( canvasSize.height() < viewportSize.height() )
pannerY += canvasPos.y() + canvasSize.height();
else
pannerY += viewportSize.height();
_panner->setPos( pannerX, pannerY );
QPointF visiblePos( -canvasPos.x(), -canvasPos.y() );
QSizeF visibleSize( qMin( viewportSize.width(),
canvasSize.width() ),
qMin( viewportSize.height(),
canvasSize.height() ) );
QRectF visibleRect( visiblePos / _zoomFactor,
visibleSize / _zoomFactor );
_panner->updatePanRect( visibleRect, origSize );
}
}
}
void PinchViewport::scrollIntoView(const FloatRect& rect)
{
if (!mainFrame() || !mainFrame()->view())
return;
FrameView* view = mainFrame()->view();
float centeringOffsetX = (visibleRect().width() - rect.width()) / 2;
float centeringOffsetY = (visibleRect().height() - rect.height()) / 2;
FloatPoint targetOffset(
rect.x() - centeringOffsetX - visibleRect().x(),
rect.y() - centeringOffsetY - visibleRect().y());
view->setScrollPosition(flooredIntPoint(targetOffset));
FloatPoint remainder = FloatPoint(targetOffset - view->scrollPosition());
move(remainder);
}
FloatRect PinchViewport::visibleRectInDocument() const
{
if (!mainFrame() || !mainFrame()->view())
return FloatRect();
FloatRect viewRect = mainFrame()->view()->visibleContentRect();
FloatRect pinchRect = visibleRect();
pinchRect.moveBy(viewRect.location());
return pinchRect;
}
/* static */ bool
HwcUtils::PrepareLayerRects(nsIntRect aVisible,
const gfx::Matrix& aLayerTransform,
const gfx::Matrix& aLayerBufferTransform,
nsIntRect aClip, nsIntRect aBufferRect,
bool aYFlipped,
hwc_rect_t* aSourceCrop, hwc_rect_t* aVisibleRegionScreen) {
gfxMatrix aTransform = gfx::ThebesMatrix(aLayerTransform);
gfxRect visibleRect(aVisible);
gfxRect clip(aClip);
gfxRect visibleRectScreen = aTransform.TransformBounds(visibleRect);
// |clip| is guaranteed to be integer
visibleRectScreen.IntersectRect(visibleRectScreen, clip);
if (visibleRectScreen.IsEmpty()) {
return false;
}
gfxMatrix inverse = gfx::ThebesMatrix(aLayerBufferTransform);
inverse.Invert();
gfxRect crop = inverse.TransformBounds(visibleRectScreen);
//clip to buffer size
crop.IntersectRect(crop, aBufferRect);
crop.Round();
if (crop.IsEmpty()) {
return false;
}
//propagate buffer clipping back to visible rect
gfxMatrix layerBufferTransform = gfx::ThebesMatrix(aLayerBufferTransform);
visibleRectScreen = layerBufferTransform.TransformBounds(crop);
visibleRectScreen.Round();
// Map from layer space to buffer space
crop -= aBufferRect.TopLeft();
if (aYFlipped) {
crop.y = aBufferRect.height - (crop.y + crop.height);
}
aSourceCrop->left = crop.x;
aSourceCrop->top = crop.y;
aSourceCrop->right = crop.x + crop.width;
aSourceCrop->bottom = crop.y + crop.height;
aVisibleRegionScreen->left = visibleRectScreen.x;
aVisibleRegionScreen->top = visibleRectScreen.y;
aVisibleRegionScreen->right = visibleRectScreen.x + visibleRectScreen.width;
aVisibleRegionScreen->bottom = visibleRectScreen.y + visibleRectScreen.height;
return true;
}
void CZoneView::DrawZone(CDC* pDC, const std::vector<CElement*>& selection, CElement* highlight) const
{
Graphics g = pDC->GetSafeHdc();
Pen pen(ColorToDraw(selection, highlight), 1);
//Arrondir les angles avec GDI+, possible ?
SolidBrush brush(Color::MakeARGB(100, fillColor.GetR(), fillColor.GetG(), fillColor.GetB()));
Rect visibleRect(*this);
visibleRect.Inflate(-3, -3);
g.FillRectangle(&brush, visibleRect);
g.DrawRectangle(&pen, visibleRect);
}
IntRect VisualViewport::visibleContentRect(
IncludeScrollbarsInRect scrollbarInclusion) const {
// TODO(ymalik): We're losing precision here and below. visibleRect should
// be replaced with visibleContentRect.
IntRect rect = IntRect(visibleRect());
if (scrollbarInclusion == ExcludeScrollbars) {
RootFrameViewport* rootFrameViewport =
mainFrame()->view()->getRootFrameViewport();
DCHECK(rootFrameViewport);
rect.contract(rootFrameViewport->verticalScrollbarWidth() / m_scale,
rootFrameViewport->horizontalScrollbarHeight() / m_scale);
}
return rect;
}
/**
* Sets hwc layer rectangles required for hwc composition
*
* @param aVisible Input. Layer's unclipped visible rectangle
* The origin is the top-left corner of the layer
* @param aTransform Input. Layer's transformation matrix
* It transforms from layer space to screen space
* @param aClip Input. A clipping rectangle.
* The origin is the top-left corner of the screen
* @param aBufferRect Input. The layer's buffer bounds
* The origin is the top-left corner of the layer
* @param aSurceCrop Output. Area of the source to consider,
* the origin is the top-left corner of the buffer
* @param aVisibleRegionScreen Output. Visible region in screen space.
* The origin is the top-left corner of the screen
* @return true if the layer should be rendered.
* false if the layer can be skipped
*/
static bool
PrepareLayerRects(nsIntRect aVisible, const gfxMatrix& aTransform,
nsIntRect aClip, nsIntRect aBufferRect,
hwc_rect_t* aSourceCrop, hwc_rect_t* aVisibleRegionScreen) {
gfxRect visibleRect(aVisible);
gfxRect clip(aClip);
gfxRect visibleRectScreen = aTransform.TransformBounds(visibleRect);
// |clip| is guaranteed to be integer
visibleRectScreen.IntersectRect(visibleRectScreen, clip);
if (visibleRectScreen.IsEmpty()) {
LOGD("Skip layer");
return false;
}
gfxMatrix inverse(aTransform);
inverse.Invert();
gfxRect crop = inverse.TransformBounds(visibleRectScreen);
//clip to buffer size
crop.IntersectRect(crop, aBufferRect);
crop.RoundOut();
if (crop.IsEmpty()) {
LOGD("Skip layer");
return false;
}
//propagate buffer clipping back to visible rect
visibleRectScreen = aTransform.TransformBounds(crop);
visibleRectScreen.RoundOut();
// Map from layer space to buffer space
crop -= aBufferRect.TopLeft();
aSourceCrop->left = crop.x;
aSourceCrop->top = crop.y;
aSourceCrop->right = crop.x + crop.width;
aSourceCrop->bottom = crop.y + crop.height;
aVisibleRegionScreen->left = visibleRectScreen.x;
aVisibleRegionScreen->top = visibleRectScreen.y;
aVisibleRegionScreen->right = visibleRectScreen.x + visibleRectScreen.width;
aVisibleRegionScreen->bottom = visibleRectScreen.y + visibleRectScreen.height;
return true;
}
void PinchViewport::setScale(float scale)
{
if (scale == m_scale)
return;
m_scale = scale;
if (mainFrame())
mainFrame()->loader().saveScrollState();
// Old-style pinch sets scale here but we shouldn't call into the
// clamping code below.
if (!m_innerViewportScrollLayer)
return;
// Ensure we clamp so we remain within the bounds.
setLocation(visibleRect().location());
// TODO: We should probably be calling scaleDidChange type functions here.
// see Page::setPageScaleFactor.
}
void UIFrameBufferQuartz2D::paintEvent(QPaintEvent *aEvent)
{
/* If the machine is NOT in 'running' state,
* the link between framebuffer and video memory
* is broken, we should go fallback now... */
if (m_fUsesGuestVRAM &&
!m_pMachineView->uisession()->isRunning() &&
!m_pMachineView->uisession()->isPaused() &&
/* Online snapshotting: */
m_pMachineView->uisession()->machineState() != KMachineState_Saving)
{
/* Simulate fallback through fake resize-event: */
UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, 640, 480);
resizeEvent(&event);
}
/* For debugging /Developer/Applications/Performance Tools/Quartz
* Debug.app is a nice tool to see which parts of the screen are
* updated.*/
Assert(m_image);
QWidget* viewport = m_pMachineView->viewport();
Assert(VALID_PTR(viewport));
/* Get the dimensions of the viewport */
CGRect viewRect = ::darwinToCGRect(viewport->geometry());
/* Get the context of this window from Qt */
CGContextRef ctx = ::darwinToCGContextRef(viewport);
Assert(VALID_PTR(ctx));
/* Flip the context */
CGContextTranslateCTM(ctx, 0, viewRect.size.height);
CGContextScaleCTM(ctx, 1.0, -1.0);
/* We handle the seamless mode as a special case. */
if (m_pMachineView->machineLogic()->visualStateType() == UIVisualStateType_Seamless)
{
/* Determine current visible region: */
RegionRects *pRgnRcts = ASMAtomicXchgPtrT(&mRegion, NULL, RegionRects*);
/* Prepare cleanup-region: */
QRegion cleanupRegion(aEvent->rect());
/* Filter out visible-rectangles;
* That way we erase *only* invisible-rectangles of paint-region: */
if (pRgnRcts && pRgnRcts->used > 0)
{
/* Slowly, step-by-step filter our visible-rectangles: */
CGRect *pCgVisibleRect = pRgnRcts->rcts;
for (ULONG uVisibleRectIndex = 0; uVisibleRectIndex < pRgnRcts->used; ++uVisibleRectIndex)
{
/* Prepare Qt visible-rectangle, flipping received CG visible-rectangle: */
CGRect cgVisibleRectFlippedToQt = ::darwinFlipCGRect(*pCgVisibleRect, viewRect.size.height);
QRect visibleRect(cgVisibleRectFlippedToQt.origin.x, cgVisibleRectFlippedToQt.origin.y,
cgVisibleRectFlippedToQt.size.width, cgVisibleRectFlippedToQt.size.height);
/* Filter that rectangle out: */
cleanupRegion -= visibleRect;
++pCgVisibleRect;
}
}
/* Erase cleanup-region: */
if (!cleanupRegion.isEmpty())
{
/* Slowly, step-by-step erase cleanup-rectangles: */
foreach (const QRect &cleanupRect, cleanupRegion.rects())
{
CGRect cgCleanupRect = ::darwinToCGRect(cleanupRect);
CGContextClearRect(ctx, ::darwinFlipCGRect(cgCleanupRect, viewRect.size.height));
}
}
DoubleRect VisualViewport::visibleContentRectDouble(IncludeScrollbarsInRect) const
{
return visibleRect();
}
void TiledBackingStore::removeAllNonVisibleTiles()
{
setKeepRect(visibleRect());
}
void TiledBackingStore::createTiles()
{
// Guard here as as these can change before the timer fires.
if (isBackingStoreUpdatesSuspended())
return;
// Update our backing store geometry.
const IntRect previousRect = m_rect;
m_rect = mapFromContents(m_client->tiledBackingStoreContentsRect());
m_trajectoryVector = m_pendingTrajectoryVector;
m_visibleRect = visibleRect();
if (m_rect.isEmpty()) {
setCoverRect(IntRect());
setKeepRect(IntRect());
return;
}
/* We must compute cover and keep rects using the visibleRect, instead of the rect intersecting the visibleRect with m_rect,
* because TBS can be used as a backing store of GraphicsLayer and the visible rect usually does not intersect with m_rect.
* In the below case, the intersecting rect is an empty.
*
* +---------------+
* | |
* | m_rect |
* | +-------|-----------------------+
* | | HERE | cover or keep |
* +---------------+ rect |
* | +---------+ |
* | | visible | |
* | | rect | |
* | +---------+ |
* | |
* | |
* +-------------------------------+
*
* We must create or keep the tiles in the HERE region.
*/
IntRect coverRect;
IntRect keepRect;
computeCoverAndKeepRect(m_visibleRect, coverRect, keepRect);
setCoverRect(coverRect);
setKeepRect(keepRect);
if (coverRect.isEmpty())
return;
// Resize tiles at the edge in case the contents size has changed, but only do so
// after having dropped tiles outside the keep rect.
bool didResizeTiles = false;
if (previousRect != m_rect)
didResizeTiles = resizeEdgeTiles();
// Search for the tile position closest to the viewport center that does not yet contain a tile.
// Which position is considered the closest depends on the tileDistance function.
double shortestDistance = std::numeric_limits<double>::infinity();
Vector<Tile::Coordinate> tilesToCreate;
unsigned requiredTileCount = 0;
// Cover areas (in tiles) with minimum distance from the visible rect. If the visible rect is
// not covered already it will be covered first in one go, due to the distance being 0 for tiles
// inside the visible rect.
Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coverRect));
for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
if (tileAt(currentCoordinate))
continue;
++requiredTileCount;
double distance = tileDistance(m_visibleRect, currentCoordinate);
if (distance > shortestDistance)
continue;
if (distance < shortestDistance) {
tilesToCreate.clear();
shortestDistance = distance;
}
tilesToCreate.append(currentCoordinate);
}
}
// Now construct the tile(s) within the shortest distance.
unsigned tilesToCreateCount = tilesToCreate.size();
for (unsigned n = 0; n < tilesToCreateCount; ++n) {
Tile::Coordinate coordinate = tilesToCreate[n];
setTile(coordinate, m_backend->createTile(this, coordinate));
}
requiredTileCount -= tilesToCreateCount;
// Paint the content of the newly created tiles or resized tiles.
if (tilesToCreateCount || didResizeTiles)
updateTileBuffers();
// Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
m_pendingTileCreation = requiredTileCount;
if (m_pendingTileCreation) {
if (!m_commitTileUpdatesOnIdleEventLoop) {
m_client->tiledBackingStoreHasPendingTileCreation();
return;
}
static const double tileCreationDelay = 0.01;
startBackingStoreUpdateTimer(tileCreationDelay);
}
}
bool TiledBackingStore::visibleAreaIsCovered() const
{
return coverageRatio(visibleRect()) == 1.0f;
}
int
createVirtualDisplay() {
uint32_t sourceWidth, sourceHeight;
uint32_t targetWidth, targetHeight;
android::status_t err;
switch (mDesiredOrientation) {
case Minicap::ORIENTATION_90:
sourceWidth = mRealHeight;
sourceHeight = mRealWidth;
targetWidth = mDesiredHeight;
targetHeight = mDesiredWidth;
break;
case Minicap::ORIENTATION_270:
sourceWidth = mRealHeight;
sourceHeight = mRealWidth;
targetWidth = mDesiredHeight;
targetHeight = mDesiredWidth;
break;
case Minicap::ORIENTATION_180:
sourceWidth = mRealWidth;
sourceHeight = mRealHeight;
targetWidth = mDesiredWidth;
targetHeight = mDesiredHeight;
break;
case Minicap::ORIENTATION_0:
default:
sourceWidth = mRealWidth;
sourceHeight = mRealHeight;
targetWidth = mDesiredWidth;
targetHeight = mDesiredHeight;
break;
}
// Set up virtual display size.
android::Rect layerStackRect(sourceWidth, sourceHeight);
android::Rect visibleRect(targetWidth, targetHeight);
// Create a Surface for the virtual display to write to.
MCINFO("Creating SurfaceComposerClient");
android::sp<android::SurfaceComposerClient> sc = new android::SurfaceComposerClient();
MCINFO("Performing SurfaceComposerClient init check");
if ((err = sc->initCheck()) != android::NO_ERROR) {
MCERROR("Unable to initialize SurfaceComposerClient");
return err;
}
// Create virtual display.
MCINFO("Creating virtual display");
mVirtualDisplay = android::SurfaceComposerClient::createDisplay(
/* const String8& displayName */ android::String8("minicap"),
/* bool secure */ true
);
MCINFO("Creating buffer queue");
android::BufferQueue::createBufferQueue(&mBufferProducer, &mBufferConsumer);
mBufferConsumer->setDefaultBufferSize(targetWidth, targetHeight);
mBufferConsumer->setDefaultBufferFormat(android::PIXEL_FORMAT_RGBA_8888);
MCINFO("Creating CPU consumer");
mConsumer = new android::CpuConsumer(mBufferConsumer, 3, false);
mConsumer->setName(android::String8("minicap"));
MCINFO("Creating frame waiter");
mFrameProxy = new FrameProxy(mUserFrameAvailableListener);
mConsumer->setFrameAvailableListener(mFrameProxy);
MCINFO("Publishing virtual display");
android::SurfaceComposerClient::openGlobalTransaction();
android::SurfaceComposerClient::setDisplaySurface(mVirtualDisplay, mBufferProducer);
android::SurfaceComposerClient::setDisplayProjection(mVirtualDisplay,
android::DISPLAY_ORIENTATION_0, layerStackRect, visibleRect);
android::SurfaceComposerClient::setDisplayLayerStack(mVirtualDisplay, 0); // default stack
android::SurfaceComposerClient::closeGlobalTransaction();
mHaveRunningDisplay = true;
return 0;
}
void HorizontalView::updateTransformation()
{
QRectF sceneRect = scene()->sceneRect();
QRectF visibleRect(_viewStart, sceneRect.top(), _viewEnd - _viewStart, sceneRect.height());
fitInView(visibleRect);
}
IntPoint PinchViewport::maximumScrollPosition() const
{
return flooredIntPoint(FloatSize(contentsSize()) - visibleRect().size());
}
bool DocumentWidget::isVisible()
{
QRect visibleRect(scrollView->contentsX(), scrollView->contentsY(), scrollView->visibleWidth(), scrollView->visibleHeight());
QRect widgetRect(scrollView->childX(this), scrollView->childY(this), width(), height());
return widgetRect.intersects(visibleRect);
}
