NS_ComposeColors(nscolor aBG, nscolor aFG)
{
// This function uses colors that are non premultiplied alpha.
PRIntn r, g, b, a;
PRIntn bgAlpha = NS_GET_A(aBG);
PRIntn fgAlpha = NS_GET_A(aFG);
// Compute the final alpha of the blended color
// a = fgAlpha + bgAlpha*(255 - fgAlpha)/255;
FAST_DIVIDE_BY_255(a, bgAlpha*(255-fgAlpha));
a = fgAlpha + a;
PRIntn blendAlpha;
if (a == 0) {
// In this case the blended color is totally trasparent,
// we preserve the color information of the foreground color.
blendAlpha = 255;
} else {
blendAlpha = (fgAlpha*255)/a;
}
MOZ_BLEND(r, NS_GET_R(aBG), NS_GET_R(aFG), blendAlpha);
MOZ_BLEND(g, NS_GET_G(aBG), NS_GET_G(aFG), blendAlpha);
MOZ_BLEND(b, NS_GET_B(aBG), NS_GET_B(aFG), blendAlpha);
return NS_RGBA(r, g, b, a);
}
//------------------------------------------------------------------------------
void
nsSimplePageSequenceFrame::PaintPageSequence(nsRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt) {
nsRect rect = aDirtyRect;
float scale = PresContext()->GetPrintPreviewScale();
aRenderingContext.PushState();
nsPoint framePos = aPt;
aRenderingContext.Translate(framePos);
rect -= framePos;
aRenderingContext.Scale(scale, scale);
rect.ScaleRoundOut(1.0f / scale);
// Now the rect and the rendering coordinates are are relative to this frame.
// Loop over the pages and paint them.
nsIFrame* child = GetFirstChild(nsnull);
while (child) {
nsPoint pt = child->GetPosition();
// The rendering context has to be translated before each call to PaintFrame
aRenderingContext.PushState();
aRenderingContext.Translate(pt);
nsLayoutUtils::PaintFrame(&aRenderingContext, child,
nsRegion(rect - pt), NS_RGBA(0,0,0,0),
nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES);
aRenderingContext.PopState();
child = child->GetNextSibling();
}
aRenderingContext.PopState();
}
extern "C" NS_GFX_(nscolor) NS_DarkenColor(nscolor inColor)
{
PRIntn r, g, b, max;
r = NS_GET_R(inColor);
g = NS_GET_G(inColor);
b = NS_GET_B(inColor);
//10% of max color decrease across the board
r -= 25;
g -= 25;
b -= 25;
//figure out which color is largest
if (r > g)
{
if (b > r)
max = b;
else
max = r;
}
else
{
if (b > g)
max = b;
else
max = g;
}
//if we underflowed on this max color, decrease
//other components by the underflow amount
if (max < 0)
{
if (max == r)
{
g += max;
b += max;
}
else if (max == g)
{
r += max;
b += max;
}
else
{
r += max;
g += max;
}
}
//clamp
if (r < 0)
r = 0;
if (g < 0)
g = 0;
if (b < 0)
b = 0;
return NS_RGBA(r, g, b, NS_GET_A(inColor));
}
bool
PaintFrameCallback::operator()(gfxContext* aContext,
const gfxRect& aFillRect,
const gfxPattern::GraphicsFilter& aFilter,
const gfxMatrix& aTransform)
{
if (mFrame->GetStateBits() & NS_FRAME_DRAWING_AS_PAINTSERVER)
return false;
mFrame->AddStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
nsRenderingContext context;
context.Init(mFrame->PresContext()->DeviceContext(), aContext);
aContext->Save();
// Clip to aFillRect so that we don't paint outside.
aContext->NewPath();
aContext->Rectangle(aFillRect);
aContext->Clip();
gfxMatrix savedMatrix(aContext->CurrentMatrix());
aContext->Multiply(gfxMatrix(aTransform).Invert());
// nsLayoutUtils::PaintFrame will anchor its painting at mFrame. But we want
// to have it anchored at the top left corner of the bounding box of all of
// mFrame's continuations. So we add a translation transform.
nsRect bbox = nsSVGIntegrationUtils::GetNonSVGUserSpace(mFrame);
PRInt32 appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
gfxPoint offset = gfxPoint(bbox.x, bbox.y) / appUnitsPerDevPixel;
aContext->Multiply(gfxMatrix().Translate(-offset));
gfxSize paintServerSize =
gfxSize(mPaintServerSize.width, mPaintServerSize.height) /
mFrame->PresContext()->AppUnitsPerDevPixel();
// nsLayoutUtils::PaintFrame wants to render with paintServerSize, but we
// want it to render with mRenderSize, so we need to set up a scale transform.
gfxFloat scaleX = mRenderSize.width / paintServerSize.width;
gfxFloat scaleY = mRenderSize.height / paintServerSize.height;
gfxMatrix scaleMatrix = gfxMatrix().Scale(scaleX, scaleY);
aContext->Multiply(scaleMatrix);
// Draw.
nsRect dirty(bbox.x, bbox.y, mPaintServerSize.width, mPaintServerSize.height);
nsLayoutUtils::PaintFrame(&context, mFrame,
dirty, NS_RGBA(0, 0, 0, 0),
nsLayoutUtils::PAINT_IN_TRANSFORM |
nsLayoutUtils::PAINT_ALL_CONTINUATIONS);
aContext->SetMatrix(savedMatrix);
aContext->Restore();
mFrame->RemoveStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
return true;
}
//------------------------------------------------------------------------------
void
nsPageFrame::PaintPageContent(nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt) {
nsIFrame* pageContentFrame = mFrames.FirstChild();
nsRect rect = aDirtyRect;
float scale = PresContext()->GetPageScale();
aRenderingContext.PushState();
nsPoint framePos = aPt + pageContentFrame->GetOffsetTo(this);
aRenderingContext.Translate(framePos.x, framePos.y);
// aPt translates to coords relative to this, then margins translate to
// pageContentFrame's coords
rect -= framePos;
aRenderingContext.Scale(scale, scale);
rect.ScaleRoundOut(1.0f / scale);
// Make sure we don't draw where we aren't supposed to draw, especially
// when printing selection
nsRect clipRect(nsPoint(0, 0), pageContentFrame->GetSize());
// Note: this computation matches how we compute maxSize.height
// in nsPageFrame::Reflow
nscoord expectedPageContentHeight =
NSToCoordCeil((GetSize().height - mPD->mReflowMargin.TopBottom()) / scale);
if (clipRect.height > expectedPageContentHeight) {
// We're doing print-selection, with one long page-content frame.
// Clip to the appropriate page-content slice for the current page.
NS_ASSERTION(mPageNum > 0, "page num should be positive");
// Note: The pageContentFrame's y-position has been set such that a zero
// y-value matches the top edge of the current page. So, to clip to the
// current page's content (in coordinates *relative* to the page content
// frame), we just negate its y-position and add the top margin.
clipRect.y = NSToCoordCeil((-pageContentFrame->GetRect().y +
mPD->mReflowMargin.top) / scale);
clipRect.height = expectedPageContentHeight;
NS_ASSERTION(clipRect.y < pageContentFrame->GetSize().height,
"Should be clipping to region inside the page content bounds");
}
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsRect backgroundRect = nsRect(nsPoint(0, 0), pageContentFrame->GetSize());
nsCSSRendering::PaintBackground(PresContext(), aRenderingContext, this,
rect, backgroundRect,
nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES);
nsLayoutUtils::PaintFrame(&aRenderingContext, pageContentFrame,
nsRegion(rect), NS_RGBA(0,0,0,0),
nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES);
aRenderingContext.PopState();
}
//------------------------------------------------------------------------------
void
nsPageFrame::PaintPageContent(nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt) {
nsIFrame* pageContentFrame = mFrames.FirstChild();
nsRect rect = aDirtyRect;
float scale = PresContext()->GetPageScale();
aRenderingContext.PushState();
nsPoint framePos = aPt + pageContentFrame->GetOffsetTo(this);
aRenderingContext.Translate(framePos.x, framePos.y);
// aPt translates to coords relative to this, then margins translate to
// pageContentFrame's coords
rect -= framePos;
aRenderingContext.Scale(scale, scale);
rect.ScaleRoundOut(1.0f / scale);
// Make sure we don't draw where we aren't supposed to draw, especially
// when printing selection
nsRect clipRect(nsPoint(0, 0), pageContentFrame->GetSize());
// Note: this computation matches how we compute maxSize.height
// in nsPageFrame::Reflow
nscoord expectedPageContentHeight =
NSToCoordCeil((GetSize().height - mPD->mReflowMargin.TopBottom()) / scale);
if (clipRect.height > expectedPageContentHeight) {
// We're doing print-selection, with one long page-content frame.
// Clip to the appropriate page-content slice for the current page.
NS_ASSERTION(mPageNum > 0, "page num should be positive");
clipRect.y = expectedPageContentHeight * (mPageNum - 1);
clipRect.height = expectedPageContentHeight;
NS_ASSERTION(clipRect.y < pageContentFrame->GetSize().height,
"Should be clipping to region inside the page content bounds");
}
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
const nsStyleBorder* border = GetStyleBorder();
const nsStylePadding* padding = GetStylePadding();
nsRect backgroundRect = nsRect(nsPoint(0, 0), pageContentFrame->GetSize());
nsCSSRendering::PaintBackground(PresContext(), aRenderingContext, this,
rect, backgroundRect, *border, *padding,
PR_TRUE);
nsLayoutUtils::PaintFrame(&aRenderingContext, pageContentFrame,
nsRegion(rect), NS_RGBA(0,0,0,0));
aRenderingContext.PopState();
}
// Function to convert HSV color space into the RGB colorspace
// Hue is the primary color defined from 0 to 359 degrees
// Saturation is defined from 0 to 255. The higher the number.. the deeper
// the color Value is the brightness of the color. 0 is black, 255 is white.
void NS_HSV2RGB(nscolor &aColor, uint16_t aHue, uint16_t aSat, uint16_t aValue,
uint8_t aAlpha)
{
uint16_t r = 0, g = 0, b = 0;
uint16_t i, p, q, t;
double h, f, percent;
if ( aSat == 0 ){
// achromatic color, no hue is defined
r = aValue;
g = aValue;
b = aValue;
} else {
// hue in in degrees around the color wheel defined from
// 0 to 360 degrees.
if (aHue >= 360) {
aHue = 0;
}
// we break the color wheel into 6 areas.. these
// areas define how the saturation and value define the color.
// reds behave differently than the blues
h = (double)aHue / 60.0;
i = (uint16_t) floor(h);
f = h-(double)i;
percent = ((double)aValue/255.0); // this needs to be a value from 0 to 1, so a percentage
// can be calculated of the saturation.
p = (uint16_t)(percent*(255-aSat));
q = (uint16_t)(percent*(255-(aSat*f)));
t = (uint16_t)(percent*(255-(aSat*(1.0-f))));
// i is guaranteed to never be larger than 5.
switch(i){
case 0: r = aValue; g = t; b = p;break;
case 1: r = q; g = aValue; b = p;break;
case 2: r = p; g = aValue; b = t;break;
case 3: r = p; g = q; b = aValue;break;
case 4: r = t; g = p; b = aValue;break;
case 5: r = aValue; g = p; b = q;break;
}
}
aColor = NS_RGBA(r, g, b, aAlpha);
}
NS_ComposeColors(nscolor aBG, nscolor aFG)
{
PRIntn bgAlpha = NS_GET_A(aBG);
PRIntn r, g, b, a;
// First compute what we get drawing aBG onto RGBA(0,0,0,0)
MOZ_BLEND(r, 0, NS_GET_R(aBG), bgAlpha);
MOZ_BLEND(g, 0, NS_GET_G(aBG), bgAlpha);
MOZ_BLEND(b, 0, NS_GET_B(aBG), bgAlpha);
a = bgAlpha;
// Now draw aFG on top of that
PRIntn fgAlpha = NS_GET_A(aFG);
MOZ_BLEND(r, r, NS_GET_R(aFG), fgAlpha);
MOZ_BLEND(g, g, NS_GET_G(aFG), fgAlpha);
MOZ_BLEND(b, b, NS_GET_B(aFG), fgAlpha);
MOZ_BLEND(a, a, 255, fgAlpha);
return NS_RGBA(r, g, b, a);
}
void
nsSVGGradientFrame::GetStopInformation(PRInt32 aIndex,
float *aOffset,
nscolor *aStopColor,
float *aStopOpacity)
{
*aOffset = 0.0f;
*aStopColor = NS_RGBA(0, 0, 0, 0);
*aStopOpacity = 1.0f;
nsIFrame *stopFrame = nsnull;
GetStopFrame(aIndex, &stopFrame);
nsCOMPtr<nsIDOMSVGStopElement> stopElement =
do_QueryInterface(stopFrame->GetContent());
if (stopElement) {
nsCOMPtr<nsIDOMSVGAnimatedNumber> aNum;
stopElement->GetOffset(getter_AddRefs(aNum));
aNum->GetAnimVal(aOffset);
if (*aOffset < 0.0f)
*aOffset = 0.0f;
else if (*aOffset > 1.0f)
*aOffset = 1.0f;
}
if (stopFrame) {
*aStopColor = stopFrame->GetStyleSVGReset()->mStopColor;
*aStopOpacity = stopFrame->GetStyleSVGReset()->mStopOpacity;
}
#ifdef DEBUG
// One way or another we have an implementation problem if we get here
else if (stopElement) {
NS_WARNING("We *do* have a stop but can't use it because it doesn't have "
"a frame - we need frame free gradients and stops!");
}
else {
NS_ERROR("Don't call me with an invalid stop index!");
}
#endif
}
NS_IMETHODIMP
nsSVGForeignObjectFrame::PaintSVG(nsSVGRenderState *aContext,
const nsIntRect *aDirtyRect)
{
if (IsDisabled())
return NS_OK;
nsIFrame* kid = GetFirstChild(nsnull);
if (!kid)
return NS_OK;
gfxMatrix matrixForChildren = GetCanvasTMForChildren();
gfxMatrix matrix = GetCanvasTM();
nsRenderingContext *ctx = aContext->GetRenderingContext(this);
if (!ctx || matrixForChildren.IsSingular()) {
NS_WARNING("Can't render foreignObject element!");
return NS_ERROR_FAILURE;
}
/* Check if we need to draw anything. */
if (aDirtyRect) {
PRInt32 appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
if (!mRect.ToOutsidePixels(appUnitsPerDevPx).Intersects(*aDirtyRect))
return NS_OK;
}
gfxContext *gfx = aContext->GetGfxContext();
gfx->Save();
if (GetStyleDisplay()->IsScrollableOverflow()) {
float x, y, width, height;
static_cast<nsSVGElement*>(mContent)->
GetAnimatedLengthValues(&x, &y, &width, &height, nsnull);
gfxRect clipRect =
nsSVGUtils::GetClipRectForFrame(this, 0.0f, 0.0f, width, height);
nsSVGUtils::SetClipRect(gfx, matrix, clipRect);
}
gfx->Multiply(matrixForChildren);
// Transform the dirty rect into the rectangle containing the
// transformed dirty rect.
gfxMatrix invmatrix = matrix.Invert();
NS_ASSERTION(!invmatrix.IsSingular(),
"inverse of non-singular matrix should be non-singular");
gfxRect transDirtyRect = gfxRect(aDirtyRect->x, aDirtyRect->y,
aDirtyRect->width, aDirtyRect->height);
transDirtyRect = invmatrix.TransformBounds(transDirtyRect);
transDirtyRect.Scale(nsPresContext::AppUnitsPerCSSPixel());
nsPoint tl(NSToCoordFloor(transDirtyRect.X()),
NSToCoordFloor(transDirtyRect.Y()));
nsPoint br(NSToCoordCeil(transDirtyRect.XMost()),
NSToCoordCeil(transDirtyRect.YMost()));
nsRect kidDirtyRect(tl.x, tl.y, br.x - tl.x, br.y - tl.y);
kidDirtyRect.IntersectRect(kidDirtyRect, kid->GetRect());
PRUint32 flags = nsLayoutUtils::PAINT_IN_TRANSFORM;
if (aContext->IsPaintingToWindow()) {
flags |= nsLayoutUtils::PAINT_TO_WINDOW;
}
nsresult rv = nsLayoutUtils::PaintFrame(ctx, kid, nsRegion(kidDirtyRect),
NS_RGBA(0,0,0,0), flags);
gfx->Restore();
return rv;
}
NS_IMETHODIMP
nsSimplePageSequenceFrame::PrintNextPage()
{
// Print each specified page
// pageNum keeps track of the current page and what pages are printing
//
// printedPageNum keeps track of the current page number to be printed
// Note: When print al the pages or a page range the printed page shows the
// actual page number, when printing selection it prints the page number starting
// with the first page of the selection. For example if the user has a
// selection that starts on page 2 and ends on page 3, the page numbers when
// print are 1 and then two (which is different than printing a page range, where
// the page numbers would have been 2 and then 3)
if (mCurrentPageFrame == nsnull) {
return NS_ERROR_FAILURE;
}
PRBool printEvenPages, printOddPages;
mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintEvenPages, &printEvenPages);
mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintOddPages, &printOddPages);
// Begin printing of the document
nsDeviceContext *dc = PresContext()->DeviceContext();
nsresult rv = NS_OK;
// See whether we should print this page
mPrintThisPage = PR_TRUE;
// If printing a range of pages check whether the page number is in the
// range of pages to print
if (mDoingPageRange) {
if (mPageNum < mFromPageNum) {
mPrintThisPage = PR_FALSE;
} else if (mPageNum > mToPageNum) {
mPageNum++;
mCurrentPageFrame = nsnull;
return NS_OK;
}
}
// Check for printing of odd and even pages
if (mPageNum & 0x1) {
if (!printOddPages) {
mPrintThisPage = PR_FALSE; // don't print odd numbered page
}
} else {
if (!printEvenPages) {
mPrintThisPage = PR_FALSE; // don't print even numbered page
}
}
if (nsIPrintSettings::kRangeSelection == mPrintRangeType) {
mPrintThisPage = PR_TRUE;
}
if (mPrintThisPage) {
// XXX This is temporary fix for printing more than one page of a selection
// This does a poor man's "dump" pagination (see Bug 89353)
// It has laid out as one long page and now we are just moving or view up/down
// one page at a time and printing the contents of what is exposed by the rect.
// currently this does not work for IFrames
// I will soon improve this to work with IFrames
PRBool continuePrinting = PR_TRUE;
nscoord width, height;
width = PresContext()->GetPageSize().width;
height = PresContext()->GetPageSize().height;
height -= mMargin.top + mMargin.bottom;
width -= mMargin.left + mMargin.right;
nscoord selectionY = height;
nsIFrame* conFrame = mCurrentPageFrame->GetFirstChild(nsnull);
if (mSelectionHeight >= 0) {
conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -mYSelOffset));
nsContainerFrame::PositionChildViews(conFrame);
}
// cast the frame to be a page frame
nsPageFrame * pf = static_cast<nsPageFrame*>(mCurrentPageFrame);
pf->SetPageNumInfo(mPageNum, mTotalPages);
pf->SetSharedPageData(mPageData);
PRInt32 printedPageNum = 1;
while (continuePrinting) {
if (PresContext()->IsRootPaginatedDocument()) {
PR_PL(("\n"));
PR_PL(("***************** BeginPage *****************\n"));
rv = dc->BeginPage();
NS_ENSURE_SUCCESS(rv, rv);
}
PR_PL(("SeqFr::PrintNextPage -> %p PageNo: %d", pf, mPageNum));
nsRefPtr<nsRenderingContext> renderingContext;
dc->CreateRenderingContext(*getter_AddRefs(renderingContext));
NS_ENSURE_TRUE(renderingContext, NS_ERROR_OUT_OF_MEMORY);
#if defined(XP_UNIX) && !defined(XP_MACOSX)
// On linux, need to rotate landscape-mode output on printed surfaces
PRInt32 orientation;
mPageData->mPrintSettings->GetOrientation(&orientation);
if (nsIPrintSettings::kLandscapeOrientation == orientation) {
// Shift up by one landscape-page-height (in points) before we rotate.
float offset = POINTS_PER_INCH_FLOAT *
(mCurrentPageFrame->GetSize().height / float(dc->AppUnitsPerCSSInch()));
renderingContext->ThebesContext()->Translate(gfxPoint(offset, 0));
renderingContext->ThebesContext()->Rotate(M_PI/2);
}
#endif // XP_UNIX && !XP_MACOSX
nsRect drawingRect(nsPoint(0, 0),
mCurrentPageFrame->GetSize());
nsRegion drawingRegion(drawingRect);
nsLayoutUtils::PaintFrame(renderingContext, mCurrentPageFrame,
drawingRegion, NS_RGBA(0,0,0,0),
nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES);
if (mSelectionHeight >= 0 && selectionY < mSelectionHeight) {
selectionY += height;
printedPageNum++;
pf->SetPageNumInfo(printedPageNum, mTotalPages);
conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -height));
nsContainerFrame::PositionChildViews(conFrame);
PR_PL(("***************** End Page (PrintNextPage) *****************\n"));
rv = dc->EndPage();
NS_ENSURE_SUCCESS(rv, rv);
} else {
continuePrinting = PR_FALSE;
}
}
}
return rv;
}
NS_IMETHODIMP
nsSubDocumentFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
if (!IsVisibleForPainting(aBuilder))
return NS_OK;
if (aBuilder->IsForEventDelivery() &&
GetStyleVisibility()->mPointerEvents == NS_STYLE_POINTER_EVENTS_NONE)
return NS_OK;
nsresult rv = DisplayBorderBackgroundOutline(aBuilder, aLists);
NS_ENSURE_SUCCESS(rv, rv);
if (!mInnerView)
return NS_OK;
nsIView* subdocView = mInnerView->GetFirstChild();
if (!subdocView)
return NS_OK;
nsCOMPtr<nsIPresShell> presShell;
nsIFrame* f = static_cast<nsIFrame*>(subdocView->GetClientData());
if (f) {
presShell = f->PresContext()->PresShell();
} else {
// If we don't have a frame we use this roundabout way to get the pres shell.
if (!mFrameLoader)
return NS_OK;
nsCOMPtr<nsIDocShell> docShell;
mFrameLoader->GetDocShell(getter_AddRefs(docShell));
if (!docShell)
return NS_OK;
docShell->GetPresShell(getter_AddRefs(presShell));
if (!presShell)
return NS_OK;
}
PRBool suppressed = PR_TRUE;
presShell->IsPaintingSuppressed(&suppressed);
nsDisplayList childItems;
nsRect dirty;
if (f) {
dirty = aDirtyRect - f->GetOffsetTo(this);
aBuilder->EnterPresShell(f, dirty);
}
// Get the bounds of subdocView relative to the reference frame.
nsRect shellBounds = subdocView->GetBounds() +
mInnerView->GetPosition() +
GetOffsetTo(aBuilder->ReferenceFrame());
if (!aBuilder->IsForEventDelivery()) {
// Add the canvas background color.
nsCOMPtr<nsIPresShell_MOZILLA_1_9_2> presShell192 =
do_QueryInterface(presShell);
if (presShell192) {
rv = presShell192->AddCanvasBackgroundColorItem2(
*aBuilder, childItems, f ? f : this, &shellBounds,
NS_RGBA(0,0,0,0), PR_TRUE);
}
}
if (f && NS_SUCCEEDED(rv)) {
rv = f->BuildDisplayListForStackingContext(aBuilder, dirty, &childItems);
}
if (NS_SUCCEEDED(rv)) {
// Clip children to the child root frame's rectangle
rv = aLists.Content()->AppendNewToTop(
new (aBuilder) nsDisplayClip(this, this, &childItems, shellBounds));
}
// delete childItems in case of OOM
childItems.DeleteAll();
if (f) {
aBuilder->LeavePresShell(f, dirty);
}
return rv;
}
nsresult
nsLookAndFeel::NativeGetColor(ColorID aID, nscolor &aColor)
{
nsresult rv = NS_OK;
#define BASE_ACTIVE_COLOR NS_RGB(0xaa,0xaa,0xaa)
#define BASE_NORMAL_COLOR NS_RGB(0xff,0xff,0xff)
#define BASE_SELECTED_COLOR NS_RGB(0xaa,0xaa,0xaa)
#define BG_ACTIVE_COLOR NS_RGB(0xff,0xff,0xff)
#define BG_INSENSITIVE_COLOR NS_RGB(0xaa,0xaa,0xaa)
#define BG_NORMAL_COLOR NS_RGB(0xff,0xff,0xff)
#define BG_PRELIGHT_COLOR NS_RGB(0xee,0xee,0xee)
#define BG_SELECTED_COLOR NS_RGB(0x99,0x99,0x99)
#define DARK_NORMAL_COLOR NS_RGB(0x88,0x88,0x88)
#define FG_INSENSITIVE_COLOR NS_RGB(0x44,0x44,0x44)
#define FG_NORMAL_COLOR NS_RGB(0x00,0x00,0x00)
#define FG_PRELIGHT_COLOR NS_RGB(0x77,0x77,0x77)
#define FG_SELECTED_COLOR NS_RGB(0xaa,0xaa,0xaa)
#define LIGHT_NORMAL_COLOR NS_RGB(0xaa,0xaa,0xaa)
#define TEXT_ACTIVE_COLOR NS_RGB(0x99,0x99,0x99)
#define TEXT_NORMAL_COLOR NS_RGB(0x00,0x00,0x00)
#define TEXT_SELECTED_COLOR NS_RGB(0x00,0x00,0x00)
switch (aID) {
// These colors don't seem to be used for anything anymore in Mozilla
// (except here at least TextSelectBackground and TextSelectForeground)
// The CSS2 colors below are used.
case eColorID_WindowBackground:
aColor = BASE_NORMAL_COLOR;
break;
case eColorID_WindowForeground:
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID_WidgetBackground:
aColor = BG_NORMAL_COLOR;
break;
case eColorID_WidgetForeground:
aColor = FG_NORMAL_COLOR;
break;
case eColorID_WidgetSelectBackground:
aColor = BG_SELECTED_COLOR;
break;
case eColorID_WidgetSelectForeground:
aColor = FG_SELECTED_COLOR;
break;
case eColorID_Widget3DHighlight:
aColor = NS_RGB(0xa0,0xa0,0xa0);
break;
case eColorID_Widget3DShadow:
aColor = NS_RGB(0x40,0x40,0x40);
break;
case eColorID_TextBackground:
// not used?
aColor = BASE_NORMAL_COLOR;
break;
case eColorID_TextForeground:
// not used?
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID_TextSelectBackground:
aColor = NS_RGBA(0x33,0xb5,0xe5,0x66);
break;
case eColorID_IMESelectedRawTextBackground:
case eColorID_IMESelectedConvertedTextBackground:
// still used
aColor = BASE_SELECTED_COLOR;
break;
case eColorID_TextSelectForegroundCustom:
aColor = NS_RGB(0x4d,0x4d,0x4d);
break;
case eColorID_TextSelectForeground:
aColor = NS_CHANGE_COLOR_IF_SAME_AS_BG;
break;
case eColorID_IMESelectedRawTextForeground:
case eColorID_IMESelectedConvertedTextForeground:
// still used
aColor = TEXT_SELECTED_COLOR;
break;
case eColorID_IMERawInputBackground:
case eColorID_IMEConvertedTextBackground:
aColor = NS_TRANSPARENT;
break;
case eColorID_IMERawInputForeground:
case eColorID_IMEConvertedTextForeground:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
break;
case eColorID_IMERawInputUnderline:
case eColorID_IMEConvertedTextUnderline:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
break;
case eColorID_IMESelectedRawTextUnderline:
case eColorID_IMESelectedConvertedTextUnderline:
aColor = NS_TRANSPARENT;
break;
case eColorID_SpellCheckerUnderline:
aColor = NS_RGB(0xff, 0, 0);
break;
// css2 http://www.w3.org/TR/REC-CSS2/ui.html#system-colors
case eColorID_activeborder:
// active window border
aColor = BG_NORMAL_COLOR;
break;
case eColorID_activecaption:
// active window caption background
aColor = BG_NORMAL_COLOR;
break;
case eColorID_appworkspace:
// MDI background color
aColor = BG_NORMAL_COLOR;
break;
case eColorID_background:
// desktop background
aColor = BG_NORMAL_COLOR;
break;
case eColorID_captiontext:
// text in active window caption, size box, and scrollbar arrow box (!)
aColor = FG_NORMAL_COLOR;
break;
case eColorID_graytext:
// disabled text in windows, menus, etc.
aColor = FG_INSENSITIVE_COLOR;
break;
case eColorID_highlight:
// background of selected item
aColor = BASE_SELECTED_COLOR;
break;
case eColorID_highlighttext:
// text of selected item
aColor = TEXT_SELECTED_COLOR;
break;
case eColorID_inactiveborder:
// inactive window border
aColor = BG_NORMAL_COLOR;
break;
case eColorID_inactivecaption:
// inactive window caption
aColor = BG_INSENSITIVE_COLOR;
break;
case eColorID_inactivecaptiontext:
// text in inactive window caption
aColor = FG_INSENSITIVE_COLOR;
break;
case eColorID_infobackground:
// tooltip background color
aColor = BG_NORMAL_COLOR;
break;
case eColorID_infotext:
// tooltip text color
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID_menu:
// menu background
aColor = BG_NORMAL_COLOR;
break;
case eColorID_menutext:
// menu text
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID_scrollbar:
// scrollbar gray area
aColor = BG_ACTIVE_COLOR;
break;
case eColorID_threedface:
case eColorID_buttonface:
// 3-D face color
aColor = BG_NORMAL_COLOR;
break;
case eColorID_buttontext:
// text on push buttons
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID_buttonhighlight:
// 3-D highlighted edge color
case eColorID_threedhighlight:
// 3-D highlighted outer edge color
aColor = LIGHT_NORMAL_COLOR;
break;
case eColorID_threedlightshadow:
// 3-D highlighted inner edge color
aColor = BG_NORMAL_COLOR;
break;
case eColorID_buttonshadow:
// 3-D shadow edge color
case eColorID_threedshadow:
// 3-D shadow inner edge color
aColor = DARK_NORMAL_COLOR;
break;
case eColorID_threeddarkshadow:
// 3-D shadow outer edge color
aColor = NS_RGB(0,0,0);
break;
case eColorID_window:
case eColorID_windowframe:
aColor = BG_NORMAL_COLOR;
break;
case eColorID_windowtext:
aColor = FG_NORMAL_COLOR;
break;
case eColorID__moz_eventreerow:
case eColorID__moz_field:
aColor = BASE_NORMAL_COLOR;
break;
case eColorID__moz_fieldtext:
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID__moz_dialog:
aColor = BG_NORMAL_COLOR;
break;
case eColorID__moz_dialogtext:
aColor = FG_NORMAL_COLOR;
break;
case eColorID__moz_dragtargetzone:
aColor = BG_SELECTED_COLOR;
break;
case eColorID__moz_buttondefault:
// default button border color
aColor = NS_RGB(0,0,0);
break;
case eColorID__moz_buttonhoverface:
aColor = BG_PRELIGHT_COLOR;
break;
case eColorID__moz_buttonhovertext:
aColor = FG_PRELIGHT_COLOR;
break;
case eColorID__moz_cellhighlight:
case eColorID__moz_html_cellhighlight:
aColor = BASE_ACTIVE_COLOR;
break;
case eColorID__moz_cellhighlighttext:
case eColorID__moz_html_cellhighlighttext:
aColor = TEXT_ACTIVE_COLOR;
break;
case eColorID__moz_menuhover:
aColor = BG_PRELIGHT_COLOR;
break;
case eColorID__moz_menuhovertext:
aColor = FG_PRELIGHT_COLOR;
break;
case eColorID__moz_oddtreerow:
aColor = NS_TRANSPARENT;
break;
case eColorID__moz_nativehyperlinktext:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
break;
case eColorID__moz_comboboxtext:
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID__moz_combobox:
aColor = BG_NORMAL_COLOR;
break;
case eColorID__moz_menubartext:
aColor = TEXT_NORMAL_COLOR;
break;
case eColorID__moz_menubarhovertext:
aColor = FG_PRELIGHT_COLOR;
break;
default:
/* default color is BLACK */
aColor = 0;
rv = NS_ERROR_FAILURE;
break;
}
return rv;
}
void
nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult) const
{
// eCSSProperty_UNKNOWN gets used for some recursive calls below.
NS_ABORT_IF_FALSE((0 <= aProperty &&
aProperty <= eCSSProperty_COUNT_no_shorthands) ||
aProperty == eCSSProperty_UNKNOWN,
"property ID out of range");
nsCSSUnit unit = GetUnit();
if (unit == eCSSUnit_Null) {
return;
}
if (eCSSUnit_String <= unit && unit <= eCSSUnit_Attr) {
if (unit == eCSSUnit_Attr) {
aResult.AppendLiteral("attr(");
}
nsAutoString buffer;
GetStringValue(buffer);
if (unit == eCSSUnit_String) {
nsStyleUtil::AppendEscapedCSSString(buffer, aResult);
} else if (unit == eCSSUnit_Families) {
// XXX We really need to do *some* escaping.
aResult.Append(buffer);
} else {
nsStyleUtil::AppendEscapedCSSIdent(buffer, aResult);
}
}
else if (eCSSUnit_Array <= unit && unit <= eCSSUnit_Steps) {
switch (unit) {
case eCSSUnit_Counter: aResult.AppendLiteral("counter("); break;
case eCSSUnit_Counters: aResult.AppendLiteral("counters("); break;
case eCSSUnit_Cubic_Bezier: aResult.AppendLiteral("cubic-bezier("); break;
case eCSSUnit_Steps: aResult.AppendLiteral("steps("); break;
default: break;
}
nsCSSValue::Array *array = GetArrayValue();
bool mark = false;
for (size_t i = 0, i_end = array->Count(); i < i_end; ++i) {
if (mark && array->Item(i).GetUnit() != eCSSUnit_Null) {
if (unit == eCSSUnit_Array &&
eCSSProperty_transition_timing_function != aProperty)
aResult.AppendLiteral(" ");
else
aResult.AppendLiteral(", ");
}
if (unit == eCSSUnit_Steps && i == 1) {
NS_ABORT_IF_FALSE(array->Item(i).GetUnit() == eCSSUnit_Enumerated &&
(array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START ||
array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END),
"unexpected value");
if (array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START) {
aResult.AppendLiteral("start");
} else {
aResult.AppendLiteral("end");
}
continue;
}
nsCSSProperty prop =
((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) &&
i == array->Count() - 1)
? eCSSProperty_list_style_type : aProperty;
if (array->Item(i).GetUnit() != eCSSUnit_Null) {
array->Item(i).AppendToString(prop, aResult);
mark = true;
}
}
if (eCSSUnit_Array == unit &&
aProperty == eCSSProperty_transition_timing_function) {
aResult.AppendLiteral(")");
}
}
/* Although Function is backed by an Array, we'll handle it separately
* because it's a bit quirky.
*/
else if (eCSSUnit_Function == unit) {
const nsCSSValue::Array* array = GetArrayValue();
NS_ABORT_IF_FALSE(array->Count() >= 1,
"Functions must have at least one element for the name.");
/* Append the function name. */
const nsCSSValue& functionName = array->Item(0);
if (functionName.GetUnit() == eCSSUnit_Enumerated) {
// We assume that the first argument is always of nsCSSKeyword type.
const nsCSSKeyword functionId =
static_cast<nsCSSKeyword>(functionName.GetIntValue());
nsStyleUtil::AppendEscapedCSSIdent(
NS_ConvertASCIItoUTF16(nsCSSKeywords::GetStringValue(functionId)),
aResult);
} else {
functionName.AppendToString(aProperty, aResult);
}
aResult.AppendLiteral("(");
/* Now, step through the function contents, writing each of them as we go. */
for (size_t index = 1; index < array->Count(); ++index) {
array->Item(index).AppendToString(aProperty, aResult);
/* If we're not at the final element, append a comma. */
if (index + 1 != array->Count())
aResult.AppendLiteral(", ");
}
/* Finally, append the closing parenthesis. */
aResult.AppendLiteral(")");
}
else if (IsCalcUnit()) {
NS_ABORT_IF_FALSE(GetUnit() == eCSSUnit_Calc, "unexpected unit");
CSSValueSerializeCalcOps ops(aProperty, aResult);
css::SerializeCalc(*this, ops);
}
else if (eCSSUnit_Integer == unit) {
aResult.AppendInt(GetIntValue(), 10);
}
else if (eCSSUnit_Enumerated == unit) {
if (eCSSProperty_text_decoration_line == aProperty) {
PRInt32 intValue = GetIntValue();
if (NS_STYLE_TEXT_DECORATION_LINE_NONE == intValue) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
// Ignore the "override all" internal value.
// (It doesn't have a string representation.)
intValue &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERRIDE_ALL;
nsStyleUtil::AppendBitmaskCSSValue(
aProperty, intValue,
NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE,
NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS,
aResult);
}
}
else if (eCSSProperty_marks == aProperty) {
PRInt32 intValue = GetIntValue();
if (intValue == NS_STYLE_PAGE_MARKS_NONE) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
NS_STYLE_PAGE_MARKS_CROP,
NS_STYLE_PAGE_MARKS_REGISTER,
aResult);
}
}
else if (eCSSProperty_unicode_bidi == aProperty) {
PR_STATIC_ASSERT(NS_STYLE_UNICODE_BIDI_NORMAL == 0);
PRInt32 intValue = GetIntValue();
if (NS_STYLE_UNICODE_BIDI_NORMAL == intValue) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
nsStyleUtil::AppendBitmaskCSSValue(
aProperty, intValue,
NS_STYLE_UNICODE_BIDI_EMBED,
NS_STYLE_UNICODE_BIDI_PLAINTEXT,
aResult);
}
}
else {
const nsAFlatCString& name = nsCSSProps::LookupPropertyValue(aProperty, GetIntValue());
AppendASCIItoUTF16(name, aResult);
}
}
else if (eCSSUnit_EnumColor == unit) {
// we can lookup the property in the ColorTable and then
// get a string mapping the name
nsCAutoString str;
if (nsCSSProps::GetColorName(GetIntValue(), str)){
AppendASCIItoUTF16(str, aResult);
} else {
NS_ABORT_IF_FALSE(false, "bad color value");
}
}
else if (eCSSUnit_Color == unit) {
nscolor color = GetColorValue();
if (color == NS_RGBA(0, 0, 0, 0)) {
// Use the strictest match for 'transparent' so we do correct
// round-tripping of all other rgba() values.
aResult.AppendLiteral("transparent");
} else {
PRUint8 a = NS_GET_A(color);
if (a < 255) {
aResult.AppendLiteral("rgba(");
} else {
aResult.AppendLiteral("rgb(");
}
NS_NAMED_LITERAL_STRING(comma, ", ");
aResult.AppendInt(NS_GET_R(color), 10);
aResult.Append(comma);
aResult.AppendInt(NS_GET_G(color), 10);
aResult.Append(comma);
aResult.AppendInt(NS_GET_B(color), 10);
if (a < 255) {
aResult.Append(comma);
aResult.AppendFloat(nsStyleUtil::ColorComponentToFloat(a));
}
aResult.Append(PRUnichar(')'));
}
}
else if (eCSSUnit_URL == unit || eCSSUnit_Image == unit) {
aResult.Append(NS_LITERAL_STRING("url("));
nsStyleUtil::AppendEscapedCSSString(
nsDependentString(GetOriginalURLValue()), aResult);
aResult.Append(NS_LITERAL_STRING(")"));
}
else if (eCSSUnit_Element == unit) {
aResult.Append(NS_LITERAL_STRING("-moz-element(#"));
nsAutoString tmpStr;
GetStringValue(tmpStr);
nsStyleUtil::AppendEscapedCSSIdent(tmpStr, aResult);
aResult.Append(NS_LITERAL_STRING(")"));
}
else if (eCSSUnit_Percent == unit) {
aResult.AppendFloat(GetPercentValue() * 100.0f);
}
else if (eCSSUnit_Percent < unit) { // length unit
aResult.AppendFloat(GetFloatValue());
}
else if (eCSSUnit_Gradient == unit) {
nsCSSValueGradient* gradient = GetGradientValue();
if (gradient->mIsRepeating) {
if (gradient->mIsRadial)
aResult.AppendLiteral("-moz-repeating-radial-gradient(");
else
aResult.AppendLiteral("-moz-repeating-linear-gradient(");
} else {
if (gradient->mIsRadial)
aResult.AppendLiteral("-moz-radial-gradient(");
else
aResult.AppendLiteral("-moz-linear-gradient(");
}
if (gradient->mIsToCorner) {
aResult.AppendLiteral("to");
NS_ABORT_IF_FALSE(gradient->mBgPos.mXValue.GetUnit() == eCSSUnit_Enumerated &&
gradient->mBgPos.mYValue.GetUnit() == eCSSUnit_Enumerated,
"unexpected unit");
if (!(gradient->mBgPos.mXValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) {
aResult.AppendLiteral(" ");
gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position,
aResult);
}
if (!(gradient->mBgPos.mYValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) {
aResult.AppendLiteral(" ");
gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position,
aResult);
}
aResult.AppendLiteral(", ");
} else if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None ||
gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None ||
gradient->mAngle.GetUnit() != eCSSUnit_None) {
if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) {
gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position,
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) {
gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position,
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mAngle.GetUnit() != eCSSUnit_None) {
gradient->mAngle.AppendToString(aProperty, aResult);
}
aResult.AppendLiteral(", ");
}
if (gradient->mIsRadial &&
(gradient->mRadialShape.GetUnit() != eCSSUnit_None ||
gradient->mRadialSize.GetUnit() != eCSSUnit_None)) {
if (gradient->mRadialShape.GetUnit() != eCSSUnit_None) {
NS_ABORT_IF_FALSE(gradient->mRadialShape.GetUnit() ==
eCSSUnit_Enumerated,
"bad unit for radial gradient shape");
PRInt32 intValue = gradient->mRadialShape.GetIntValue();
NS_ABORT_IF_FALSE(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR,
"radial gradient with linear shape?!");
AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
nsCSSProps::kRadialGradientShapeKTable),
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mRadialSize.GetUnit() != eCSSUnit_None) {
NS_ABORT_IF_FALSE(gradient->mRadialSize.GetUnit() ==
eCSSUnit_Enumerated,
"bad unit for radial gradient size");
PRInt32 intValue = gradient->mRadialSize.GetIntValue();
AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
nsCSSProps::kRadialGradientSizeKTable),
aResult);
}
aResult.AppendLiteral(", ");
}
for (PRUint32 i = 0 ;;) {
gradient->mStops[i].mColor.AppendToString(aProperty, aResult);
if (gradient->mStops[i].mLocation.GetUnit() != eCSSUnit_None) {
aResult.AppendLiteral(" ");
gradient->mStops[i].mLocation.AppendToString(aProperty, aResult);
}
if (++i == gradient->mStops.Length()) {
break;
}
aResult.AppendLiteral(", ");
}
aResult.AppendLiteral(")");
} else if (eCSSUnit_Pair == unit) {
GetPairValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_Triplet == unit) {
GetTripletValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_Rect == unit) {
GetRectValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_List == unit || eCSSUnit_ListDep == unit) {
GetListValue()->AppendToString(aProperty, aResult);
} else if (eCSSUnit_PairList == unit || eCSSUnit_PairListDep == unit) {
GetPairListValue()->AppendToString(aProperty, aResult);
}
switch (unit) {
case eCSSUnit_Null: break;
case eCSSUnit_Auto: aResult.AppendLiteral("auto"); break;
case eCSSUnit_Inherit: aResult.AppendLiteral("inherit"); break;
case eCSSUnit_Initial: aResult.AppendLiteral("-moz-initial"); break;
case eCSSUnit_None: aResult.AppendLiteral("none"); break;
case eCSSUnit_Normal: aResult.AppendLiteral("normal"); break;
case eCSSUnit_System_Font: aResult.AppendLiteral("-moz-use-system-font"); break;
case eCSSUnit_All: aResult.AppendLiteral("all"); break;
case eCSSUnit_Dummy:
case eCSSUnit_DummyInherit:
NS_ABORT_IF_FALSE(false, "should never serialize");
break;
case eCSSUnit_String: break;
case eCSSUnit_Ident: break;
case eCSSUnit_Families: break;
case eCSSUnit_URL: break;
case eCSSUnit_Image: break;
case eCSSUnit_Element: break;
case eCSSUnit_Array: break;
case eCSSUnit_Attr:
case eCSSUnit_Cubic_Bezier:
case eCSSUnit_Steps:
case eCSSUnit_Counter:
case eCSSUnit_Counters: aResult.Append(PRUnichar(')')); break;
case eCSSUnit_Local_Font: break;
case eCSSUnit_Font_Format: break;
case eCSSUnit_Function: break;
case eCSSUnit_Calc: break;
case eCSSUnit_Calc_Plus: break;
case eCSSUnit_Calc_Minus: break;
case eCSSUnit_Calc_Times_L: break;
case eCSSUnit_Calc_Times_R: break;
case eCSSUnit_Calc_Divided: break;
case eCSSUnit_Integer: break;
case eCSSUnit_Enumerated: break;
case eCSSUnit_EnumColor: break;
case eCSSUnit_Color: break;
case eCSSUnit_Percent: aResult.Append(PRUnichar('%')); break;
case eCSSUnit_Number: break;
case eCSSUnit_Gradient: break;
case eCSSUnit_Pair: break;
case eCSSUnit_Triplet: break;
case eCSSUnit_Rect: break;
case eCSSUnit_List: break;
case eCSSUnit_ListDep: break;
case eCSSUnit_PairList: break;
case eCSSUnit_PairListDep: break;
case eCSSUnit_Inch: aResult.AppendLiteral("in"); break;
case eCSSUnit_Millimeter: aResult.AppendLiteral("mm"); break;
case eCSSUnit_PhysicalMillimeter: aResult.AppendLiteral("mozmm"); break;
case eCSSUnit_Centimeter: aResult.AppendLiteral("cm"); break;
case eCSSUnit_Point: aResult.AppendLiteral("pt"); break;
case eCSSUnit_Pica: aResult.AppendLiteral("pc"); break;
case eCSSUnit_EM: aResult.AppendLiteral("em"); break;
case eCSSUnit_XHeight: aResult.AppendLiteral("ex"); break;
case eCSSUnit_Char: aResult.AppendLiteral("ch"); break;
case eCSSUnit_RootEM: aResult.AppendLiteral("rem"); break;
case eCSSUnit_Pixel: aResult.AppendLiteral("px"); break;
case eCSSUnit_Degree: aResult.AppendLiteral("deg"); break;
case eCSSUnit_Grad: aResult.AppendLiteral("grad"); break;
case eCSSUnit_Radian: aResult.AppendLiteral("rad"); break;
case eCSSUnit_Hertz: aResult.AppendLiteral("Hz"); break;
case eCSSUnit_Kilohertz: aResult.AppendLiteral("kHz"); break;
case eCSSUnit_Seconds: aResult.Append(PRUnichar('s')); break;
case eCSSUnit_Milliseconds: aResult.AppendLiteral("ms"); break;
}
}
NS_IMETHODIMP
nsSVGForeignObjectFrame::PaintSVG(nsRenderingContext *aContext,
const nsIntRect *aDirtyRect)
{
if (IsDisabled())
return NS_OK;
nsIFrame* kid = GetFirstPrincipalChild();
if (!kid)
return NS_OK;
gfxMatrix matrixForChildren = GetCanvasTMForChildren();
gfxMatrix matrix = GetCanvasTM();
if (matrixForChildren.IsSingular()) {
NS_WARNING("Can't render foreignObject element!");
return NS_ERROR_FAILURE;
}
nsRect kidDirtyRect = kid->GetVisualOverflowRect();
/* Check if we need to draw anything. */
if (aDirtyRect) {
// Transform the dirty rect into app units in our userspace.
gfxMatrix invmatrix = matrix;
invmatrix.Invert();
NS_ASSERTION(!invmatrix.IsSingular(),
"inverse of non-singular matrix should be non-singular");
gfxRect transDirtyRect = gfxRect(aDirtyRect->x, aDirtyRect->y,
aDirtyRect->width, aDirtyRect->height);
transDirtyRect = invmatrix.TransformBounds(transDirtyRect);
kidDirtyRect.IntersectRect(kidDirtyRect,
nsLayoutUtils::RoundGfxRectToAppRect(transDirtyRect,
PresContext()->AppUnitsPerCSSPixel()));
// XXX after bug 614732 is fixed, we will compare mRect with aDirtyRect,
// not with kidDirtyRect. I.e.
// PRInt32 appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
// mRect.ToOutsidePixels(appUnitsPerDevPx).Intersects(*aDirtyRect)
if (kidDirtyRect.IsEmpty())
return NS_OK;
}
gfxContext *gfx = aContext->ThebesContext();
gfx->Save();
if (GetStyleDisplay()->IsScrollableOverflow()) {
float x, y, width, height;
static_cast<nsSVGElement*>(mContent)->
GetAnimatedLengthValues(&x, &y, &width, &height, nsnull);
gfxRect clipRect =
nsSVGUtils::GetClipRectForFrame(this, 0.0f, 0.0f, width, height);
nsSVGUtils::SetClipRect(gfx, matrix, clipRect);
}
gfx->Multiply(matrixForChildren);
PRUint32 flags = nsLayoutUtils::PAINT_IN_TRANSFORM;
if (SVGAutoRenderState::IsPaintingToWindow(aContext)) {
flags |= nsLayoutUtils::PAINT_TO_WINDOW;
}
nsresult rv = nsLayoutUtils::PaintFrame(aContext, kid, nsRegion(kidDirtyRect),
NS_RGBA(0,0,0,0), flags);
gfx->Restore();
return rv;
}
void NS_GetSpecial3DColors(nscolor aResult[2],
nscolor aBackgroundColor,
nscolor aBorderColor)
{
uint8_t f0, f1;
uint8_t r, g, b;
uint8_t rb = NS_GET_R(aBorderColor);
uint8_t gb = NS_GET_G(aBorderColor);
uint8_t bb = NS_GET_B(aBorderColor);
uint8_t a = NS_GET_A(aBorderColor);
// This needs to be optimized.
// Calculating background brightness again and again is
// a waste of time!!!. Just calculate it only once.
// .....somehow!!!
uint8_t red = NS_GET_R(aBackgroundColor);
uint8_t green = NS_GET_G(aBackgroundColor);
uint8_t blue = NS_GET_B(aBackgroundColor);
uint8_t elementBrightness = NS_GetBrightness(rb,gb,bb);
uint8_t backgroundBrightness = NS_GetBrightness(red, green, blue);
if (backgroundBrightness < COLOR_DARK_THRESHOLD) {
f0 = COLOR_DARK_BS_FACTOR;
f1 = COLOR_DARK_TS_FACTOR;
if(elementBrightness == MAX_DARKNESS)
{
rb = NS_GET_R(DARK_GRAY);
gb = NS_GET_G(DARK_GRAY);
bb = NS_GET_B(DARK_GRAY);
}
}else if (backgroundBrightness > COLOR_LIGHT_THRESHOLD) {
f0 = COLOR_LITE_BS_FACTOR;
f1 = COLOR_LITE_TS_FACTOR;
if(elementBrightness == MAX_BRIGHTNESS)
{
rb = NS_GET_R(LIGHT_GRAY);
gb = NS_GET_G(LIGHT_GRAY);
bb = NS_GET_B(LIGHT_GRAY);
}
}else {
f0 = COLOR_DARK_BS_FACTOR +
(backgroundBrightness *
(COLOR_LITE_BS_FACTOR - COLOR_DARK_BS_FACTOR) / MAX_COLOR);
f1 = COLOR_DARK_TS_FACTOR +
(backgroundBrightness *
(COLOR_LITE_TS_FACTOR - COLOR_DARK_TS_FACTOR) / MAX_COLOR);
}
r = rb - (f0 * rb / 100);
g = gb - (f0 * gb / 100);
b = bb - (f0 * bb / 100);
aResult[0] = NS_RGBA(r, g, b, a);
r = rb + (f1 * (MAX_COLOR - rb) / 100);
g = gb + (f1 * (MAX_COLOR - gb) / 100);
b = bb + (f1 * (MAX_COLOR - bb) / 100);
aResult[1] = NS_RGBA(r, g, b, a);
}
extern "C" NS_GFX_(nscolor) NS_BrightenColor(nscolor inColor)
{
PRIntn r, g, b, max, over;
r = NS_GET_R(inColor);
g = NS_GET_G(inColor);
b = NS_GET_B(inColor);
//10% of max color increase across the board
r += 25;
g += 25;
b += 25;
//figure out which color is largest
if (r > g)
{
if (b > r)
max = b;
else
max = r;
}
else
{
if (b > g)
max = b;
else
max = g;
}
//if we overflowed on this max color, increase
//other components by the overflow amount
if (max > 255)
{
over = max - 255;
if (max == r)
{
g += over;
b += over;
}
else if (max == g)
{
r += over;
b += over;
}
else
{
r += over;
g += over;
}
}
//clamp
if (r > 255)
r = 255;
if (g > 255)
g = 255;
if (b > 255)
b = 255;
return NS_RGBA(r, g, b, NS_GET_A(inColor));
}
