PathItem *PathView::addRoute(const Route &route) { if (route.isNull()) { _palette.nextColor(); return 0; } RouteItem *ri = new RouteItem(route); _routes.append(ri); _rr |= ri->path().boundingRect(); _zoom = scale2zoom(contentsScale()); ri->setScale(1.0/mapScale(_zoom)); ri->setColor(_palette.nextColor()); ri->setWidth(_routeWidth); ri->setStyle(_routeStyle); ri->setVisible(_showRoutes); ri->showWaypoints(_showRouteWaypoints); ri->showWaypointLabels(_showWaypointLabels); _scene->addItem(ri); if (_poi) addPOI(_poi->points(ri)); return ri; }
void PathView::addWaypoints(const QList<Waypoint> &waypoints) { qreal scale = mapScale(_zoom); for (int i = 0; i < waypoints.count(); i++) { const Waypoint &w = waypoints.at(i); WaypointItem *wi = new WaypointItem(w); wi->setScale(1.0/scale); wi->setZValue(1); wi->showLabel(_showWaypointLabels); wi->setVisible(_showWaypoints); _scene->addItem(wi); if (_wr.isNull()) { if (_wp.isNull()) _wp = wi->coordinates(); else _wr = qrectf(_wp, wi->coordinates()); } else unite(_wr, wi->coordinates()); _waypoints.append(wi); } if (_poi) addPOI(_poi->points(waypoints)); _zoom = scale2zoom(contentsScale()); }
/*! \qmlmethod bool WebView::heuristicZoom(int clickX, int clickY, real maxzoom) Finds a zoom that: \list \li shows a whole item \li includes (\a clickX, \a clickY) \li fits into the preferredWidth and preferredHeight \li zooms by no more than \a maxZoom \li is more than 10% above the current zoom \endlist If such a zoom exists, emits zoomTo(zoom,centerX,centerY) and returns true; otherwise, no signal is emitted and returns false. */ bool QDeclarativeWebView::heuristicZoom(int clickX, int clickY, qreal maxZoom) { if (contentsScale() >= maxZoom / scale()) return false; qreal ozf = contentsScale(); QRect showArea = elementAreaAt(clickX, clickY, d->preferredwidth / maxZoom, d->preferredheight / maxZoom); qreal z = qMin(qreal(d->preferredwidth) / showArea.width(), qreal(d->preferredheight) / showArea.height()); if (z > maxZoom / scale()) z = maxZoom / scale(); if (z / ozf > 1.2) { QRectF r(showArea.left() * z, showArea.top() * z, showArea.width() * z, showArea.height() * z); emit zoomTo(z, r.x() + r.width() / 2, r.y() + r.height() / 2); return true; } return false; }
void GraphicsLayerChromium::updateContentsScale() { // If page scale is already applied then there's no need to apply it again. if (appliesPageScale() || !m_layer) return; m_layer->setContentsScale(contentsScale()); }
void TiledLayerChromium::setNeedsDisplayRect(const FloatRect& dirtyRect) { FloatRect scaledDirtyRect(dirtyRect); scaledDirtyRect.scale(contentsScale()); IntRect dirty = enclosingIntRect(scaledDirtyRect); invalidateRect(dirty); LayerChromium::setNeedsDisplayRect(dirtyRect); }
void GraphicsLayerChromium::updateLayerPreserves3D() { if (m_preserves3D && m_transformLayer.isNull()) { // Create the transform layer. m_transformLayer = WebLayer::create(); m_transformLayer.setPreserves3D(true); m_transformLayer.setAnimationDelegate(this); m_layer.transferAnimationsTo(&m_transformLayer); // Copy the position from this layer. updateLayerPosition(); updateLayerSize(); updateAnchorPoint(); updateTransform(); updateChildrenTransform(); m_layer.setPosition(FloatPoint::zero()); m_layer.setAnchorPoint(FloatPoint(0.5f, 0.5f)); m_layer.setTransform(SkMatrix44()); // Set the old layer to opacity of 1. Further down we will set the opacity on the transform layer. m_layer.setOpacity(1); m_layer.setContentsScale(contentsScale()); // Move this layer to be a child of the transform layer. if (!m_layer.parent().isNull()) m_layer.parent().replaceChild(m_layer, m_transformLayer); m_transformLayer.addChild(m_layer); updateChildList(); } else if (!m_preserves3D && !m_transformLayer.isNull()) { // Relace the transformLayer in the parent with this layer. m_layer.removeFromParent(); if (!m_transformLayer.parent().isNull()) m_transformLayer.parent().replaceChild(m_transformLayer, m_layer); m_layer.setAnimationDelegate(this); m_transformLayer.transferAnimationsTo(&m_layer); // Release the transform layer. m_transformLayer.setAnimationDelegate(0); m_transformLayer.reset(); updateLayerPosition(); updateLayerSize(); updateAnchorPoint(); updateTransform(); updateChildrenTransform(); updateChildList(); } m_layer.setPreserves3D(m_preserves3D); primaryLayer().setOpacity(m_opacity); updateNames(); }
void PathView::rescale() { int zoom = scale2zoom(contentsScale()); if (zoom != _zoom) { rescale(zoom); _mapScale->setZoom(zoom); } }
void GraphicsLayerChromium::updateLayerPreserves3D() { if (m_preserves3D && !m_transformLayer) { // Create the transform layer. m_transformLayer = LayerChromium::create(); m_transformLayer->setPreserves3D(true); m_transformLayer->setLayerAnimationDelegate(this); // Copy the position from this layer. updateLayerPosition(); updateLayerSize(); updateAnchorPoint(); updateTransform(); updateChildrenTransform(); m_layer->setPosition(FloatPoint(m_size.width() / 2.0f, m_size.height() / 2.0f)); m_layer->setAnchorPoint(FloatPoint(0.5f, 0.5f)); TransformationMatrix identity; m_layer->setTransform(identity); // Set the old layer to opacity of 1. Further down we will set the opacity on the transform layer. m_layer->setOpacity(1); m_layer->setContentsScale(contentsScale()); // Move this layer to be a child of the transform layer. if (m_layer->parent()) m_layer->parent()->replaceChild(m_layer.get(), m_transformLayer.get()); m_transformLayer->addChild(m_layer.get()); updateChildList(); } else if (!m_preserves3D && m_transformLayer) { // Relace the transformLayer in the parent with this layer. m_layer->removeFromParent(); if (m_transformLayer->parent()) m_transformLayer->parent()->replaceChild(m_transformLayer.get(), m_layer.get()); // Release the transform layer. m_transformLayer->setLayerAnimationDelegate(0); m_transformLayer = 0; updateLayerPosition(); updateLayerSize(); updateAnchorPoint(); updateTransform(); updateChildrenTransform(); updateChildList(); } m_layer->setPreserves3D(m_preserves3D); primaryLayer()->setOpacity(m_opacity); updateNames(); }
int QDeclarativePaintedItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QDeclarativeItem::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 5) qt_static_metacall(this, _c, _id, _a); _id -= 5; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< QSize*>(_v) = contentsSize(); break; case 1: *reinterpret_cast< QColor*>(_v) = fillColor(); break; case 2: *reinterpret_cast< int*>(_v) = pixelCacheSize(); break; case 3: *reinterpret_cast< bool*>(_v) = smoothCache(); break; case 4: *reinterpret_cast< qreal*>(_v) = contentsScale(); break; } _id -= 5; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setContentsSize(*reinterpret_cast< QSize*>(_v)); break; case 1: setFillColor(*reinterpret_cast< QColor*>(_v)); break; case 2: setPixelCacheSize(*reinterpret_cast< int*>(_v)); break; case 3: setSmoothCache(*reinterpret_cast< bool*>(_v)); break; case 4: setContentsScale(*reinterpret_cast< qreal*>(_v)); break; } _id -= 5; } else if (_c == QMetaObject::ResetProperty) { _id -= 5; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 5; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 5; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 5; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 5; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 5; } #endif // QT_NO_PROPERTIES return _id; }
PathItem *PathView::addTrack(const Track &track) { if (track.isNull()) { _palette.nextColor(); return 0; } TrackItem *ti = new TrackItem(track); _tracks.append(ti); _tr |= ti->path().boundingRect(); _zoom = scale2zoom(contentsScale()); ti->setScale(1.0/mapScale(_zoom)); ti->setColor(_palette.nextColor()); ti->setWidth(_trackWidth); ti->setStyle(_trackStyle); ti->setVisible(_showTracks); _scene->addItem(ti); if (_poi) addPOI(_poi->points(ti)); return ti; }
QSize QDeclarativeWebView::contentsSize() const { return page()->mainFrame()->contentsSize() * contentsScale(); }
void QDeclarativeWebView::updateDeclarativeWebViewSize() { QSizeF size = d->view->geometry().size() * contentsScale(); setImplicitWidth(size.width()); setImplicitHeight(size.height()); }
void TiledLayerChromium::prepareToUpdateTiles(bool idle, int left, int top, int right, int bottom, const CCOcclusionTracker* occlusion) { createTextureUpdaterIfNeeded(); // Create tiles as needed, expanding a dirty rect to contain all // the dirty regions currently being drawn. All dirty tiles that are to be painted // get their m_updateRect set to m_dirtyRect and m_dirtyRect cleared. This way if // invalidateRect is invoked during prepareToUpdate we don't lose the request. IntRect dirtyLayerRect; for (int j = top; j <= bottom; ++j) { for (int i = left; i <= right; ++i) { UpdatableTile* tile = tileAt(i, j); if (!tile) tile = createTile(i, j); // When not idle painting, if the visible region of the tile is occluded, don't reserve a texture or mark it for update. // If any part of the tile is visible, then we need to paint it so the tile is pushed to the impl thread. // This will also avoid painting the tile in the next loop, below. if (!idle && occlusion) { IntRect visibleTileRect = intersection(m_tiler->tileBounds(i, j), visibleLayerRect()); if (occlusion->occluded(this, visibleTileRect)) continue; } // FIXME: Decide if partial update should be allowed based on cost // of update. https://bugs.webkit.org/show_bug.cgi?id=77376 if (tileOnlyNeedsPartialUpdate(tile) && layerTreeHost() && layerTreeHost()->requestPartialTextureUpdate()) tile->m_partialUpdate = true; else if (tileNeedsBufferedUpdate(tile) && layerTreeHost()) layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal()); if (!tile->managedTexture()->isValid(m_tiler->tileSize(), m_textureFormat)) { // Sets the dirty rect to a full-sized tile with border texels. tile->m_dirtyRect = m_tiler->tileRect(tile); } if (!tile->managedTexture()->reserve(m_tiler->tileSize(), m_textureFormat)) { m_skipsIdlePaint = true; if (!idle) { // If the background covers the viewport, always draw this // layer so that checkerboarded tiles will still draw. if (!backgroundCoversViewport()) m_skipsDraw = true; m_tiler->reset(); m_paintRect = IntRect(); m_requestedUpdateTilesRect = IntRect(); } return; } dirtyLayerRect.unite(tile->m_dirtyRect); tile->copyAndClearDirty(); } } m_paintRect = dirtyLayerRect; if (dirtyLayerRect.isEmpty()) return; // Due to borders, when the paint rect is extended to tile boundaries, it // may end up overlapping more tiles than the original content rect. Record // the original tiles so we don't upload more tiles than necessary. if (!m_paintRect.isEmpty()) m_requestedUpdateTilesRect = IntRect(left, top, right - left + 1, bottom - top + 1); // Calling prepareToUpdate() calls into WebKit to paint, which may have the side // effect of disabling compositing, which causes our reference to the texture updater to be deleted. // However, we can't free the memory backing the GraphicsContext until the paint finishes, // so we grab a local reference here to hold the updater alive until the paint completes. RefPtr<LayerTextureUpdater> protector(textureUpdater()); IntRect paintedOpaqueRect; textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &paintedOpaqueRect); for (int j = top; j <= bottom; ++j) { for (int i = left; i <= right; ++i) { UpdatableTile* tile = tileAt(i, j); // Tiles are created before prepareToUpdate() is called. if (!tile) CRASH(); IntRect tileRect = m_tiler->tileBounds(i, j); // Use m_updateRect as copyAndClearDirty above moved the existing dirty rect to m_updateRect if the tile isn't culled. const IntRect& dirtyRect = tile->m_updateRect; if (dirtyRect.isEmpty()) continue; // Save what was painted opaque in the tile. Keep the old area if the paint didn't touch it, and didn't paint some // other part of the tile opaque. IntRect tilePaintedRect = intersection(tileRect, m_paintRect); IntRect tilePaintedOpaqueRect = intersection(tileRect, paintedOpaqueRect); if (!tilePaintedRect.isEmpty()) { IntRect paintInsideTileOpaqueRect = intersection(tile->opaqueRect(), tilePaintedRect); bool paintInsideTileOpaqueRectIsNonOpaque = !tilePaintedOpaqueRect.contains(paintInsideTileOpaqueRect); bool opaquePaintNotInsideTileOpaqueRect = !tilePaintedOpaqueRect.isEmpty() && !tile->opaqueRect().contains(tilePaintedOpaqueRect); if (paintInsideTileOpaqueRectIsNonOpaque || opaquePaintNotInsideTileOpaqueRect) tile->setOpaqueRect(tilePaintedOpaqueRect); } // sourceRect starts as a full-sized tile with border texels included. IntRect sourceRect = m_tiler->tileRect(tile); sourceRect.intersect(dirtyRect); // Paint rect not guaranteed to line up on tile boundaries, so // make sure that sourceRect doesn't extend outside of it. sourceRect.intersect(m_paintRect); tile->m_updateRect = sourceRect; if (sourceRect.isEmpty()) continue; tile->texture()->prepareRect(sourceRect); } } }
IntSize TiledLayerChromium::contentBounds() const { return IntSize(lroundf(bounds().width() * contentsScale()), lroundf(bounds().height() * contentsScale())); }
void TiledDrawingAreaProxy::requestTileUpdate(int tileID, const IntRect& dirtyRect) { page()->process()->connection()->send(DrawingAreaLegacyMessage::RequestTileUpdate, page()->pageID(), CoreIPC::In(tileID, dirtyRect, contentsScale())); }
void TiledLayerChromium::prepareToUpdateTiles(bool idle, int left, int top, int right, int bottom) { // Reset m_updateRect for all tiles. for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) { UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get()); tile->m_updateRect = IntRect(); } // Create tiles as needed, expanding a dirty rect to contain all // the dirty regions currently being drawn. All dirty tiles that are to be painted // get their m_updateRect set to m_dirtyRect and m_dirtyRect cleared. This way if // invalidateRect is invoked during prepareToUpdate we don't lose the request. IntRect dirtyLayerRect; for (int j = top; j <= bottom; ++j) { for (int i = left; i <= right; ++i) { UpdatableTile* tile = tileAt(i, j); if (!tile) tile = createTile(i, j); // Do post commit deletion of current texture when partial texture // updates are not used. if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialTextureUpdates) layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal()); if (!tile->managedTexture()->isValid(m_tiler->tileSize(), m_textureFormat)) tile->m_dirtyRect = m_tiler->tileRect(tile); if (!tile->managedTexture()->reserve(m_tiler->tileSize(), m_textureFormat)) { m_skipsIdlePaint = true; if (!idle) { m_skipsDraw = true; cleanupResources(); } return; } dirtyLayerRect.unite(tile->m_dirtyRect); tile->copyAndClearDirty(); } } m_paintRect = dirtyLayerRect; if (dirtyLayerRect.isEmpty()) return; // Due to borders, when the paint rect is extended to tile boundaries, it // may end up overlapping more tiles than the original content rect. Record // the original tiles so we don't upload more tiles than necessary. if (!m_paintRect.isEmpty()) m_requestedUpdateTilesRect = IntRect(left, top, right - left + 1, bottom - top + 1); // Calling prepareToUpdate() calls into WebKit to paint, which may have the side // effect of disabling compositing, which causes our reference to the texture updater to be deleted. // However, we can't free the memory backing the GraphicsContext until the paint finishes, // so we grab a local reference here to hold the updater alive until the paint completes. RefPtr<LayerTextureUpdater> protector(textureUpdater()); IntRect opaqueRect; // FIXME: unused. remove this and store in the layer to pass to impl for draw culling textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &opaqueRect); for (int j = top; j <= bottom; ++j) { for (int i = left; i <= right; ++i) { UpdatableTile* tile = tileAt(i, j); // Tiles are created before prepareToUpdate() is called. if (!tile) CRASH(); // Use m_updateRect as copyAndClearDirty above moved the existing dirty rect to m_updateRect. const IntRect& dirtyRect = tile->m_updateRect; if (dirtyRect.isEmpty()) continue; IntRect sourceRect = m_tiler->tileRect(tile); sourceRect.intersect(dirtyRect); // Paint rect not guaranteed to line up on tile boundaries, so // make sure that sourceRect doesn't extend outside of it. sourceRect.intersect(m_paintRect); tile->m_updateRect = sourceRect; if (sourceRect.isEmpty()) continue; tile->texture()->prepareRect(sourceRect); } } }