void SimpleSurface::applyFilter (Surface *inSrc, const Rect &inRect, ImagePoint inOffset, Filter *inFilter) {
if (!mBase) return;
FilterList f;
f.push_back (inFilter);
Rect src_rect (inRect.w, inRect.h);
Rect dest = GetFilteredObjectRect (f, src_rect);
inSrc->IncRef ();
Surface *result = FilterBitmap (f, inSrc, src_rect, dest, false, ImagePoint (inRect.x, inRect.y));
dest.Translate (inOffset.x, inOffset.y);
src_rect = Rect (0, 0, result->Width (), result->Height ());
int dx = dest.x;
int dy = dest.y;
dest = dest.Intersect (Rect (0, 0, mWidth, mHeight));
dest.Translate (-dx, -dy);
dest = dest.Intersect (src_rect);
dest.Translate (dx, dy);
int bpp = BytesPP ();
RenderTarget t = BeginRender (dest, false);
//printf("Copy back @ %d,%d %dx%d + (%d,%d)\n", dest.x, dest.y, t.Width(), t.Height(), dx, dy);
for (int y = 0; y < t.Height (); y++)
memcpy ((void *)(t.Row (y + dest.y) + ((dest.x) * bpp)), result->Row (y - dy) - (dx * bpp), dest.w * bpp);
EndRender ();
result->DecRef ();
}
Bitmap Bitmap::GetBitmap(const Rect& area) const
{
// assert
assert( image );
// test area
if ( area.width < 1 ||
area.height < 1 ||
area.x < 0 ||
area.y < 0 ||
(area.x+area.width) > width ||
(area.y+area.height) > height )
return *this;
// clip
Rect q;
if ( !q.Intersect(GetRect(),area) )
return *this;
// new bitmap
Bitmap p(q.width,q.height,format);
// copy image
CopyImage(p.image,
image + q.y * pitch + q.x * format.GetBytes(),
p.pitch,pitch,q.height);
return p;
}
bool SystemDraw::IsPaintingOp(const Rect& r) const
{
Rect cr = r.Offseted(GetOffset());
cr.Intersect(GetClip());
if(cr.IsEmpty())
return false;
return !invalid || gdk_region_rect_in(invalid, GdkRect(cr)) != GDK_OVERLAP_RECTANGLE_OUT;
}
void
gfxContext::PushGroupAndCopyBackground(gfxContentType content)
{
IntRect clipExtents;
if (mDT->GetFormat() != SurfaceFormat::B8G8R8X8) {
gfxRect clipRect = GetRoundOutDeviceClipExtents(this);
clipExtents = IntRect(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
}
if ((mDT->GetFormat() == SurfaceFormat::B8G8R8X8 ||
mDT->GetOpaqueRect().Contains(clipExtents)) &&
!mDT->GetUserData(&sDontUseAsSourceKey)) {
DrawTarget *oldDT = mDT;
RefPtr<SourceSurface> source = mDT->Snapshot();
Point oldDeviceOffset = CurrentState().deviceOffset;
PushNewDT(gfxContentType::COLOR);
if (oldDT == mDT) {
// Creating new DT failed.
return;
}
Point offset = CurrentState().deviceOffset - oldDeviceOffset;
Rect surfRect(0, 0, Float(mDT->GetSize().width), Float(mDT->GetSize().height));
Rect sourceRect = surfRect + offset;
mDT->SetTransform(Matrix());
// XXX: It's really sad that we have to do this (for performance).
// Once DrawTarget gets a PushLayer API we can implement this within
// DrawTargetTiled.
if (source->GetType() == SurfaceType::TILED) {
SnapshotTiled *sourceTiled = static_cast<SnapshotTiled*>(source.get());
for (uint32_t i = 0; i < sourceTiled->mSnapshots.size(); i++) {
Rect tileSourceRect = sourceRect.Intersect(Rect(sourceTiled->mOrigins[i].x,
sourceTiled->mOrigins[i].y,
sourceTiled->mSnapshots[i]->GetSize().width,
sourceTiled->mSnapshots[i]->GetSize().height));
if (tileSourceRect.IsEmpty()) {
continue;
}
Rect tileDestRect = tileSourceRect - offset;
tileSourceRect -= sourceTiled->mOrigins[i];
mDT->DrawSurface(sourceTiled->mSnapshots[i], tileDestRect, tileSourceRect);
}
} else {
mDT->DrawSurface(source, surfRect, sourceRect);
}
mDT->SetOpaqueRect(oldDT->GetOpaqueRect());
PushClipsToDT(mDT);
mDT->SetTransform(GetDTTransform());
return;
}
PushGroup(content);
}
bool PolygonRender::Render(const RenderTarget &inTarget, const RenderState &inState)
{
Extent2DF extent;
CachedExtentRenderer::GetExtent(inState.mTransform, extent);
if (!extent.Valid())
return true;
// Get bounding pixel rect
Rect rect = inState.mTransform.GetTargetRect(extent);
// Intersect with clip rect ...
Rect visible_pixels = rect.Intersect(inState.mClipRect);
if (visible_pixels.HasPixels())
{
// Check to see if AlphaMask is invalid...
int tx = 0;
int ty = 0;
if (mAlphaMask && !mAlphaMask->Compatible(inState.mTransform, rect,visible_pixels, tx, ty))
{
mAlphaMask->Dispose();
mAlphaMask = 0;
}
if (!mAlphaMask)
{
SetTransform(inState.mTransform);
// TODO: make visible_pixels a bit bigger ?
SpanRect span(visible_pixels, inState.mTransform.mAAFactor);
span.mWinding = GetWinding();
mSpanRect = &span;
int alpha_factor = Iterate(itCreateRenderer, *inState.mTransform.mMatrix);
mAlphaMask = mSpanRect->CreateMask(mTransform, alpha_factor);
mSpanRect = 0;
}
if (inTarget.mPixelFormat == pfAlpha)
{
mAlphaMask->RenderBitmap(tx, ty, inTarget, inState);
}
else
{
mFiller->Fill(*mAlphaMask, tx, ty, inTarget, inState);
}
}
return true;
}
RenderTarget SimpleSurface::BeginRender (const Rect &inRect, bool inForHitTest) {
if (!mBase)
return RenderTarget ();
Rect r = inRect.Intersect (Rect (0, 0, mWidth, mHeight));
if (mTexture)
mTexture->Dirty (r);
mVersion++;
return RenderTarget (r, mPixelFormat, mBase, mStride);
}
void
CliWindow::Invalidate (const Rect& region)
{
Rect bounds = _canvas.GetDrawBounds();
if (bounds.Intersects(region)) {
bounds = bounds.Intersect(region);
Redraw(bounds);
if (_parent) {
bounds.Move(Bounds().TopLeft()+_parent->ClientOffset());
_parent->Invalidate(bounds);
}
}
}
bool MultiFormMgr::Paint(bool fForceBackBufferValid)
{
// Calc opaque rect
Rect rcOpaque;
rcOpaque.SetEmpty();
CalcOpaqueRect(NULL, NULL, &rcOpaque);
bool fAnyScroll = false;
int n;
for (n = 0; n < m_cfrmm; n++) {
// Paint children form mgr bits
bool fScrolled = m_apfrmm[n]->ScrollBits();
if (fForceBackBufferValid)
fScrolled = true;
if (fScrolled)
fAnyScroll = true;
// Paint / calc updatemaps for children
Rect rcT;
rcT.Intersect(&m_arcFormMgr[n], &rcOpaque);
rcT.Offset(-m_arcFormMgr[n].left, -m_arcFormMgr[n].top);
m_apfrmm[n]->Paint(fScrolled, &rcT);
}
// There is a form, need the children updatemap data to be reflected in the
// parent updatemap
for (n = 0; n < m_cfrmm; n++) {
FormMgr *pfrmm = m_apfrmm[n];
UpdateMap *pupd = pfrmm->GetUpdateMap();
Rect rcT;
bool fFirst = true;
while (pupd->EnumUpdateRects(fFirst, NULL, &rcT)) {
fFirst = false;
rcT.Offset(m_arcFormMgr[n].left, m_arcFormMgr[n].top);
m_pupd->InvalidateRect(&rcT);
}
}
// Now that the multi-form mgr has all the invalid state reflected,
// it is ok to paint
rcOpaque.SetEmpty();
FormMgr::Paint(false, &rcOpaque);
return fAnyScroll;
}
void DrawRectBASE(PixelBlock& w, int x, int y, int cx, int cy, Color c)
{
RTIMING("DrawRect");
Rect r = RectC(x, y, cx, cy);
r.Intersect(w.GetSize());
if(r.IsEmpty())
return;
dword color = c.GetRaw();
dword *a = w.PointAdr(r.left, r.top);
int d = w.LineDelta();
cy = r.Height();
cx = r.Width();
while(cy--) {
memsetd(a, color, cx);
a += d;
}
}
void TexturedLayerMLGPU::AssignBigImage(FrameBuilder* aBuilder,
RenderViewMLGPU* aView,
BigImageIterator* aIter,
const Maybe<Polygon>& aGeometry) {
const Matrix4x4& transform = GetLayer()->GetEffectiveTransformForBuffer();
// Note that we don't need to assign these in any particular order, since
// they do not overlap.
do {
IntRect tileRect = aIter->GetTileRect();
IntRect rect = tileRect.Intersect(mPictureRect);
if (rect.IsEmpty()) {
continue;
}
{
Rect screenRect = transform.TransformBounds(Rect(rect));
screenRect.MoveBy(-aView->GetTargetOffset());
screenRect =
screenRect.Intersect(Rect(mComputedClipRect.ToUnknownRect()));
if (screenRect.IsEmpty()) {
// This tile is not in the clip region, so skip it.
continue;
}
}
RefPtr<TextureSource> tile = mBigImageTexture->ExtractCurrentTile();
if (!tile) {
continue;
}
// Create a temporary item.
RefPtr<TempImageLayerMLGPU> item =
new TempImageLayerMLGPU(aBuilder->GetManager());
item->Init(this, tile, rect);
Maybe<Polygon> geometry = aGeometry;
item->AddBoundsToView(aBuilder, aView, std::move(geometry));
// Since the layer tree is not holding this alive, we have to ask the
// FrameBuilder to do it for us.
aBuilder->RetainTemporaryLayer(item);
} while (aIter->NextTile());
}
IntRect
LayerMLGPU::GetClippedBoundingBox(RenderViewMLGPU* aView,
const Maybe<gfx::Polygon>& aGeometry)
{
MOZ_ASSERT(IsPrepared());
Layer* layer = GetLayer();
const Matrix4x4& transform = layer->GetEffectiveTransform();
Rect rect = aGeometry
? aGeometry->BoundingBox()
: Rect(layer->GetLocalVisibleRegion().GetBounds().ToUnknownRect());
rect = transform.TransformBounds(rect);
rect.MoveBy(-aView->GetTargetOffset());
rect = rect.Intersect(Rect(mComputedClipRect.ToUnknownRect()));
IntRect bounds;
rect.RoundOut();
rect.ToIntRect(&bounds);
return bounds;
}
void MultiFormMgr::InvalidateRect(Rect *prc)
{
// Distribute to this form mgr
Rect rcDib;
if (prc == NULL) {
Size siz;
m_pbm->GetSize(&siz);
rcDib.Set(0, 0, siz.cx, siz.cy);
prc = &rcDib;
}
// Distribute to children form mgr's
for (int n = 0; n < m_cfrmm; n++) {
Rect rcT;
if (rcT.Intersect(prc, &m_arcFormMgr[n])) {
rcT.Offset(-m_arcFormMgr[n].left, -m_arcFormMgr[n].top);
m_apfrmm[n]->InvalidateRect(&rcT);
}
}
}
bool PointRenderer::Render( const RenderTarget &inTarget, const RenderState &inState )
{
Extent2DF extent;
CachedExtentRenderer::GetExtent(inState.mTransform,extent);
if (!extent.Valid())
return true;
// Get bounding pixel rect
Rect rect = inState.mTransform.GetTargetRect(extent);
// Intersect with clip rect ...
Rect visible_pixels = rect.Intersect(inState.mClipRect);
int x0 = visible_pixels.x;
int y0 = visible_pixels.y;
int x1 = visible_pixels.x1();
int y1 = visible_pixels.y1();
bool swap = gC0IsRed != (bool)(inTarget.mPixelFormat & pfSwapRB);
//bool alpha = (inTarget.mPixelFormat & pfHasAlpha);
if (!mHasColours)
{
int val = swap ? mCol.SwappedIVal() : mCol.ival;
// 100% alpha...
if ( ( (val & 0xff000000) == 0xff000000 ) || (inTarget.mPixelFormat & pfHasAlpha) )
{
for(int i=0; i<mTransformed.size(); i++)
{
const UserPoint &point = mTransformed[i];
int tx = point.x;
if (x0<=tx && tx<x1)
{
int ty = point.y;
if (y0<=ty && ty<y1)
((int *)inTarget.Row(ty))[tx] = val;
}
}
}
else
{
ARGB argb = swap ? mCol.Swapped() : mCol;
for(int i=0; i<mTransformed.size(); i++)
{
const UserPoint &point = mTransformed[i];
int tx = point.x;
if (x0<=tx && tx<x1)
{
int ty = point.y;
if (y0<=ty && ty<y1)
((ARGB *)inTarget.Row(ty))[tx].QBlendA(argb);
}
}
}
}
else
{
ARGB *argb = (ARGB *) & mData[mData0 + mTransformed.size()*2];
if (inTarget.mPixelFormat & pfHasAlpha)
for(int i=0; i<mTransformed.size(); i++)
{
const UserPoint &point = mTransformed[i];
int tx = point.x;
if (x0<=tx && tx<x1)
{
int ty = point.y;
if (y0<=ty && ty<y1)
((ARGB *)inTarget.Row(ty))[tx].QBlendA( swap? argb[i] : argb[i].Swapped() );
}
}
else
for(int i=0; i<mTransformed.size(); i++)
{
const UserPoint &point = mTransformed[i];
int tx = point.x;
if (x0<=tx && tx<x1)
{
int ty = point.y;
if (y0<=ty && ty<y1)
((ARGB *)inTarget.Row(ty))[tx].QBlend( swap? argb[i].Swapped() : argb[i] );
}
}
}
return true;
}
bool Render(const RenderTarget &inTarget, const RenderState &inState)
{
Surface *s = mFill->bitmapData;
double bmp_scale_x = 1.0/s->Width();
double bmp_scale_y = 1.0/s->Height();
// Todo:skew
bool is_stretch = (inState.mTransform.mMatrix->m00!=1.0 ||
inState.mTransform.mMatrix->m11!=1.0) &&
( inState.mTransform.mMatrix->m00 > 0 &&
inState.mTransform.mMatrix->m11 > 0 );
for(int i=0; i<mTileData.size(); i++)
{
TileData &data= mTileData[i];
BlendMode blend = data.mHasColour ? ( mBlendMode==bmAdd ? bmTintedAdd : bmTinted ):
mBlendMode;
UserPoint corner(data.mPos);
UserPoint pos = inState.mTransform.mMatrix->Apply(corner.x,corner.y);
if (s->Format()==pfAlpha && !is_stretch && mBlendMode==bmNormal && data.mHasColour /* integer co-ordinate?*/ )
{
unsigned int col = inState.mColourTransform->Transform(data.mColour|0xff000000);
s->BlitTo(inTarget, data.mRect, (int)(pos.x), (int)(pos.y), blend, 0, col);
}
else if ( (is_stretch || data.mHasTrans) )
{
// Can use stretch if there is no skew and no colour transform...
if (!data.mHasColour && (!data.mHasTrans) && mBlendMode==bmNormal )
{
UserPoint p0 = pos;
pos = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y+data.mRect.h);
s->StretchTo(inTarget, data.mRect, DRect(p0.x,p0.y,pos.x,pos.y,true));
}
else
{
int tile_alpha = 256;
bool just_alpha = (data.mHasColour) &&
((data.mColour&0x00ffffff ) == 0x00ffffff);
if (data.mHasColour && mBlendMode==bmNormal)
{
tile_alpha = data.mColour>>24;
if (tile_alpha>0) tile_alpha++;
}
// Create alpha mask...
UserPoint p[4];
p[0] = inState.mTransform.mMatrix->Apply(corner.x,corner.y);
if (data.mHasTrans)
{
p[1] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.w*data.mTransX.x,
corner.y + data.mRect.w*data.mTransY.x);
p[2] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.w*data.mTransX.x + data.mRect.h*data.mTransX.y,
corner.y + data.mRect.w*data.mTransY.x + data.mRect.h*data.mTransY.y );
p[3] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.h*data.mTransX.y,
corner.y + data.mRect.h*data.mTransY.y );
}
else
{
p[1] = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y);
p[2] = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y+data.mRect.h);
p[3] = inState.mTransform.mMatrix->Apply(corner.x,corner.y+data.mRect.h);
}
Extent2DF extent;
extent.Add(p[0]);
extent.Add(p[1]);
extent.Add(p[2]);
extent.Add(p[3]);
// Get bounding pixel rect
Rect rect = inState.mTransform.GetTargetRect(extent);
// Intersect with clip rect ...
Rect visible_pixels = rect.Intersect(inState.mClipRect);
if (!visible_pixels.HasPixels())
continue;
Rect alpha_rect(visible_pixels);
bool offscreen_buffer = mBlendMode!=bmNormal;
if (offscreen_buffer)
{
for(int i=0; i<4; i++)
{
p[i].x -= visible_pixels.x;
p[i].y -= visible_pixels.y;
}
alpha_rect.x -= visible_pixels.x;
alpha_rect.y -= visible_pixels.y;
}
int aa = 1;
SpanRect *span = new SpanRect(alpha_rect,aa);
for(int i=0; i<4; i++)
span->Line00(
Fixed10( p[i].x, p[i].y ),
Fixed10( p[(i+1)&3].x, p[(i+1)&3].y) );
AlphaMask *alpha = span->CreateMask(inState.mTransform,tile_alpha);
delete span;
float uvt[6];
uvt[0] = (data.mRect.x) * bmp_scale_x;
uvt[1] = (data.mRect.y) * bmp_scale_y;
uvt[2] = (data.mRect.x + data.mRect.w) * bmp_scale_x;
uvt[3] = (data.mRect.y) * bmp_scale_y;
uvt[4] = (data.mRect.x + data.mRect.w) * bmp_scale_x;
uvt[5] = (data.mRect.y + data.mRect.h) * bmp_scale_y;
mFiller->SetMapping(p,uvt,2);
// Can render straight to surface ....
if (!offscreen_buffer)
{
if (s->Format()==pfAlpha)
{
if (data.mHasColour)
{
ARGB col = inState.mColourTransform->Transform(data.mColour|0xff000000);
mFiller->SetTint(col);
}
mFiller->Fill(*alpha,0,0,inTarget,inState);
}
else if (data.mHasTrans && !just_alpha)
{
ColorTransform buf;
RenderState col_state(inState);
ColorTransform tint;
tint.redMultiplier = ((data.mColour) & 0xff) * one_on_255;
tint.greenMultiplier = ((data.mColour>>8) & 0xff) * one_on_255;
tint.blueMultiplier = ((data.mColour>>16) & 0xff) * one_on_255;
col_state.CombineColourTransform(inState, &tint, &buf);
mFiller->Fill(*alpha,0,0,inTarget,col_state);
}
else
mFiller->Fill(*alpha,0,0,inTarget,inState);
}
else
{
bool Render(const RenderTarget &inTarget, const RenderState &inState)
{
if (mTriangles->mUVT.empty())
return PolygonRender::Render(inTarget,inState);
Extent2DF extent;
CachedExtentRenderer::GetExtent(inState.mTransform,extent,true);
if (!extent.Valid())
return true;
// Get bounding pixel rect
Rect rect = inState.mTransform.GetTargetRect(extent);
// Intersect with clip rect ...
Rect visible_pixels = rect.Intersect(inState.mClipRect);
int tris = mTriangles->mTriangleCount;
UserPoint *point = &mTransformed[0];
bool *edge_aa = &mEdgeAA[0];
float *uvt = &mTriangles->mUVT[0];
int tex_components = mTriangles->mType == vtVertex ? 0 : mTriangles->mType==vtVertexUV ? 2 : 3;
int aa = inState.mTransform.mAAFactor;
bool aa1 = aa==1;
for(int i=0;i<tris;i++)
{
// For each alpha mask ...
// Check to see if AlphaMask is invalid...
AlphaMask *&alpha = mAlphaMasks[i];
int tx=0;
int ty=0;
if (alpha && !alpha->Compatible(inState.mTransform, rect,visible_pixels,tx,ty))
{
alpha->Dispose();
alpha = 0;
}
if (!alpha)
{
SetTransform(inState.mTransform);
SpanRect *span = new SpanRect(visible_pixels,inState.mTransform.mAAFactor);
if (aa1 || edge_aa[0])
span->Line01( mTransform.ToImageAA(point[0]),mTransform.ToImageAA(point[1]) );
else
span->Line11( mTransform.ToImageAA(point[0]),mTransform.ToImageAA(point[1]) );
if (aa1 || edge_aa[1])
span->Line01( mTransform.ToImageAA(point[1]),mTransform.ToImageAA(point[2]) );
else
span->Line11( mTransform.ToImageAA(point[1]),mTransform.ToImageAA(point[2]) );
if (aa1 || edge_aa[2])
span->Line01( mTransform.ToImageAA(point[2]),mTransform.ToImageAA(point[0]) );
else
span->Line11( mTransform.ToImageAA(point[2]),mTransform.ToImageAA(point[0]) );
alpha = span->CreateMask(mTransform,256);
delete span;
}
if (inTarget.mPixelFormat==pfAlpha)
{
alpha->RenderBitmap(tx,ty,inTarget,inState);
}
else
{
if (tex_components)
mFiller->SetMapping(point,uvt,tex_components);
mFiller->Fill(*alpha,tx,ty,inTarget,inState);
}
point += 3;
uvt+=tex_components*3;
edge_aa += 3;
}
mMappingDirty = false;
return true;
}
bool UIControl::isReadyForPaint(Rect& rect)
{
return rect.Intersect(m_client) == TRUE && hasAttr(STATE_VISIBLE);
}
bool Render(const RenderTarget &inTarget, const RenderState &inState)
{
#define orthoTol 1e-6
Surface *s = mFill->bitmapData;
double bmp_scale_x = 1.0/s->Width();
double bmp_scale_y = 1.0/s->Height();
bool is_base_ortho = fabs(inState.mTransform.mMatrix->m01)< orthoTol && fabs(inState.mTransform.mMatrix->m10)< orthoTol;
float sx = inState.mTransform.mMatrix->m00;
float sy = inState.mTransform.mMatrix->m11;
bool is_base_identity = is_base_ortho && fabs(sx-1.0)<orthoTol && fabs(sy-1.0)<orthoTol;
//int blits = 0;
//int stretches = 0;
//int renders = 0;
for(int i=0;i<mTileData.size();i++)
{
TileData &data= mTileData[i];
BlendMode blend = data.mHasColour ? ( mBlendMode==bmAdd ? bmTintedAdd : bmTinted ):
mBlendMode;
UserPoint corner(data.mPos);
UserPoint pos = inState.mTransform.mMatrix->Apply(corner.x,corner.y);
bool is_ortho = is_base_ortho && (!data.mHasTrans || fabs(data.mTransX.y)<orthoTol);
bool is_identity = data.mHasTrans ?
is_ortho && fabs(sx*data.mTransX.x-1.0)<orthoTol && fabs(sy*data.mTransY.y-1)<orthoTol :
is_base_identity;
if ( !is_identity )
{
// Can use stretch if there is no skew and no colour transform...
if (!data.mHasColour && mBlendMode==bmNormal && is_ortho )
{
UserPoint p0 = pos;
if (data.mHasTrans)
pos = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w*data.mTransX.x,
corner.y+data.mRect.h*data.mTransY.y);
else
pos = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y+data.mRect.h);
s->StretchTo(inTarget, data.mRect, DRect(p0.x,p0.y,pos.x,pos.y,true));
//stretches++;
}
else
{
//renders++;
int tile_alpha = 256;
bool just_alpha = (data.mHasColour) &&
((data.mColour&0x00ffffff ) == 0x00ffffff);
if (data.mHasColour && mBlendMode==bmNormal)
{
tile_alpha = data.mColour>>24;
if (tile_alpha>0) tile_alpha++;
}
// Create alpha mask...
UserPoint p[4];
p[0] = inState.mTransform.mMatrix->Apply(corner.x,corner.y);
if (data.mHasTrans)
{
p[1] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.w*data.mTransX.x,
corner.y + data.mRect.w*data.mTransY.x);
p[2] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.w*data.mTransX.x + data.mRect.h*data.mTransX.y,
corner.y + data.mRect.w*data.mTransY.x + data.mRect.h*data.mTransY.y );
p[3] = inState.mTransform.mMatrix->Apply(
corner.x + data.mRect.h*data.mTransX.y,
corner.y + data.mRect.h*data.mTransY.y );
}
else
{
p[1] = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y);
p[2] = inState.mTransform.mMatrix->Apply(corner.x+data.mRect.w,corner.y+data.mRect.h);
p[3] = inState.mTransform.mMatrix->Apply(corner.x,corner.y+data.mRect.h);
}
Extent2DF extent;
extent.Add(p[0]);
extent.Add(p[1]);
extent.Add(p[2]);
extent.Add(p[3]);
// Get bounding pixel rect
Rect rect = inState.mTransform.GetTargetRect(extent);
// Intersect with clip rect ...
Rect visible_pixels = rect.Intersect(inState.mClipRect);
if (!visible_pixels.HasPixels())
continue;
Rect alpha_rect(visible_pixels);
bool offscreen_buffer = mBlendMode!=bmNormal;
if (offscreen_buffer)
{
for(int i=0;i<4;i++)
{
p[i].x -= visible_pixels.x;
p[i].y -= visible_pixels.y;
}
alpha_rect.x -= visible_pixels.x;
alpha_rect.y -= visible_pixels.y;
}
int aa = 1;
SpanRect *span = new SpanRect(alpha_rect,aa);
// ToImageAA - add 0.5 offset
for(int i=0;i<4;i++)
span->Line00(
Fixed10( p[i].x + 0.5, p[i].y + 0.5 ),
Fixed10( p[(i+1)&3].x + 0.5, p[(i+1)&3].y + 0.5) );
AlphaMask *alpha = span->CreateMask(inState.mTransform,tile_alpha);
delete span;
float uvt[6];
uvt[0] = (data.mRect.x) * bmp_scale_x;
uvt[1] = (data.mRect.y) * bmp_scale_y;
uvt[2] = (data.mRect.x + data.mRect.w) * bmp_scale_x;
uvt[3] = (data.mRect.y) * bmp_scale_y;
uvt[4] = (data.mRect.x + data.mRect.w) * bmp_scale_x;
uvt[5] = (data.mRect.y + data.mRect.h) * bmp_scale_y;
mFiller->SetMapping(p,uvt,2);
// Can render straight to surface ....
if (!offscreen_buffer)
{
if (s->Format()==pfAlpha)
{
if (data.mHasColour)
{
ARGB col = inState.mColourTransform->Transform(data.mColour|0xff000000);
mFiller->SetTint(col);
}
mFiller->Fill(*alpha,0,0,inTarget,inState);
}
else if (data.mHasTrans && !just_alpha)
{
ColorTransform buf;
RenderState col_state(inState);
ColorTransform tint;
tint.redMultiplier = ((data.mColour) & 0xff) * one_on_255;
tint.greenMultiplier = ((data.mColour>>8) & 0xff) * one_on_255;
tint.blueMultiplier = ((data.mColour>>16) & 0xff) * one_on_255;
col_state.CombineColourTransform(inState, &tint, &buf);
mFiller->Fill(*alpha,0,0,inTarget,col_state);
}
else
mFiller->Fill(*alpha,0,0,inTarget,inState);
}
else
{
///////////////////////////////////////////////////////////////////////////////////////////////
// repaint images on image cache
void PixRasterBaseCtrl::PaintCache()
{
Array<Rect> rects;
// if no associated PixRaster object, do nothing
if(!pixRasterCtrl || !pixRasterCtrl->GetPixBase())
return;
// backups old imageCache positions inside the full tiff image
int oldCacheLeft = cacheLeft;
int oldCacheTop = cacheTop;
// calculate new imageCache position inside the full tiff image
if(hScrollBar.IsVisible())
cacheLeft = hScrollBar.Get();
else
cacheLeft = 0;
if(vScrollBar.IsVisible())
cacheTop = vScrollBar.Get();
else
cacheTop = 0;
// if cache is not valid OR scrolled out a full window, gets full cache area
if(
!imageCache.IsValid() ||
abs(oldCacheLeft-cacheLeft) >= imageCache.GetWidth() ||
abs(oldCacheTop-cacheTop) >= imageCache.GetHeight()
)
{
rects.Add(Rect(imageCache.GetSize()));
imageCache.SetValid(true);
oldCacheLeft = oldCacheTop = 0;
}
else
{
// shifts imageCache
imageCache.Scroll(Size(oldCacheLeft-cacheLeft, oldCacheTop-cacheTop));
// calculates the (1 or 2) rects that must be repainted
int startLine = 0;
int endLine = imageCache.GetHeight();
// top rectangle, if any
if(cacheTop < oldCacheTop)
{
rects.Add(Rect(0, 0, imageCache.GetWidth(), oldCacheTop-cacheTop));
startLine += oldCacheTop-cacheTop;
}
// bottom rectangle, if any
else if(cacheTop > oldCacheTop)
{
rects.Add(Rect(0, imageCache.GetHeight()-(cacheTop-oldCacheTop), imageCache.GetWidth(), imageCache.GetHeight()));
endLine += oldCacheTop-cacheTop;
}
// left rectangle, if any
if(cacheLeft < oldCacheLeft)
rects.Add(Rect(0, startLine, oldCacheLeft - cacheLeft, endLine));
else if(cacheLeft > oldCacheLeft)
rects.Add(Rect(imageCache.GetWidth()-(cacheLeft-oldCacheLeft), startLine, imageCache.GetWidth(), endLine));
}
// gets associated PixRaster object
PixBase *pixBase = pixRasterCtrl->GetPixBase();
// scans the PixRaster pages to see if some of them fits in
// rectangles that must be repainted
int currentTop = 0;
int currentPage = pixBase->GetActivePage();
for(int i = 0 ; i < pixBase->GetPageCount() ; i++)
{
// sets the active page
pixBase->SeekPage(i);
// translates current top of page in view coordinates
int viewCurrentTop = ScaleToView(currentTop);
// gets current page size and translates it in view coordinates
Rect viewPageRect(
-cacheLeft,
-cacheTop + viewCurrentTop,
ScaleToView(pixBase->GetSize().cx) - cacheLeft,
ScaleToView(pixBase->GetSize().cy) - cacheTop + viewCurrentTop
);
// now scans the rectangles that must be repainted
// and checks if current page has some area on it
for(int iRect = 0; iRect < rects.GetCount(); iRect++)
{
// gets current rectangle
Rect rect = rects[iRect];
// intersects with page rect
rect.Intersect(viewPageRect);
// if intersection is not empty, do repaint the stuff
if(!rect.IsEmpty())
{
// gets back the tiff rectangle
Rect tiffRect(
ScaleToPage(rect.left + cacheLeft),
ScaleToPage(rect.top + cacheTop) - currentTop,
ScaleToPage(rect.right + cacheLeft),
ScaleToPage(rect.bottom + cacheTop) -currentTop
);
// rescales the image area
ImageEncoder t;
Rescale(t, rect.GetSize(), *pixBase, tiffRect);
// and copies insiede the cache area
Image img = Image(t);
ASSERT(rect.top >= 0 && rect.top + img.GetHeight() <= imageCache.GetHeight());
ASSERT(rect.left >= 0 && rect.left + img.GetWidth() <= imageCache.GetWidth());
imageCache.Copy(Point(rect.left, rect.top), Rect(0, 0, img.GetWidth(), img.GetHeight()), img);
}
}
currentTop += pixBase->GetHeight() + ScaleToPage(10);
}
// restore PixRaster's active page
pixBase->SeekPage(currentPage);
} // END PixRasterBaseCtrl::PaintCache()
LRESULT CVideoMarkup::OnButtonUp( UINT, WPARAM, LPARAM lParam, BOOL&)
{
POINT p;
p.x = LOWORD(lParam);
p.y = HIWORD(lParam);
if (draggingIcon) { // we just completed an icon drag
// End the drag-and-drop process
draggingIcon = FALSE;
ImageList_DragLeave(m_sampleListView);
ImageList_EndDrag();
ImageList_Destroy(hDragImageList);
SetCursor(LoadCursor(NULL, IDC_ARROW));
ReleaseCapture();
// Determine the position of the drop point
LVHITTESTINFO lvhti;
lvhti.pt = p;
ClientToScreen(&lvhti.pt);
::ScreenToClient(m_sampleListView, &lvhti.pt);
ListView_HitTestEx(m_sampleListView, &lvhti);
CRect posRect, negRect, motionRect, rangeRect;
ListView_GetGroupRect(m_sampleListView, GROUPID_POSSAMPLES, LVGGR_GROUP, &posRect);
ListView_GetGroupRect(m_sampleListView, GROUPID_NEGSAMPLES, LVGGR_GROUP, &negRect);
ListView_GetGroupRect(m_sampleListView, GROUPID_MOTIONSAMPLES, LVGGR_GROUP, &motionRect);
ListView_GetGroupRect(m_sampleListView, GROUPID_RANGESAMPLES, LVGGR_GROUP, &rangeRect);
int newGroupId;
if (posRect.PtInRect(lvhti.pt)) newGroupId = GROUPID_POSSAMPLES;
else if (negRect.PtInRect(lvhti.pt)) newGroupId = GROUPID_NEGSAMPLES;
else if (motionRect.PtInRect(lvhti.pt)) newGroupId = GROUPID_MOTIONSAMPLES;
else if (rangeRect.PtInRect(lvhti.pt)) newGroupId = GROUPID_RANGESAMPLES;
else newGroupId = GROUPID_TRASH;
// update group membership of selected items based on drop location
int numSelected = ListView_GetSelectedCount(m_sampleListView);
int iSelection = -1;
for (int iIndex=0; iIndex<numSelected; iIndex++) {
// retrieve the selected item
LVITEM lvi;
iSelection = ListView_GetNextItem(m_sampleListView, iSelection, LVNI_SELECTED);
lvi.mask = LVIF_IMAGE | LVIF_STATE | LVIF_GROUPID;
lvi.state = 0;
lvi.stateMask = 0;
lvi.iItem = iSelection;
lvi.iSubItem = 0;
ListView_GetItem(m_sampleListView, &lvi);
// Get the ID of this selected item
UINT sampleId = ListView_MapIndexToID(m_sampleListView, iSelection);
// test if this is an allowable group membership change
int origGroupId = sampleSet.GetOriginalSampleGroup(sampleId);
if (!GroupTransitionIsAllowed(origGroupId, newGroupId)) {
// this is not a valid change so we'll move to the next item
continue;
}
// update sample group in training set
sampleSet.SetSampleGroup(sampleId, newGroupId);
// Update item in list view with new group id
lvi.iGroupId = newGroupId;
ListView_SetItem(m_sampleListView, &lvi);
}
m_sampleListView.Invalidate(FALSE);
} else if (m_videoLoader.videoLoaded && selectingRegion) { // we just finished drawing a selection
ClipCursor(NULL); // restore full cursor movement
if (!m_videoRect.PtInRect(p)) {
InvalidateRect(&m_videoRect,FALSE);
return 0;
}
selectingRegion = false;
Rect selectRect;
selectRect.X = (INT) min(selectStart.X, selectCurrent.X);
selectRect.Y = (INT) min(selectStart.Y, selectCurrent.Y);
selectRect.Width = (INT) abs(selectStart.X - selectCurrent.X);
selectRect.Height = (INT) abs(selectStart.Y - selectCurrent.Y);
Rect drawBounds(0,0,VIDEO_X,VIDEO_Y);
selectRect.Intersect(drawBounds);
double scaleX = ((double)m_videoLoader.videoX) / ((double)VIDEO_X);
double scaleY = ((double)m_videoLoader.videoY) / ((double)VIDEO_Y);
selectRect.X = (INT) (scaleX * selectRect.X);
selectRect.Y = (INT) (scaleY * selectRect.Y);
selectRect.Width = (INT) (scaleX * selectRect.Width);
selectRect.Height = (INT) (scaleY * selectRect.Height);
// discard tiny samples since they won't help
if ((selectRect.Width > 10) && (selectRect.Height > 10)) {
TrainingSample *sample;
// if we're in motion mode, the behavior is a little special
if (recognizerMode == MOTION_FILTER) {
sample = new TrainingSample(m_videoLoader.copyFrame, m_videoLoader.GetMotionHistory(), m_sampleListView, m_hImageList, selectRect, GROUPID_MOTIONSAMPLES);
} else {
sample = new TrainingSample(m_videoLoader.copyFrame, m_sampleListView, m_hImageList, selectRect, currentGroupId);
}
sampleSet.AddSample(sample);
}
InvalidateRect(&m_videoRect, FALSE);
}
return 0;
}
