already_AddRefed<gfx::DrawTarget>
CompositorWidgetProxy::CreateBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect)
{
MOZ_ASSERT(aScreenTarget);
gfx::SurfaceFormat format = gfx::SurfaceFormat::B8G8R8A8;
gfx::IntSize size = aRect.ToUnknownRect().Size();
gfx::IntSize clientSize(GetClientSize().ToUnknownSize());
RefPtr<gfx::DrawTarget> target;
// Re-use back buffer if possible
if (mLastBackBuffer &&
mLastBackBuffer->GetBackendType() == aScreenTarget->GetBackendType() &&
mLastBackBuffer->GetFormat() == format &&
size <= mLastBackBuffer->GetSize() &&
mLastBackBuffer->GetSize() <= clientSize) {
target = mLastBackBuffer;
target->SetTransform(gfx::Matrix());
if (!aClearRect.IsEmpty()) {
gfx::IntRect clearRect = aClearRect.ToUnknownRect() - aRect.ToUnknownRect().TopLeft();
target->ClearRect(gfx::Rect(clearRect.x, clearRect.y, clearRect.width, clearRect.height));
}
} else {
target = aScreenTarget->CreateSimilarDrawTarget(size, format);
mLastBackBuffer = target;
}
return target.forget();
}
void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, CompositeOperator, const FloatRect& dstRect)
{
if (!m_source.initialized())
return;
#if USE(WXGC)
wxGCDC* context = (wxGCDC*)ctxt->platformContext();
#else
wxWindowDC* context = ctxt->platformContext();
#endif
ctxt->save();
ctxt->clip(IntRect(dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height()));
wxBitmap* bitmap = frameAtIndex(m_currentFrame);
if (!bitmap) // If it's too early we won't have an image yet.
return;
float currentW = 0;
float currentH = 0;
#if USE(WXGC)
wxGraphicsContext* gc = context->GetGraphicsContext();
gc->ConcatTransform(patternTransform);
#else
wxMemoryDC mydc;
mydc.SelectObject(*bitmap);
#endif
wxPoint origin(context->GetDeviceOrigin());
wxSize clientSize(context->GetSize());
while ( currentW < dstRect.width() && currentW < clientSize.x - origin.x ) {
while ( currentH < dstRect.height() && currentH < clientSize.y - origin.y) {
#if USE(WXGC)
gc->DrawBitmap(*bitmap, (wxDouble)dstRect.x() + currentW, (wxDouble)dstRect.y() + currentH, (wxDouble)srcRect.width(), (wxDouble)srcRect.height());
#else
context->Blit((wxCoord)dstRect.x() + currentW, (wxCoord)dstRect.y() + currentH,
(wxCoord)srcRect.width(), (wxCoord)srcRect.height(), &mydc,
(wxCoord)srcRect.x(), (wxCoord)srcRect.y(), wxCOPY, true);
#endif
currentH += srcRect.height();
}
currentW += srcRect.width();
currentH = 0;
}
ctxt->restore();
#if !USE(WXGC)
mydc.SelectObject(wxNullBitmap);
#endif
// NB: delete is causing crashes during page load, but not during the deletion
// itself. It occurs later on when a valid bitmap created in frameAtIndex
// suddenly becomes invalid after returning. It's possible these errors deal
// with reentrancy and threding problems.
//delete bitmap;
startAnimation();
}
Document* StyleSheetContents::clientSingleOwnerDocument() const {
if (!m_hasSingleOwnerDocument || clientSize() <= 0)
return nullptr;
if (m_loadingClients.size())
return (*m_loadingClients.begin())->ownerDocument();
return (*m_completedClients.begin())->ownerDocument();
}
qint64 ScrollBar::sliderValueFromPosition(int position, int span, bool upsideDown)
{
// fix client size using barsize
const int fix_client_size = qMax(clientSize() - span, 0);
const qint64 s_len = maximum_ - minimum_;
const double value_ratio = (double)position / (double)fix_client_size;
// position to value
return static_cast<qint64>(s_len * value_ratio);
}
// wxWindow's GetBestVirtualSize returns the actual window size,
// whereas we want to return the virtual size
wxSize wxScrolledWindow::GetBestVirtualSize() const
{
wxSize clientSize( GetClientSize() );
if (GetSizer())
{
wxSize minSize( GetSizer()->CalcMin() );
return wxSize( wxMax( clientSize.x, minSize.x ), wxMax( clientSize.y, minSize.y ) );
}
else
return clientSize;
}
int ScrollBar::drawBarSize() const
{
const int bar_size = base_size_ / 2;
const qint64 scroll_len = maximum_ - minimum_ + page_step_;
const double ratio = (double)page_step_ / scroll_len;
if (ratio <= 0 || ratio >= 1) {
return 0;
}
return qMax(static_cast<int>(clientSize() * ratio), bar_size);
}
int ScrollBar::sliderPositionFromValue(qint64 logicalValue, int span, bool upsideDown) const
{
// fix client size using barsize
const int fix_client_size = qMax(clientSize() - span, 0);
const qint64 s_len = maximum_ - minimum_;
const qint64 s_pos = maximum_ - minimum_ - logicalValue;
// calc ratio
const double screen_pos_ratio = (double)1 - ((double)s_pos / (double)s_len);
// value to position
return qMin(static_cast<int>(fix_client_size * screen_pos_ratio), fix_client_size);
}
void MyVideoCaptureWindow::DoPaint( wxPaintDC& dc )
{
wxVideoCaptureWindowBase::DoPaint(dc);
if (!IsDeviceConnected())
{
// The window is blank when disconnected so we might as well
// give a hint to people that they need to connect first.
wxBitmap bmp = wxArtProvider::GetBitmap(wxART_MISSING_IMAGE, wxART_OTHER, wxSize(32, 32));
wxSize clientSize(GetClientSize());
wxString txt(wxT("Please select a capture device"));
wxSize txtSize = dc.GetTextExtent(txt);
dc.DrawText(txt, clientSize.GetWidth()/2 - txtSize.GetWidth()/2,
clientSize.GetHeight()/2 - txtSize.GetHeight());
dc.DrawBitmap(bmp, clientSize.GetWidth()/2 - bmp.GetWidth()/2,
clientSize.GetHeight()/2 + 4);
}
}
void wxSashLayoutWindow::OnCalculateLayout(wxCalculateLayoutEvent& event)
{
wxRect clientSize(event.GetRect());
int flags = event.GetFlags();
if (!IsShown())
return;
// Let's assume that all windows stretch the full extent of the window in
// the direction of that window orientation. This will work for non-docking toolbars,
// and the status bar. Note that the windows have to have been created in a certain
// order to work, else you might get a left-aligned window going to the bottom
// of the window, and the status bar appearing to the right of it. The
// status bar would have to be created after or before the toolbar(s).
wxRect thisRect;
// Try to stretch
int length = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? clientSize.width : clientSize.height;
wxLayoutOrientation orient = GetOrientation();
// We assume that a window that says it's horizontal, wants to be stretched in that
// direction. Is this distinction too fine? Do we assume that any horizontal
// window needs to be stretched in that direction? Possibly.
int whichDimension = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? wxLAYOUT_LENGTH_X : wxLAYOUT_LENGTH_Y;
wxQueryLayoutInfoEvent infoEvent(GetId());
infoEvent.SetEventObject(this);
infoEvent.SetRequestedLength(length);
infoEvent.SetFlags(orient | whichDimension);
if (!GetEventHandler()->ProcessEvent(infoEvent))
return;
wxSize sz = infoEvent.GetSize();
if (sz.x == 0 && sz.y == 0) // Assume it's invisible
return;
// Now we know the size it wants to be. We wish to decide where to place it, i.e.
// how it's aligned.
switch (GetAlignment())
{
case wxLAYOUT_TOP:
{
thisRect.x = clientSize.x; thisRect.y = clientSize.y;
thisRect.width = sz.x; thisRect.height = sz.y;
clientSize.y += thisRect.height;
clientSize.height -= thisRect.height;
break;
}
case wxLAYOUT_LEFT:
{
thisRect.x = clientSize.x; thisRect.y = clientSize.y;
thisRect.width = sz.x; thisRect.height = sz.y;
clientSize.x += thisRect.width;
clientSize.width -= thisRect.width;
break;
}
case wxLAYOUT_RIGHT:
{
thisRect.x = clientSize.x + (clientSize.width - sz.x); thisRect.y = clientSize.y;
thisRect.width = sz.x; thisRect.height = sz.y;
clientSize.width -= thisRect.width;
break;
}
case wxLAYOUT_BOTTOM:
{
thisRect.x = clientSize.x; thisRect.y = clientSize.y + (clientSize.height - sz.y);
thisRect.width = sz.x; thisRect.height = sz.y;
clientSize.height -= thisRect.height;
break;
}
case wxLAYOUT_NONE:
{
break;
}
}
if ((flags & wxLAYOUT_QUERY) == 0)
{
// If not in query mode, resize the window.
// TODO: add wxRect& form to wxWindow::SetSize
wxSize sz2 = GetSize();
wxPoint pos = GetPosition();
SetSize(thisRect.x, thisRect.y, thisRect.width, thisRect.height);
// Make sure the sash is erased when the window is resized
if ((pos.x != thisRect.x || pos.y != thisRect.y || sz2.x != thisRect.width || sz2.y != thisRect.height) &&
(GetSashVisible(wxSASH_TOP) || GetSashVisible(wxSASH_RIGHT) || GetSashVisible(wxSASH_BOTTOM) || GetSashVisible(wxSASH_LEFT)))
Refresh(true);
}
event.SetRect(clientSize);
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace, CompositeOperator, const FloatRect& dstRect)
{
#if USE(WXGC)
wxGCDC* context = (wxGCDC*)ctxt->platformContext();
wxGraphicsBitmap* bitmap = nativeImageForCurrentFrame();
#else
wxDC* context = ctxt->platformContext();
wxBitmap* bitmap = nativeImageForCurrentFrame();
#endif
if (!bitmap) // If it's too early we won't have an image yet.
return;
ctxt->save();
ctxt->clip(IntRect(dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height()));
float currentW = 0;
float currentH = 0;
#if USE(WXGC)
wxGraphicsContext* gc = context->GetGraphicsContext();
float adjustedX = phase.x() + srcRect.x() *
narrowPrecisionToFloat(patternTransform.a());
float adjustedY = phase.y() + srcRect.y() *
narrowPrecisionToFloat(patternTransform.d());
gc->ConcatTransform(patternTransform);
#else
float adjustedX = phase.x();
float adjustedY = phase.y();
wxMemoryDC mydc;
mydc.SelectObject(*bitmap);
ctxt->concatCTM(patternTransform);
#endif
//wxPoint origin(context->GetDeviceOrigin());
AffineTransform mat(ctxt->getCTM());
wxPoint origin(mat.mapPoint(IntPoint(0, 0)));
wxSize clientSize(context->GetSize());
wxCoord w = srcRect.width();
wxCoord h = srcRect.height();
wxCoord srcx = srcRect.x();
wxCoord srcy = srcRect.y();
while (currentW < dstRect.right() - phase.x() && origin.x + adjustedX + currentW < clientSize.x) {
while (currentH < dstRect.bottom() - phase.y() && origin.y + adjustedY + currentH < clientSize.y) {
#if USE(WXGC)
#if wxCHECK_VERSION(2,9,0)
gc->DrawBitmap(*bitmap, adjustedX + currentW, adjustedY + currentH, (wxDouble)srcRect.width(), (wxDouble)srcRect.height());
#else
gc->DrawGraphicsBitmap(*bitmap, adjustedX + currentW, adjustedY + currentH, (wxDouble)srcRect.width(), (wxDouble)srcRect.height());
#endif
#else
context->Blit(adjustedX + currentW, adjustedY + currentH,
w, h, &mydc, srcx, srcy, wxCOPY, true);
#endif
currentH += srcRect.height();
}
currentW += srcRect.width();
currentH = 0;
}
ctxt->restore();
#if !USE(WXGC)
mydc.SelectObject(wxNullBitmap);
#endif
// NB: delete is causing crashes during page load, but not during the deletion
// itself. It occurs later on when a valid bitmap created in frameAtIndex
// suddenly becomes invalid after returning. It's possible these errors deal
// with reentrancy and threding problems.
//delete bitmap;
startAnimation();
if (ImageObserver* observer = imageObserver())
observer->didDraw(this);
}
