Exemplo n.º 1
0
void GfxCanvasText::paint(GfxPainter &p)
{
    if(_img.isNull())
        return;

    qreal op = p.opacity();
    p.setOpacity(op * layerVisible());

    QSize _s = _img.size();
    QPoint point = getImgPoint();
    if(1. != layerScale()) {
        QMatrix m;
        m.translate(layerX(), layerY());
        m.scale(layerScale(), layerScale());
        m.translate(-_size.width() / 2, -_size.height() / 2);
        m.translate(point.x(), point.y());
        p.drawImageTransformed(m, _img, quality().value() != 0.);
    } else {
        p.drawImage(int(layerX()) + point.x() - _size.width() / 2, 
                    int(layerY()) + point.y() - _size.height() / 2, _img);
        if(gfx_show_image_bounds) {
            QRect r(int(layerX()) + point.x() - _size.width() / 2, 
                    int(layerY()) + point.y() - _size.height() / 2,
                    _img.width(),
                    _img.height());
            p.fillRect(r, QColor(0, 0, 255, 127));
        }
    }

    p.setOpacity(op);
    GfxCanvasItem::paint(p);
}
Exemplo n.º 2
0
void GfxCanvasImage::paint(GfxPainter &p)
{
    if(_img.isNull())
        return;

    qreal op = p.opacity();
    p.setOpacity(op * layerVisible());

    if(_rotate.value() || 1. != layerScale()) {
        QMatrix m;
        m.translate(layerX(), layerY());
        m.rotate(_rotate.value());
        m.scale(layerScale(), layerScale());
        m.translate(-_s.width() / 2, -_s.height() / 2);
        p.drawImageTransformed(m, _img, quality().value() != 0.);
    } else {
        if(subPixelPlacement()) {
            p.drawImage(qreal(layerX() - qreal(_s.width()) / 2.), 
                        int(layerY() - qreal(_s.height()) / 2.), _img);
        } else {
            p.drawImage(int(layerX() - qreal(_s.width()) / 2.), 
                        int(layerY() - qreal(_s.height()) / 2.), _img);
        }
        if(gfx_show_image_bounds) {
            QRect r(int(layerX() - qreal(_s.width()) / 2.), 
                    int(layerY() - qreal(_s.height()) / 2.),
                    _s.width(), _s.height());
            p.fillRect(r, QColor(0, 0, 255, 127));
        }
    }

    p.setOpacity(op);
    GfxCanvasItem::paint(p);
}
Exemplo n.º 3
0
QRect GfxCanvasImage::boundingRect()
{
    QMatrix m;
    m.translate(layerX(), layerY());
    m.rotate(_rotate.value());
    m.scale(layerScale(), layerScale());
    m.translate(-_s.width() / 2, -_s.height() / 2);
    QRect r(QPoint(0, 0), _s);
    r = m.mapRect(r);
    r.setX(r.x() - 1);
    r.setY(r.y() - 1);
    r.setWidth(r.width() + 2);
    r.setHeight(r.height() + 2);
    return r | GfxCanvasItem::boundingRect();;
}
Exemplo n.º 4
0
QRect GfxCanvasText::boundingRect()
{
    checkCache();
    if(_img.isNull())
        return QRect();

    QMatrix m;
    m.translate(layerX(), layerY());
    m.scale(layerScale(), layerScale());
    m.translate(-_size.width() / 2, -_size.height() / 2);
    QRect r(getImgPoint(), _img.size());
    r = m.mapRect(r);
    r.setX(r.x() - 1);
    r.setY(r.y() - 1);
    r.setWidth(r.width() + 2);
    r.setHeight(r.height() + 2);
    return r | GfxCanvasItem::boundingRect();;
}
Exemplo n.º 5
0
void GfxCanvasColor::paint(GfxPainter &p)
{
    qreal op = p.opacity();
    p.setOpacity(op * layerVisible());

    QSize s(int(_s.width() * layerScale()), int(_s.height() * layerScale()));
    if(_rotate.value()) {
        QMatrix m;
        m.translate(layerX(), layerY());
        m.rotate(_rotate.value());
        m.translate(-s.width() / 2, -s.height() / 2);
        p.fillRectTransformed(m, s, color(), quality().value() != 0.);
    } else {
        p.fillRect(QRect(QPoint(int(layerX() - qreal(s.width()) / 2.), 
                                int(layerY() - qreal(s.height()) / 2.)), s), color());
    }

    p.setOpacity(op);
    GfxCanvasItem::paint(p);
}
Exemplo n.º 6
0
void GfxCanvasMipImage::paint(GfxPainter &p)
{
    if(_imgs.isEmpty() || scale().value() == 0.) return;

    qreal op = p.opacity();
    p.setOpacity(op * layerVisible());

    // Find correct image
    QSize s = layerScale() * _s;
    int imgNum;
    for(imgNum = 0; imgNum < _imgs.count(); ++imgNum) 
        if(_imgs.at(imgNum).width() >= s.width())
            break;
    if(imgNum == _imgs.count())
        imgNum = _imgs.count() - 1;


    const QImage &img = _imgs.at(imgNum);

    // Adjust zoom
    qreal zoom =  qreal(s.width()) / qreal(img.width());
    qreal rotate = _rotate.value();

    int x = int(layerX());
    int y = int(layerY());
    if(zoom == 1. && rotate == 0.) {
        if(subPixelPlacement()) {
            p.drawImage(qreal(layerX() - qreal(s.width()) / 2.), 
                        int(layerY() - qreal(s.height()) / 2.), img);
        } else {
            p.drawImage(x - s.width() / 2, y - s.height() / 2, img);
        }

        if(gfx_show_mip_matches) {
            QRect r(x - s.width() / 2, y - s.height() / 2, s.width(), s.height());
            p.fillRect(r, QColor(255, 0, 0, 127));
        }
    } else {
        QMatrix m;
        m.translate(x, y);
        if(rotate)
            m.rotate(rotate);
        if(zoom != 1.)
            m.scale(zoom, zoom);
        m.translate(-img.width() / 2, -img.height() / 2);
        p.drawImageTransformed(m, img, _quality.value() != 0.);
    }

    p.setOpacity(op);
    GfxCanvasItem::paint(p);
}
Exemplo n.º 7
0
void
TiledContentHost::RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
                                    const nsIntRegion& aValidRegion,
                                    EffectChain& aEffectChain,
                                    float aOpacity,
                                    const gfx::Point& aOffset,
                                    const gfx::Filter& aFilter,
                                    const gfx::Rect& aClipRect,
                                    const nsIntRegion& aMaskRegion,
                                    nsIntRect aVisibleRect,
                                    gfx::Matrix4x4 aTransform)
{
  float resolution = aLayerBuffer.GetResolution();
  gfxSize layerScale(1, 1);
  // We assume that the current frame resolution is the one used in our primary
  // layer buffer. Compensate for a changing frame resolution.
  if (aLayerBuffer.GetFrameResolution() != mVideoMemoryTiledBuffer.GetFrameResolution()) {
    const gfxSize& layerResolution = aLayerBuffer.GetFrameResolution();
    const gfxSize& localResolution = mVideoMemoryTiledBuffer.GetFrameResolution();
    layerScale.width = layerResolution.width / localResolution.width;
    layerScale.height = layerResolution.height / localResolution.height;
    aVisibleRect.ScaleRoundOut(layerScale.width, layerScale.height);
  }
  aTransform.Scale(1/(resolution * layerScale.width),
                   1/(resolution * layerScale.height), 1);

  uint32_t rowCount = 0;
  uint32_t tileX = 0;
  for (int32_t x = aVisibleRect.x; x < aVisibleRect.x + aVisibleRect.width;) {
    rowCount++;
    int32_t tileStartX = aLayerBuffer.GetTileStart(x);
    int32_t w = aLayerBuffer.GetScaledTileLength() - tileStartX;
    if (x + w > aVisibleRect.x + aVisibleRect.width) {
      w = aVisibleRect.x + aVisibleRect.width - x;
    }
    int tileY = 0;
    for (int32_t y = aVisibleRect.y; y < aVisibleRect.y + aVisibleRect.height;) {
      int32_t tileStartY = aLayerBuffer.GetTileStart(y);
      int32_t h = aLayerBuffer.GetScaledTileLength() - tileStartY;
      if (y + h > aVisibleRect.y + aVisibleRect.height) {
        h = aVisibleRect.y + aVisibleRect.height - y;
      }

      TiledTexture tileTexture = aLayerBuffer.
        GetTile(nsIntPoint(aLayerBuffer.RoundDownToTileEdge(x),
                           aLayerBuffer.RoundDownToTileEdge(y)));
      if (tileTexture != aLayerBuffer.GetPlaceholderTile()) {
        nsIntRegion tileDrawRegion;
        tileDrawRegion.And(aValidRegion,
                           nsIntRect(x * layerScale.width,
                                     y * layerScale.height,
                                     w * layerScale.width,
                                     h * layerScale.height));
        tileDrawRegion.Sub(tileDrawRegion, aMaskRegion);

        if (!tileDrawRegion.IsEmpty()) {
          tileDrawRegion.ScaleRoundOut(resolution / layerScale.width,
                                       resolution / layerScale.height);

          nsIntPoint tileOffset((x - tileStartX) * resolution,
                                (y - tileStartY) * resolution);
          uint32_t tileSize = aLayerBuffer.GetTileLength();
          RenderTile(tileTexture, aEffectChain, aOpacity, aTransform, aOffset, aFilter, aClipRect, tileDrawRegion,
                     tileOffset, nsIntSize(tileSize, tileSize));
        }
      }
      tileY++;
      y += h;
    }
    tileX++;
    x += w;
  }
}
Exemplo n.º 8
0
void
TiledContentHost::RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
                                    const gfxRGBA* aBackgroundColor,
                                    EffectChain& aEffectChain,
                                    float aOpacity,
                                    const gfx::Filter& aFilter,
                                    const gfx::Rect& aClipRect,
                                    nsIntRegion aVisibleRegion,
                                    gfx::Matrix4x4 aTransform)
{
  if (!mCompositor) {
    NS_WARNING("Can't render tiled content host - no compositor");
    return;
  }
  float resolution = aLayerBuffer.GetResolution();
  gfx::Size layerScale(1, 1);

  // We assume that the current frame resolution is the one used in our high
  // precision layer buffer. Compensate for a changing frame resolution when
  // rendering the low precision buffer.
  if (aLayerBuffer.GetFrameResolution() != mTiledBuffer.GetFrameResolution()) {
    const CSSToParentLayerScale& layerResolution = aLayerBuffer.GetFrameResolution();
    const CSSToParentLayerScale& localResolution = mTiledBuffer.GetFrameResolution();
    layerScale.width = layerScale.height = layerResolution.scale / localResolution.scale;
    aVisibleRegion.ScaleRoundOut(layerScale.width, layerScale.height);
  }

  // If we're drawing the low precision buffer, make sure the high precision
  // buffer is masked out to avoid overdraw and rendering artifacts with
  // non-opaque layers.
  nsIntRegion maskRegion;
  if (resolution != mTiledBuffer.GetResolution()) {
    maskRegion = mTiledBuffer.GetValidRegion();
    // XXX This should be ScaleRoundIn, but there is no such function on
    //     nsIntRegion.
    maskRegion.ScaleRoundOut(layerScale.width, layerScale.height);
  }

  // Make sure the resolution and difference in frame resolution are accounted
  // for in the layer transform.
  aTransform.PreScale(1/(resolution * layerScale.width),
                      1/(resolution * layerScale.height), 1);

  uint32_t rowCount = 0;
  uint32_t tileX = 0;
  nsIntRect visibleRect = aVisibleRegion.GetBounds();
  gfx::IntSize scaledTileSize = aLayerBuffer.GetScaledTileSize();
  for (int32_t x = visibleRect.x; x < visibleRect.x + visibleRect.width;) {
    rowCount++;
    int32_t tileStartX = aLayerBuffer.GetTileStart(x, scaledTileSize.width);
    int32_t w = scaledTileSize.width - tileStartX;
    if (x + w > visibleRect.x + visibleRect.width) {
      w = visibleRect.x + visibleRect.width - x;
    }
    int tileY = 0;
    for (int32_t y = visibleRect.y; y < visibleRect.y + visibleRect.height;) {
      int32_t tileStartY = aLayerBuffer.GetTileStart(y, scaledTileSize.height);
      int32_t h = scaledTileSize.height - tileStartY;
      if (y + h > visibleRect.y + visibleRect.height) {
        h = visibleRect.y + visibleRect.height - y;
      }

      TileHost tileTexture = aLayerBuffer.
        GetTile(nsIntPoint(aLayerBuffer.RoundDownToTileEdge(x, scaledTileSize.width),
                           aLayerBuffer.RoundDownToTileEdge(y, scaledTileSize.height)));
      if (tileTexture != aLayerBuffer.GetPlaceholderTile()) {
        nsIntRegion tileDrawRegion;
        tileDrawRegion.And(nsIntRect(x, y, w, h), aLayerBuffer.GetValidRegion());
        tileDrawRegion.And(tileDrawRegion, aVisibleRegion);
        tileDrawRegion.Sub(tileDrawRegion, maskRegion);

        if (!tileDrawRegion.IsEmpty()) {
          tileDrawRegion.ScaleRoundOut(resolution, resolution);
          nsIntPoint tileOffset((x - tileStartX) * resolution,
                                (y - tileStartY) * resolution);
          gfx::IntSize tileSize = aLayerBuffer.GetTileSize();
          RenderTile(tileTexture, aBackgroundColor, aEffectChain, aOpacity, aTransform,
                     aFilter, aClipRect, tileDrawRegion, tileOffset,
                     nsIntSize(tileSize.width, tileSize.height));
        }
      }
      tileY++;
      y += h;
    }
    tileX++;
    x += w;
  }
  gfx::Rect rect(visibleRect.x, visibleRect.y,
                 visibleRect.width, visibleRect.height);
  GetCompositor()->DrawDiagnostics(DiagnosticFlags::CONTENT,
                                   rect, aClipRect, aTransform, mFlashCounter);
}
Exemplo n.º 9
0
void
TiledContentHost::RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
                                    const gfxRGBA* aBackgroundColor,
                                    EffectChain& aEffectChain,
                                    float aOpacity,
                                    const gfx::Filter& aFilter,
                                    const gfx::Rect& aClipRect,
                                    nsIntRegion aVisibleRegion,
                                    gfx::Matrix4x4 aTransform)
{
  if (!mCompositor) {
    NS_WARNING("Can't render tiled content host - no compositor");
    return;
  }
  float resolution = aLayerBuffer.GetResolution();
  gfx::Size layerScale(1, 1);

  // We assume that the current frame resolution is the one used in our high
  // precision layer buffer. Compensate for a changing frame resolution when
  // rendering the low precision buffer.
  if (aLayerBuffer.GetFrameResolution() != mTiledBuffer.GetFrameResolution()) {
    const CSSToParentLayerScale2D& layerResolution = aLayerBuffer.GetFrameResolution();
    const CSSToParentLayerScale2D& localResolution = mTiledBuffer.GetFrameResolution();
    layerScale.width = layerResolution.xScale / localResolution.xScale;
    layerScale.height = layerResolution.yScale / localResolution.yScale;
    aVisibleRegion.ScaleRoundOut(layerScale.width, layerScale.height);
  }

  // Make sure we don't render at low resolution where we have valid high
  // resolution content, to avoid overdraw and artifacts with semi-transparent
  // layers.
  nsIntRegion maskRegion;
  if (resolution != mTiledBuffer.GetResolution()) {
    maskRegion = mTiledBuffer.GetValidRegion();
    // XXX This should be ScaleRoundIn, but there is no such function on
    //     nsIntRegion.
    maskRegion.ScaleRoundOut(layerScale.width, layerScale.height);
  }

  // Make sure the resolution and difference in frame resolution are accounted
  // for in the layer transform.
  aTransform.PreScale(1/(resolution * layerScale.width),
                      1/(resolution * layerScale.height), 1);

  DiagnosticFlags componentAlphaDiagnostic = DiagnosticFlags::NO_DIAGNOSTIC;

  nsIntRegion compositeRegion = aLayerBuffer.GetValidRegion();
  compositeRegion.AndWith(aVisibleRegion);
  compositeRegion.SubOut(maskRegion);

  IntRect visibleRect = aVisibleRegion.GetBounds();

  if (compositeRegion.IsEmpty()) {
    return;
  }

  if (aBackgroundColor) {
    nsIntRegion backgroundRegion = compositeRegion;
    backgroundRegion.ScaleRoundOut(resolution, resolution);
    EffectChain effect;
    effect.mPrimaryEffect = new EffectSolidColor(ToColor(*aBackgroundColor));
    nsIntRegionRectIterator it(backgroundRegion);
    for (const IntRect* rect = it.Next(); rect != nullptr; rect = it.Next()) {
      Rect graphicsRect(rect->x, rect->y, rect->width, rect->height);
      mCompositor->DrawQuad(graphicsRect, aClipRect, effect, 1.0, aTransform);
    }
  }

  for (size_t i = 0; i < aLayerBuffer.GetTileCount(); ++i) {
    TileHost& tile = aLayerBuffer.GetTile(i);
    if (tile.IsPlaceholderTile()) {
      continue;
    }

    TileIntPoint tilePosition = aLayerBuffer.GetPlacement().TilePosition(i);
    // A sanity check that catches a lot of mistakes.
    MOZ_ASSERT(tilePosition.x == tile.mTilePosition.x && tilePosition.y == tile.mTilePosition.y);

    IntPoint tileOffset = aLayerBuffer.GetTileOffset(tilePosition);
    nsIntRegion tileDrawRegion = IntRect(tileOffset, aLayerBuffer.GetScaledTileSize());
    tileDrawRegion.AndWith(compositeRegion);

    if (tileDrawRegion.IsEmpty()) {
      continue;
    }

    tileDrawRegion.ScaleRoundOut(resolution, resolution);
    RenderTile(tile, aEffectChain, aOpacity,
               aTransform, aFilter, aClipRect, tileDrawRegion,
               tileOffset * resolution, aLayerBuffer.GetTileSize(),
               gfx::Rect(visibleRect.x, visibleRect.y,
                         visibleRect.width, visibleRect.height));
    if (tile.mTextureHostOnWhite) {
      componentAlphaDiagnostic = DiagnosticFlags::COMPONENT_ALPHA;
    }
  }

  gfx::Rect rect(visibleRect.x, visibleRect.y,
                 visibleRect.width, visibleRect.height);
  GetCompositor()->DrawDiagnostics(DiagnosticFlags::CONTENT | componentAlphaDiagnostic,
                                   rect, aClipRect, aTransform, mFlashCounter);
}