void
nsPageFrame::PaintPrintPreviewBackground(nsIRenderingContext& aRenderingContext,
nsPoint aPt)
{
// fill page with White
aRenderingContext.SetColor(NS_RGB(255,255,255));
// REVIEW: this used to have rect's width and height be the
// mClipRect if specialClipIsSet ... but that seems completely bogus
// and inconsistent with the painting of the shadow below
nsRect rect(aPt, GetSize());
rect.width -= mPD->mShadowSize.width;
rect.height -= mPD->mShadowSize.height;
aRenderingContext.FillRect(rect);
// draw line around outside of page
aRenderingContext.SetColor(NS_RGB(0,0,0));
aRenderingContext.DrawRect(rect);
if (mPD->mShadowSize.width > 0 && mPD->mShadowSize.height > 0) {
aRenderingContext.SetColor(NS_RGB(51,51,51));
nsRect r(aPt.x,aPt.y, mRect.width, mRect.height);
nsRect shadowRect;
shadowRect.x = r.x + r.width - mPD->mShadowSize.width;
shadowRect.y = r.y + mPD->mShadowSize.height;
shadowRect.width = mPD->mShadowSize.width;
shadowRect.height = r.height - mPD->mShadowSize.height;
aRenderingContext.FillRect(shadowRect);
shadowRect.x = r.x + mPD->mShadowSize.width;
shadowRect.y = r.y + r.height - mPD->mShadowSize.height;
shadowRect.width = r.width - mPD->mShadowSize.width;
shadowRect.height = mPD->mShadowSize.height;
aRenderingContext.FillRect(shadowRect);
}
}
nsStyleGradient*
Gecko_CreateGradient(uint8_t aShape,
uint8_t aSize,
bool aRepeating,
bool aLegacySyntax,
uint32_t aStopCount)
{
nsStyleGradient* result = new nsStyleGradient();
result->mShape = aShape;
result->mSize = aSize;
result->mRepeating = aRepeating;
result->mLegacySyntax = aLegacySyntax;
result->mAngle.SetNoneValue();
result->mBgPosX.SetNoneValue();
result->mBgPosY.SetNoneValue();
result->mRadiusX.SetNoneValue();
result->mRadiusY.SetNoneValue();
nsStyleGradientStop dummyStop;
dummyStop.mLocation.SetNoneValue();
dummyStop.mColor = NS_RGB(0, 0, 0);
dummyStop.mIsInterpolationHint = 0;
for (uint32_t i = 0; i < aStopCount; i++) {
result->mStops.AppendElement(dummyStop);
}
return result;
}
GraphicsState::GraphicsState()
{
mMatrix = nsnull;
mLocalClip.x = mLocalClip.y = mLocalClip.width = mLocalClip.height = 0;
mClipRegion = nsnull;
mColor = NS_RGB(0,0,0);
mLineStyle = nsLineStyle_kSolid;
mFontMetrics = nsnull;
}
int NS_GetBrightness(uint8_t aRed, uint8_t aGreen, uint8_t aBlue)
{
uint8_t intensity = (aRed + aGreen + aBlue) / 3;
uint8_t luminosity = NS_GetLuminosity(NS_RGB(aRed, aGreen, aBlue)) / 1000;
return ((intensity * INTENSITY_FACTOR) +
(luminosity * LUMINOSITY_FACTOR)) / 100;
}
static void
PaintDebugPlaceholder(nsIFrame* aFrame, nsRenderingContext* aCtx,
const nsRect& aDirtyRect, nsPoint aPt)
{
aCtx->SetColor(NS_RGB(0, 255, 255));
nscoord x = nsPresContext::CSSPixelsToAppUnits(-5);
aCtx->FillRect(aPt.x + x, aPt.y,
nsPresContext::CSSPixelsToAppUnits(13), nsPresContext::CSSPixelsToAppUnits(3));
nscoord y = nsPresContext::CSSPixelsToAppUnits(-10);
aCtx->FillRect(aPt.x, aPt.y + y,
nsPresContext::CSSPixelsToAppUnits(3), nsPresContext::CSSPixelsToAppUnits(10));
}
//ASSURE DIFFERENT COLORS for selection
inline nscolor EnsureDifferentColors(nscolor colorA, nscolor colorB)
{
if (colorA == colorB)
{
nscolor res;
res = NS_RGB(NS_GET_R(colorA) ^ 0xff,
NS_GET_G(colorA) ^ 0xff,
NS_GET_B(colorA) ^ 0xff);
return res;
}
return colorA;
}
void
nsPageFrame::PaintHeaderFooter(nsIRenderingContext& aRenderingContext,
nsPoint aPt)
{
nsPresContext* pc = PresContext();
if (!mPD->mPrintSettings) {
if (pc->Type() == nsPresContext::eContext_PrintPreview || pc->IsDynamic())
mPD->mPrintSettings = pc->GetPrintSettings();
if (!mPD->mPrintSettings)
return;
}
nsRect rect(aPt.x, aPt.y, mRect.width - mPD->mShadowSize.width,
mRect.height - mPD->mShadowSize.height);
aRenderingContext.SetColor(NS_RGB(0,0,0));
// Get the FontMetrics to determine width.height of strings
nsCOMPtr<nsIFontMetrics> fontMet;
pc->DeviceContext()->GetMetricsFor(*mPD->mHeadFootFont,
pc->GetUserFontSet(),
*getter_AddRefs(fontMet));
aRenderingContext.SetFont(fontMet);
nscoord ascent = 0;
nscoord visibleHeight = 0;
if (fontMet) {
fontMet->GetHeight(visibleHeight);
fontMet->GetMaxAscent(ascent);
}
// print document headers and footers
nsXPIDLString headerLeft, headerCenter, headerRight;
mPD->mPrintSettings->GetHeaderStrLeft(getter_Copies(headerLeft));
mPD->mPrintSettings->GetHeaderStrCenter(getter_Copies(headerCenter));
mPD->mPrintSettings->GetHeaderStrRight(getter_Copies(headerRight));
DrawHeaderFooter(aRenderingContext, eHeader,
headerLeft, headerCenter, headerRight,
rect, ascent, visibleHeight);
nsXPIDLString footerLeft, footerCenter, footerRight;
mPD->mPrintSettings->GetFooterStrLeft(getter_Copies(footerLeft));
mPD->mPrintSettings->GetFooterStrCenter(getter_Copies(footerCenter));
mPD->mPrintSettings->GetFooterStrRight(getter_Copies(footerRight));
DrawHeaderFooter(aRenderingContext, eFooter,
footerLeft, footerCenter, footerRight,
rect, ascent, visibleHeight);
}
// compatible with legacy Nav behavior
extern "C" NS_GFX_(PRBool) NS_LooseHexToRGB(const nsString& aColorSpec, nscolor* aResult)
{
// XXXldb nsStackString<30>
NS_LossyConvertUCS2toASCII buffer(aColorSpec);
int nameLen = buffer.Length();
const char* colorSpec = buffer.get();
if ('#' == colorSpec[0]) {
++colorSpec;
--nameLen;
}
if (3 < nameLen) {
// Convert the ascii to binary
int dpc = (nameLen / 3) + (((nameLen % 3) != 0) ? 1 : 0);
if (4 < dpc) {
dpc = 4;
}
// Translate components from hex to binary
int r = ComponentValue(colorSpec, nameLen, 0, dpc);
int g = ComponentValue(colorSpec, nameLen, 1, dpc);
int b = ComponentValue(colorSpec, nameLen, 2, dpc);
NS_ASSERTION((r >= 0) && (r <= 255), "bad r");
NS_ASSERTION((g >= 0) && (g <= 255), "bad g");
NS_ASSERTION((b >= 0) && (b <= 255), "bad b");
if (nsnull != aResult) {
*aResult = NS_RGB(r, g, b);
}
}
else {
if (nsnull != aResult) {
*aResult = NS_RGB(0, 0, 0);
}
}
return PR_TRUE;
}
nsresult
nsTableCellFrame::DecorateForSelection(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsStyleBackground *aStyleColor)
{
PRInt16 displaySelection;
displaySelection = DisplaySelection(aPresContext);
if (displaySelection) {
PRBool isSelected =
(GetStateBits() & NS_FRAME_SELECTED_CONTENT) == NS_FRAME_SELECTED_CONTENT;
if (isSelected) {
nsIFrameSelection *frameSelection =
aPresContext->PresShell()->FrameSelection();
PRBool tableCellSelectionMode;
nsresult result =
frameSelection->GetTableCellSelection(&tableCellSelectionMode);
if (NS_SUCCEEDED(result) && tableCellSelectionMode) {
nscolor bordercolor;
if (displaySelection == nsISelectionController::SELECTION_DISABLED) {
bordercolor = NS_RGB(176,176,176);// disabled color
}
else {
aPresContext->LookAndFeel()->
GetColor(nsILookAndFeel::eColor_TextSelectBackground,
bordercolor);
}
PRInt16 t2p = (PRInt16) aPresContext->PixelsToTwips();
if ((mRect.width >(3*t2p)) && (mRect.height > (3*t2p)))
{
//compare bordercolor to ((nsStyleColor *)myColor)->mBackgroundColor)
bordercolor = EnsureDifferentColors(bordercolor, aStyleColor->mBackgroundColor);
//outerrounded
aRenderingContext.SetColor(bordercolor);
aRenderingContext.DrawLine(t2p, 0, mRect.width, 0);
aRenderingContext.DrawLine(0, t2p, 0, mRect.height);
aRenderingContext.DrawLine(t2p, mRect.height, mRect.width, mRect.height);
aRenderingContext.DrawLine(mRect.width, t2p, mRect.width, mRect.height);
//middle
aRenderingContext.DrawRect(t2p, t2p, mRect.width-t2p, mRect.height-t2p);
//shading
aRenderingContext.DrawLine(2*t2p, mRect.height-2*t2p, mRect.width-t2p, mRect.height- (2*t2p));
aRenderingContext.DrawLine(mRect.width - (2*t2p), 2*t2p, mRect.width - (2*t2p), mRect.height-t2p);
}
}
}
}
return NS_OK;
}
NS_HSL2RGB(float h, float s, float l)
{
PRUint8 r, g, b;
float m1, m2;
if (l <= 0.5f) {
m2 = l*(s+1);
} else {
m2 = l + s - l*s;
}
m1 = l*2 - m2;
r = PRUint8(255 * HSL_HueToRGB(m1, m2, h + 1.0f/3.0f));
g = PRUint8(255 * HSL_HueToRGB(m1, m2, h));
b = PRUint8(255 * HSL_HueToRGB(m1, m2, h - 1.0f/3.0f));
return NS_RGB(r, g, b);
}
NS_IMETHODIMP
nsGNOMEShellService::SetDesktopBackgroundColor(PRUint32 aColor)
{
nsCOMPtr<nsIGConfService> gconf = do_GetService(NS_GCONFSERVICE_CONTRACTID);
unsigned char red = (aColor >> 16);
unsigned char green = (aColor >> 8) & 0xff;
unsigned char blue = aColor & 0xff;
nsCAutoString colorString;
NS_RGBToASCIIHex(NS_RGB(red, green, blue), colorString);
gconf->SetString(NS_LITERAL_CSTRING(kDesktopColorKey), colorString);
return NS_OK;
}
NS_IMETHODIMP
nsMathMLmsqrtFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags)
{
/////////////
// paint the content we are square-rooting
nsresult rv = nsMathMLContainerFrame::Paint(aPresContext, aRenderingContext,
aDirtyRect, aWhichLayer);
/////////////
// paint the sqrt symbol
if (!NS_MATHML_HAS_ERROR(mPresentationData.flags)) {
mSqrChar.Paint(aPresContext, aRenderingContext,
aDirtyRect, aWhichLayer, this);
if (NS_FRAME_PAINT_LAYER_FOREGROUND == aWhichLayer &&
mStyleContext->GetStyleVisibility()->IsVisible() &&
!mBarRect.IsEmpty()) {
// paint the overline bar
const nsStyleColor* color = GetStyleColor();
aRenderingContext.SetColor(color->mColor);
aRenderingContext.FillRect(mBarRect);
}
#if defined(NS_DEBUG) && defined(SHOW_BOUNDING_BOX)
// for visual debug
if (NS_MATHML_PAINT_BOUNDING_METRICS(mPresentationData.flags)) {
nsRect rect;
mSqrChar.GetRect(rect);
nsBoundingMetrics bm;
mSqrChar.GetBoundingMetrics(bm);
aRenderingContext.SetColor(NS_RGB(255,0,0));
nscoord x = rect.x + bm.leftBearing;
nscoord y = rect.y;
nscoord w = bm.rightBearing - bm.leftBearing;
nscoord h = bm.ascent + bm.descent;
aRenderingContext.DrawRect(x,y,w,h);
}
#endif
}
return rv;
}
extern "C" NS_GFX_(PRBool) NS_ASCIIHexToRGB(const nsCString& aColorSpec,
nscolor* aResult)
{
const char* buffer = aColorSpec.get();
int nameLen = aColorSpec.Length();
if ((nameLen == 3) || (nameLen == 6)) {
// Make sure the digits are legal
for (int i = 0; i < nameLen; i++) {
char ch = buffer[i];
if (((ch >= '0') && (ch <= '9')) ||
((ch >= 'a') && (ch <= 'f')) ||
((ch >= 'A') && (ch <= 'F'))) {
// Legal character
continue;
}
// Whoops. Illegal character.
return PR_FALSE;
}
// Convert the ascii to binary
int dpc = ((3 == nameLen) ? 1 : 2);
// Translate components from hex to binary
int r = ComponentValue(buffer, nameLen, 0, dpc);
int g = ComponentValue(buffer, nameLen, 1, dpc);
int b = ComponentValue(buffer, nameLen, 2, dpc);
if (dpc == 1) {
// Scale single digit component to an 8 bit value. Replicate the
// single digit to compute the new value.
r = (r << 4) | r;
g = (g << 4) | g;
b = (b << 4) | b;
}
NS_ASSERTION((r >= 0) && (r <= 255), "bad r");
NS_ASSERTION((g >= 0) && (g <= 255), "bad g");
NS_ASSERTION((b >= 0) && (b <= 255), "bad b");
if (nsnull != aResult) {
*aResult = NS_RGB(r, g, b);
}
return PR_TRUE;
}
// Improperly formatted color value
return PR_FALSE;
}
nsRenderingContextQt::nsRenderingContextQt()
{
mFontMetrics = nsnull;
mContext = nsnull;
mSurface = nsnull;
mOffscreenSurface = nsnull;
mCurrentColor = NS_RGB(255,255,255); // set it to white
mCurrentLineStyle = nsLineStyle_kSolid;
mCurrentFont = nsnull;
mTranMatrix = nsnull;
mP2T = 1.0f;
mClipRegion = nsnull;
mFunction = Qt::CopyROP;
mQLineStyle = Qt::SolidLine;
PushState();
}
nsRenderingContextPh :: nsRenderingContextPh()
{
mGC = nsnull;
mTranMatrix = nsnull;
mClipRegion = nsnull;
mFontMetrics = nsnull;
mSurface = nsnull;
mOffscreenSurface = nsnull;
mContext = nsnull;
mP2T = 1.0f;
mPhotonFontName = nsnull;
mCurrentColor = NS_RGB(255, 255, 255);
mCurrentLineStyle = nsLineStyle_kSolid;
mStateCache = new nsVoidArray();
mOwner = PR_FALSE;
PushState();
}
NS_IMETHODIMP
nsPlaceholderFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags)
{
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
float p2t;
p2t = aPresContext->PixelsToTwips();
aRenderingContext.SetColor(NS_RGB(0, 255, 255));
nscoord x = NSIntPixelsToTwips(-5, p2t);
aRenderingContext.FillRect(x, 0, NSIntPixelsToTwips(13, p2t),
NSIntPixelsToTwips(3, p2t));
nscoord y = NSIntPixelsToTwips(-10, p2t);
aRenderingContext.FillRect(0, y, NSIntPixelsToTwips(3, p2t),
NSIntPixelsToTwips(10, p2t));
}
DO_GLOBAL_REFLOW_COUNT_DSP("nsPlaceholderFrame", &aRenderingContext);
return NS_OK;
}
nsCSSProperty mPropID;
nsStyleAnimation::Value mCSSValue;
nsPresContext* mPresContext;
};
// Helper "zero" values of various types
// -------------------------------------
static const nsStyleAnimation::Value
sZeroCoord(0, nsStyleAnimation::Value::CoordConstructor);
static const nsStyleAnimation::Value
sZeroPercent(0.0f, nsStyleAnimation::Value::PercentConstructor);
static const nsStyleAnimation::Value
sZeroFloat(0.0f, nsStyleAnimation::Value::FloatConstructor);
static const nsStyleAnimation::Value
sZeroColor(NS_RGB(0,0,0), nsStyleAnimation::Value::ColorConstructor);
// Helper Methods
// --------------
static const nsStyleAnimation::Value*
GetZeroValueForUnit(nsStyleAnimation::Unit aUnit)
{
NS_ABORT_IF_FALSE(aUnit != nsStyleAnimation::eUnit_Null,
"Need non-null unit for a zero value");
switch (aUnit) {
case nsStyleAnimation::eUnit_Coord:
return &sZeroCoord;
case nsStyleAnimation::eUnit_Percent:
return &sZeroPercent;
case nsStyleAnimation::eUnit_Float:
return &sZeroFloat;
nsresult
nsLookAndFeel::NativeGetColor(ColorID aID, nscolor &aColor)
{
nsresult res = NS_OK;
if (!qApp)
return NS_ERROR_FAILURE;
QPalette palette = qApp->palette();
switch (aID) {
case eColorID_WindowBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WindowForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_WidgetSelectBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetSelectForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_Widget3DHighlight:
aColor = NS_RGB(0xa0,0xa0,0xa0);
break;
case eColorID_Widget3DShadow:
aColor = NS_RGB(0x40,0x40,0x40);
break;
case eColorID_TextBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_TextForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_TextSelectBackground:
case eColorID_IMESelectedRawTextBackground:
case eColorID_IMESelectedConvertedTextBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Highlight));
break;
case eColorID_TextSelectForeground:
case eColorID_IMESelectedRawTextForeground:
case eColorID_IMESelectedConvertedTextForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::HighlightedText));
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;
case eColorID_activeborder:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_activecaption:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_appworkspace:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_background:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_captiontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID_graytext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Text));
break;
case eColorID_highlight:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Highlight));
break;
case eColorID_highlighttext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::HighlightedText));
break;
case eColorID_inactiveborder:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Window));
break;
case eColorID_inactivecaption:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Window));
break;
case eColorID_inactivecaptiontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Text));
break;
case eColorID_infobackground:
#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ToolTipBase));
#else
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Base));
#endif
break;
case eColorID_infotext:
#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ToolTipText));
#else
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
#endif
break;
case eColorID_menu:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_menutext:
case eColorID__moz_menubartext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID_scrollbar:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Mid));
break;
case eColorID_threedface:
case eColorID_buttonface:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Button));
break;
case eColorID_buttonhighlight:
case eColorID_threedhighlight:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Dark));
break;
case eColorID_buttontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ButtonText));
break;
case eColorID_buttonshadow:
case eColorID_threedshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Dark));
break;
case eColorID_threeddarkshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Shadow));
break;
case eColorID_threedlightshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Light));
break;
case eColorID_window:
case eColorID_windowframe:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_windowtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
// from the CSS3 working draft (not yet finalized)
// http://www.w3.org/tr/2000/wd-css3-userint-20000216.html#color
case eColorID__moz_buttondefault:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Button));
break;
case eColorID__moz_field:
case eColorID__moz_combobox:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Base));
break;
case eColorID__moz_fieldtext:
case eColorID__moz_comboboxtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID__moz_dialog:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID__moz_dialogtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID__moz_dragtargetzone:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID__moz_buttonhovertext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ButtonText));
break;
case eColorID__moz_menuhovertext:
case eColorID__moz_menubarhovertext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
default:
aColor = 0;
res = NS_ERROR_FAILURE;
break;
}
return res;
}
void
MediaEngineTabVideoSource::Draw() {
nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(mWindow);
if (!win) {
return;
}
int32_t innerWidth, innerHeight;
win->GetInnerWidth(&innerWidth);
win->GetInnerHeight(&innerHeight);
if (innerWidth == 0 || innerHeight == 0) {
return;
}
float pixelRatio;
win->GetDevicePixelRatio(&pixelRatio);
const int deviceInnerWidth = (int)(pixelRatio * innerWidth);
const int deviceInnerHeight = (int)(pixelRatio * innerHeight);
IntSize size;
if ((deviceInnerWidth <= mBufWidthMax) && (deviceInnerHeight <= mBufHeightMax)) {
size = IntSize(deviceInnerWidth, deviceInnerHeight);
} else {
const float scaleWidth = (float)mBufWidthMax / (float)deviceInnerWidth;
const float scaleHeight = (float)mBufHeightMax / (float)deviceInnerHeight;
const float scale = scaleWidth < scaleHeight ? scaleWidth : scaleHeight;
size = IntSize((int)(scale * deviceInnerWidth), (int)(scale * deviceInnerHeight));
}
gfxImageFormat format = gfxImageFormat::RGB24;
uint32_t stride = gfxASurface::FormatStrideForWidth(format, size.width);
if (mDataSize < static_cast<size_t>(stride * size.height)) {
mDataSize = stride * size.height;
mData = static_cast<unsigned char*>(malloc(mDataSize));
}
if (!mData) {
return;
}
nsRefPtr<nsPresContext> presContext;
nsIDocShell* docshell = win->GetDocShell();
if (docshell) {
docshell->GetPresContext(getter_AddRefs(presContext));
}
if (!presContext) {
return;
}
nscolor bgColor = NS_RGB(255, 255, 255);
nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
uint32_t renderDocFlags = 0;
if (!mScrollWithPage) {
renderDocFlags |= nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING;
}
nsRect r(0, 0, nsPresContext::CSSPixelsToAppUnits((float)innerWidth),
nsPresContext::CSSPixelsToAppUnits((float)innerHeight));
nsRefPtr<layers::ImageContainer> container = layers::LayerManager::CreateImageContainer();
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForData(BackendType::CAIRO,
mData.rwget(),
size,
stride,
SurfaceFormat::B8G8R8X8);
if (!dt) {
return;
}
nsRefPtr<gfxContext> context = new gfxContext(dt);
context->SetMatrix(context->CurrentMatrix().Scale((((float) size.width)/innerWidth),
(((float) size.height)/innerHeight)));
NS_ENSURE_SUCCESS_VOID(presShell->RenderDocument(r, renderDocFlags, bgColor, context));
RefPtr<SourceSurface> surface = dt->Snapshot();
if (!surface) {
return;
}
layers::CairoImage::Data cairoData;
cairoData.mSize = size;
cairoData.mSourceSurface = surface;
nsRefPtr<layers::CairoImage> image = new layers::CairoImage();
image->SetData(cairoData);
MonitorAutoLock mon(mMonitor);
mImage = image;
}
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:
case eColorID_IMESelectedRawTextBackground:
case eColorID_IMESelectedConvertedTextBackground:
// still used
aColor = BASE_SELECTED_COLOR;
break;
case eColorID_TextSelectForeground:
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;
}
gint
nsFreeTypeXImage::DrawString(nsRenderingContextGTK* aContext,
nsDrawingSurfaceGTK* aSurface, nscoord aX,
nscoord aY, const PRUnichar* aString,
PRUint32 aLength)
{
#if DEBUG_SHOW_GLYPH_BOX
PRUint32 x, y;
// grey shows image size
// red shows character cells
// green box shows text ink
#endif
if (aLength < 1) {
return 0;
}
// get the face/size from the FreeType cache
FT_Face face = getFTFace();
NS_ASSERTION(face, "failed to get face/size");
if (!face)
return 0;
nsresult rslt;
PRInt32 leftBearing, rightBearing, ascent, descent, width;
rslt = doGetBoundingMetrics(aString, aLength, &leftBearing, &rightBearing,
&ascent, &descent, &width);
if (NS_FAILED(rslt))
return 0;
// make sure we bring down enough background for blending
rightBearing = PR_MAX(rightBearing, width+1);
// offset in the ximage to the x origin
PRInt32 x_origin = PR_MAX(0, -leftBearing);
// offset in the ximage to the x origin
PRInt32 y_origin = ascent;
PRInt32 x_pos = x_origin;
int image_width = x_origin + rightBearing;
int image_height = y_origin + PR_MAX(descent, 0);
if ((image_width<=0) || (image_height<=0)) {
// if we do not have any pixels then no point in trying to draw
// eg: the space char has 0 height
NS_ASSERTION(width>=0, "Negative width");
return width;
}
Display *dpy = GDK_DISPLAY();
Drawable win = GDK_WINDOW_XWINDOW(aSurface->GetDrawable());
GC gc = GDK_GC_XGC(aContext->GetGC());
XGCValues values;
if (!XGetGCValues(dpy, gc, GCForeground, &values)) {
NS_ERROR("failed to get foreground pixel");
return 0;
}
nscolor color = nsX11AlphaBlend::PixelToNSColor(values.foreground);
#if DEBUG_SHOW_GLYPH_BOX
// show X/Y origin
XDrawLine(dpy, win, DefaultGC(dpy, 0), aX-2, aY, aX+2, aY);
XDrawLine(dpy, win, DefaultGC(dpy, 0), aX, aY-2, aX, aY+2);
// show width
XDrawLine(dpy, win, DefaultGC(dpy, 0), aX-x_origin, aY-y_origin-2,
aX+rightBearing, aY-y_origin-2);
#endif
//
// Get the background
//
XImage *sub_image = nsX11AlphaBlend::GetBackground(dpy, DefaultScreen(dpy),
win, aX-x_origin, aY-y_origin,
image_width, image_height);
if (sub_image==nsnull) {
#ifdef DEBUG
int screen = DefaultScreen(dpy);
// complain if the requested area is not completely off screen
int win_width = DisplayWidth(dpy, screen);
int win_height = DisplayHeight(dpy, screen);
if (((int)(aX-leftBearing+image_width) > 0) // not hidden to left
&& ((int)(aX-leftBearing) < win_width) // not hidden to right
&& ((int)(aY-ascent+image_height) > 0)// not hidden to top
&& ((int)(aY-ascent) < win_height)) // not hidden to bottom
{
NS_ASSERTION(sub_image, "failed to get the image");
}
#endif
return 0;
}
#if DEBUG_SHOW_GLYPH_BOX
DEBUG_AADRAWBOX(sub_image,0,0,image_width,image_height,0,0,0,255/4);
nscolor black NS_RGB(0,255,0);
blendPixel blendPixelFunc = nsX11AlphaBlend::GetBlendPixel();
// x origin
for (x=0; x<(unsigned int)image_height; x++)
if (x%4==0) (*blendPixelFunc)(sub_image, x_origin, x, black, 255/2);
// y origin
for (y=0; y<(unsigned int)image_width; y++)
if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2);
#endif
FTC_Image_Cache icache;
mFt2->GetImageCache(&icache);
if (!icache)
return 0;
//
// Get aa glyphs and blend with background
//
blendGlyph blendGlyph = nsX11AlphaBlend::GetBlendGlyph();
PRUint32 i, extraSurrogateLength;
for (i=0; i<aLength; i+=1+extraSurrogateLength) {
FT_UInt glyph_index;
FT_Glyph glyph;
nsresult rv;
FT_BBox glyph_bbox;
FT_ULong code_point = aString[i];
extraSurrogateLength = 0;
if(i<aLength-1 && IS_HIGH_SURROGATE(code_point) && IS_LOW_SURROGATE(aString[i+1])) {
// if surrogate, make UCS4 code point from high aString[i] surrogate and
// low surrogate aString[i+1]
code_point = SURROGATE_TO_UCS4(code_point, aString[i+1]);
// skip aString[i+1], it is already used as low surrogate
extraSurrogateLength = 1;
}
mFt2->GetCharIndex(face, code_point, &glyph_index);
if (glyph_index) {
rv = mFt2->ImageCacheLookup(icache, &mImageDesc, glyph_index, &glyph);
}
if ((glyph_index) && (NS_SUCCEEDED(rv))) {
mFt2->GlyphGetCBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox);
}
else {
// draw an empty box for the missing glyphs
GetFallbackGlyphMetrics(&glyph_bbox, face);
int x, y, w = glyph_bbox.xMax, h = glyph_bbox.yMax;
for (x=1; x<w; x++) {
XPutPixel(sub_image, x_pos+x, ascent-1, values.foreground);
XPutPixel(sub_image, x_pos+x, ascent-h, values.foreground);
}
for (y=1; y<h; y++) {
XPutPixel(sub_image, x_pos+1, ascent-y, values.foreground);
XPutPixel(sub_image, x_pos+w-1, ascent-y, values.foreground);
x = (y*(w-2))/h;
XPutPixel(sub_image, x_pos+x+1, ascent-y, values.foreground);
}
x_pos += w + 1;
continue;
}
FT_BitmapGlyph slot = (FT_BitmapGlyph)glyph;
nsAntiAliasedGlyph aaglyph(glyph_bbox.xMax-glyph_bbox.xMin,
glyph_bbox.yMax-glyph_bbox.yMin, 0);
PRUint8 buf[IMAGE_BUFFER_SIZE]; // try to use the stack for data
if (!aaglyph.WrapFreeType(&glyph_bbox, slot, buf, IMAGE_BUFFER_SIZE)) {
NS_ERROR("failed to wrap freetype image");
XDestroyImage(sub_image);
return 0;
}
//
// blend the aa-glyph onto the background
//
NS_ASSERTION(ascent>=glyph_bbox.yMax,"glyph too tall");
NS_ASSERTION(x_pos>=-aaglyph.GetLBearing(),"glyph extends too far to left");
#if DEBUG_SHOW_GLYPH_BOX
// draw box around part of glyph that extends to the left
// of the main area (negative LBearing)
if (aaglyph.GetLBearing() < 0) {
DEBUG_AADRAWBOX(sub_image, x_pos + aaglyph.GetLBearing(),
ascent-glyph_bbox.yMax,
-aaglyph.GetLBearing(), glyph_bbox.yMax, 255,0,0, 255/4);
}
// draw box around main glyph area
DEBUG_AADRAWBOX(sub_image, x_pos, ascent-glyph_bbox.yMax,
aaglyph.GetAdvance(), glyph_bbox.yMax, 0,255,0, 255/4);
// draw box around part of glyph that extends to the right
// of the main area (negative LBearing)
if (aaglyph.GetRBearing() > (int)aaglyph.GetAdvance()) {
DEBUG_AADRAWBOX(sub_image, x_pos + aaglyph.GetAdvance(),
ascent-glyph_bbox.yMax,
aaglyph.GetRBearing()-aaglyph.GetAdvance(),
glyph_bbox.yMax, 0,0,255, 255/4);
}
#endif
(*blendGlyph)(sub_image, &aaglyph, sLinearWeightTable, color,
x_pos + aaglyph.GetLBearing(), ascent-glyph_bbox.yMax);
x_pos += aaglyph.GetAdvance();
}
//
// Send it to the display
//
XPutImage(dpy, win, gc, sub_image, 0, 0, aX-x_origin , aY-ascent,
image_width, image_height);
XDestroyImage(sub_image);
return width;
}
nscolor GetSysColorInfo(int iSysColor)
{
long lColor = ::WinQuerySysColor( HWND_DESKTOP, iSysColor, 0);
RGB2 *pRGB2 = (RGB2*) &lColor;
return NS_RGB( pRGB2->bRed, pRGB2->bGreen, pRGB2->bBlue);
}
// Draw a header or footer string
// @param aRenderingContext - rendering context to draw into
// @param aHeaderFooter - indicates whether it is a header or footer
// @param aJust - indicates where the string is located within the header/footer
// @param aStr - the string to be drawn
// @param aRect - the rect of the page
// @param aHeight - the height of the font
// @param aAscent - the ascent of the font
// @param aWidth - available width for the string
void
nsPageFrame::DrawHeaderFooter(nsIRenderingContext& aRenderingContext,
nsHeaderFooterEnum aHeaderFooter,
PRInt32 aJust,
const nsString& aStr,
const nsRect& aRect,
nscoord aAscent,
nscoord aHeight,
nscoord aWidth)
{
nscoord contentWidth = aWidth - (mPD->mEdgePaperMargin.left + mPD->mEdgePaperMargin.right);
if ((aHeaderFooter == eHeader && aHeight < mPD->mReflowMargin.top) ||
(aHeaderFooter == eFooter && aHeight < mPD->mReflowMargin.bottom)) {
nsAutoString str;
ProcessSpecialCodes(aStr, str);
PRInt32 indx;
PRInt32 textWidth = 0;
const PRUnichar* text = str.get();
PRInt32 len = (PRInt32)str.Length();
if (len == 0) {
return; // bail is empty string
}
// find how much text fits, the "position" is the size of the available area
if (nsLayoutUtils::BinarySearchForPosition(&aRenderingContext, text, 0, 0, 0, len,
PRInt32(contentWidth), indx, textWidth)) {
if (indx < len-1 ) {
// we can't fit in all the text
if (indx > 3) {
// But we can fit in at least 4 chars. Show all but 3 of them, then
// an ellipsis.
// XXXbz for non-plane0 text, this may be cutting things in the
// middle of a codepoint! Also, we have no guarantees that the three
// dots will fit in the space the three chars we removed took up with
// these font metrics!
str.Truncate(indx-3);
str.AppendLiteral("...");
} else {
// We can only fit 3 or fewer chars. Just show nothing
str.Truncate();
}
}
} else {
return; // bail if couldn't find the correct length
}
if (HasRTLChars(str)) {
PresContext()->SetBidiEnabled();
}
// cacl the x and y positions of the text
nscoord x = GetXPosition(aRenderingContext, aRect, aJust, str);
nscoord y;
if (aHeaderFooter == eHeader) {
y = aRect.y + mPD->mExtraMargin.top + mPD->mEdgePaperMargin.top;
} else {
y = aRect.YMost() - aHeight - mPD->mExtraMargin.bottom - mPD->mEdgePaperMargin.bottom;
}
// set up new clip and draw the text
aRenderingContext.PushState();
aRenderingContext.SetColor(NS_RGB(0,0,0));
aRenderingContext.SetClipRect(aRect, nsClipCombine_kIntersect);
nsLayoutUtils::DrawString(this, &aRenderingContext, str.get(), str.Length(), nsPoint(x, y + aAscent));
aRenderingContext.PopState();
}
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("TestColorNames");
if (xpcom.failed())
return 1;
nscolor rgb;
int rv = 0;
// First make sure we can find all of the tags that are supposed to
// be in the table. Futz with the case to make sure any case will
// work
for (PRUint32 index = 0 ; index < ArrayLength(kColorNames); index++) {
// Lookup color by name and make sure it has the right id
nsCString tagName(kColorNames[index]);
// Check that color lookup by name gets the right rgb value
if (!NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) {
fail("can't find '%s'", tagName.get());
rv = 1;
}
if (rgb != kColors[index]) {
fail("name='%s' ColorNameToRGB=%x kColors[%d]=%08x",
tagName.get(), rgb, index, kColors[index]);
rv = 1;
}
// fiddle with the case to make sure we can still find it
tagName.SetCharAt(tagName.CharAt(0) - 32, 0);
if (!NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) {
fail("can't find '%s'", tagName.get());
rv = 1;
}
if (rgb != kColors[index]) {
fail("name='%s' ColorNameToRGB=%x kColors[%d]=%08x",
tagName.get(), rgb, index, kColors[index]);
rv = 1;
}
// Check that parsing an RGB value in hex gets the right values
PRUint8 r = NS_GET_R(rgb);
PRUint8 g = NS_GET_G(rgb);
PRUint8 b = NS_GET_B(rgb);
PRUint8 a = NS_GET_A(rgb);
if (a != PR_UINT8_MAX) {
// NS_HexToRGB() can not handle a color with alpha channel
rgb = NS_RGB(r, g, b);
}
char cbuf[50];
PR_snprintf(cbuf, sizeof(cbuf), "%02x%02x%02x", r, g, b);
nscolor hexrgb;
if (!NS_HexToRGB(NS_ConvertASCIItoUTF16(cbuf), &hexrgb)) {
fail("hex conversion to color of '%s'", cbuf);
rv = 1;
}
if (hexrgb != rgb) {
fail("rgb=%x hexrgb=%x", rgb, hexrgb);
rv = 1;
}
}
// Now make sure we don't find some garbage
for (PRUint32 i = 0; i < ArrayLength(kJunkNames); i++) {
nsCString tag(kJunkNames[i]);
if (NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tag), &rgb)) {
fail("found '%s'", kJunkNames[i] ? kJunkNames[i] : "(null)");
rv = 1;
}
}
if (rv == 0)
passed("TestColorNames");
return rv;
}
nsresult nsLookAndFeel::NativeGetColor(const nsColorID aID, nscolor &aColor)
{
nsresult res = NS_OK;
int idx;
switch (aID) {
case eColor_WindowBackground:
idx = SYSCLR_WINDOW;
break;
case eColor_WindowForeground:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor_WidgetBackground:
idx = SYSCLR_BUTTONMIDDLE;
break;
case eColor_WidgetForeground:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor_WidgetSelectBackground:
idx = SYSCLR_HILITEBACKGROUND;
break;
case eColor_WidgetSelectForeground:
idx = SYSCLR_HILITEFOREGROUND;
break;
case eColor_Widget3DHighlight:
idx = SYSCLR_BUTTONLIGHT;
break;
case eColor_Widget3DShadow:
idx = SYSCLR_BUTTONDARK;
break;
case eColor_TextBackground:
idx = SYSCLR_WINDOW;
break;
case eColor_TextForeground:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor_TextSelectBackground:
case eColor_IMESelectedRawTextBackground:
case eColor_IMESelectedConvertedTextBackground:
idx = SYSCLR_HILITEBACKGROUND;
break;
case eColor_TextSelectForeground:
case eColor_IMESelectedRawTextForeground:
case eColor_IMESelectedConvertedTextForeground:
idx = SYSCLR_HILITEFOREGROUND;
break;
case eColor_IMERawInputBackground:
case eColor_IMEConvertedTextBackground:
aColor = NS_TRANSPARENT;
return NS_OK;
case eColor_IMERawInputForeground:
case eColor_IMEConvertedTextForeground:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
return NS_OK;
case eColor_IMERawInputUnderline:
case eColor_IMEConvertedTextUnderline:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
return NS_OK;
case eColor_IMESelectedRawTextUnderline:
case eColor_IMESelectedConvertedTextUnderline:
aColor = NS_TRANSPARENT;
return NS_OK;
case eColor_SpellCheckerUnderline:
aColor = NS_RGB(0xff, 0, 0);
return NS_OK;
// New CSS 2 Color definitions
case eColor_activeborder:
idx = SYSCLR_ACTIVEBORDER;
break;
case eColor_activecaption:
idx = SYSCLR_ACTIVETITLETEXT;
break;
case eColor_appworkspace:
idx = SYSCLR_APPWORKSPACE;
break;
case eColor_background:
idx = SYSCLR_BACKGROUND;
break;
case eColor_buttonface:
case eColor__moz_buttonhoverface:
idx = SYSCLR_BUTTONMIDDLE;
break;
case eColor_buttonhighlight:
idx = SYSCLR_BUTTONLIGHT;
break;
case eColor_buttonshadow:
idx = SYSCLR_BUTTONDARK;
break;
case eColor_buttontext:
case eColor__moz_buttonhovertext:
idx = SYSCLR_MENUTEXT;
break;
case eColor_captiontext:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor_graytext:
idx = SYSCLR_MENUDISABLEDTEXT;
break;
case eColor_highlight:
case eColor__moz_html_cellhighlight:
idx = SYSCLR_HILITEBACKGROUND;
break;
case eColor_highlighttext:
case eColor__moz_html_cellhighlighttext:
idx = SYSCLR_HILITEFOREGROUND;
break;
case eColor_inactiveborder:
idx = SYSCLR_INACTIVEBORDER;
break;
case eColor_inactivecaption:
idx = SYSCLR_INACTIVETITLE;
break;
case eColor_inactivecaptiontext:
idx = SYSCLR_INACTIVETITLETEXT;
break;
case eColor_infobackground:
aColor = NS_RGB( 255, 255, 228);
return res;
case eColor_infotext:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor_menu:
idx = SYSCLR_MENU;
break;
case eColor_menutext:
case eColor__moz_menubartext:
idx = SYSCLR_MENUTEXT;
break;
case eColor_scrollbar:
idx = SYSCLR_SCROLLBAR;
break;
case eColor_threeddarkshadow:
idx = SYSCLR_BUTTONDARK;
break;
case eColor_threedface:
idx = SYSCLR_BUTTONMIDDLE;
break;
case eColor_threedhighlight:
idx = SYSCLR_BUTTONLIGHT;
break;
case eColor_threedlightshadow:
idx = SYSCLR_BUTTONMIDDLE;
break;
case eColor_threedshadow:
idx = SYSCLR_BUTTONDARK;
break;
case eColor_window:
idx = SYSCLR_WINDOW;
break;
case eColor_windowframe:
idx = SYSCLR_WINDOWFRAME;
break;
case eColor_windowtext:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor__moz_eventreerow:
case eColor__moz_oddtreerow:
case eColor__moz_field:
case eColor__moz_combobox:
idx = SYSCLR_ENTRYFIELD;
break;
case eColor__moz_fieldtext:
case eColor__moz_comboboxtext:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor__moz_dialog:
case eColor__moz_cellhighlight:
idx = SYSCLR_DIALOGBACKGROUND;
break;
case eColor__moz_dialogtext:
case eColor__moz_cellhighlighttext:
idx = SYSCLR_WINDOWTEXT;
break;
case eColor__moz_buttondefault:
idx = SYSCLR_BUTTONDEFAULT;
break;
case eColor__moz_menuhover:
if (WinQuerySysColor(HWND_DESKTOP, SYSCLR_MENUHILITEBGND, 0) ==
WinQuerySysColor(HWND_DESKTOP, SYSCLR_MENU, 0)) {
// if this happens, we would paint menu selections unreadable
// (we are most likely on Warp3), so let's fake a dark grey
// background for the selected menu item
aColor = NS_RGB( 132, 130, 132);
return res;
} else {
idx = SYSCLR_MENUHILITEBGND;
}
break;
case eColor__moz_menuhovertext:
case eColor__moz_menubarhovertext:
if (WinQuerySysColor(HWND_DESKTOP, SYSCLR_MENUHILITEBGND, 0) ==
WinQuerySysColor(HWND_DESKTOP, SYSCLR_MENU, 0)) {
// white text to be readable on dark grey
aColor = NS_RGB( 255, 255, 255);
return res;
} else {
idx = SYSCLR_MENUHILITE;
}
break;
case eColor__moz_nativehyperlinktext:
aColor = NS_RGB( 0, 0, 255);
return res;
default:
idx = SYSCLR_WINDOW;
break;
}
long lColor = WinQuerySysColor( HWND_DESKTOP, idx, 0);
int iRed = (lColor & RGB_RED) >> 16;
int iGreen = (lColor & RGB_GREEN) >> 8;
int iBlue = (lColor & RGB_BLUE);
aColor = NS_RGB( iRed, iGreen, iBlue);
return res;
}
void
MediaEngineTabVideoSource::Draw() {
nsIntSize size(mBufW, mBufH);
nsresult rv;
float scale = 1.0;
nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(mWindow);
if (!win) {
return;
}
// take a screenshot, as wide as possible, proportional to the destination size
nsCOMPtr<nsIDOMWindowUtils> utils = do_GetInterface(win);
if (!utils) {
return;
}
nsCOMPtr<nsIDOMClientRect> rect;
rv = utils->GetRootBounds(getter_AddRefs(rect));
NS_ENSURE_SUCCESS_VOID(rv);
if (!rect) {
return;
}
float left, top, width, height;
rect->GetLeft(&left);
rect->GetTop(&top);
rect->GetWidth(&width);
rect->GetHeight(&height);
if (width == 0 || height == 0) {
return;
}
int32_t srcX = left;
int32_t srcY = top;
int32_t srcW;
int32_t srcH;
float aspectRatio = ((float) size.width) / size.height;
if (width / aspectRatio < height) {
srcW = width;
srcH = width / aspectRatio;
} else {
srcW = height * aspectRatio;
srcH = height;
}
nsRefPtr<nsPresContext> presContext;
nsIDocShell* docshell = win->GetDocShell();
if (docshell) {
docshell->GetPresContext(getter_AddRefs(presContext));
}
if (!presContext) {
return;
}
nscolor bgColor = NS_RGB(255, 255, 255);
nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
uint32_t renderDocFlags = (nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING |
nsIPresShell::RENDER_DOCUMENT_RELATIVE);
nsRect r(nsPresContext::CSSPixelsToAppUnits(srcX / scale),
nsPresContext::CSSPixelsToAppUnits(srcY / scale),
nsPresContext::CSSPixelsToAppUnits(srcW / scale),
nsPresContext::CSSPixelsToAppUnits(srcH / scale));
gfxImageFormat format = gfxImageFormatRGB24;
uint32_t stride = gfxASurface::FormatStrideForWidth(format, size.width);
nsRefPtr<layers::ImageContainer> container = layers::LayerManager::CreateImageContainer();
nsRefPtr<gfxASurface> surf;
surf = new gfxImageSurface(static_cast<unsigned char*>(mData), size,
stride, format);
if (surf->CairoStatus() != 0) {
return;
}
nsRefPtr<gfxContext> context = new gfxContext(surf);
gfxPoint pt(0, 0);
context->Translate(pt);
context->Scale(scale * size.width / srcW, scale * size.height / srcH);
rv = presShell->RenderDocument(r, renderDocFlags, bgColor, context);
NS_ENSURE_SUCCESS_VOID(rv);
layers::CairoImage::Data cairoData;
cairoData.mSurface = surf;
cairoData.mSize = size;
nsRefPtr<layers::CairoImage> image = new layers::CairoImage();
image->SetData(cairoData);
MonitorAutoLock mon(mMonitor);
mImage = image;
}
nsThebesRenderingContext::nsThebesRenderingContext()
: mLineStyle(nsLineStyle_kNone)
, mColor(NS_RGB(0,0,0))
{
}
inFlasher::inFlasher() :
mColor(NS_RGB(0,0,0)),
mThickness(0),
mInvert(false)
{
}
NS_IMETHODIMP
nsTableCellFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags)
{
NS_ENSURE_TRUE(aPresContext, NS_ERROR_NULL_POINTER);
PRBool isVisible;
if (NS_SUCCEEDED(IsVisibleForPainting(aPresContext, aRenderingContext, PR_FALSE, &isVisible)) && !isVisible) {
return NS_OK;
}
PRBool paintChildren = PR_TRUE;
if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer) {
const nsStyleBorder* myBorder = nsnull;
const nsStylePadding* myPadding = nsnull;
const nsStyleTableBorder* cellTableStyle = nsnull;
const nsStyleVisibility* vis = GetStyleVisibility();
if (vis->IsVisible()) {
myBorder = GetStyleBorder();
myPadding = GetStylePadding();
cellTableStyle = GetStyleTableBorder();
// draw the border & background only when there is content or showing empty cells
if (NS_STYLE_TABLE_EMPTY_CELLS_HIDE != cellTableStyle->mEmptyCells ||
!GetContentEmpty()) {
PaintUnderlay(*aPresContext, aRenderingContext, aDirtyRect, aFlags,
*myBorder, *myPadding, *cellTableStyle);
}
// Paint outline
nsRect rect(0, 0, mRect.width, mRect.height);
const nsStyleOutline* myOutline = GetStyleOutline();
nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *myBorder, *myOutline,
mStyleContext, 0);
const nsStyleBackground* myColor = GetStyleBackground();
DecorateForSelection(aPresContext, aRenderingContext,myColor); //ignore return value
}
paintChildren = !(aFlags & NS_PAINT_FLAG_TABLE_CELL_BG_PASS);
//flags were for us; remove them for our children
aFlags &= ~ (NS_PAINT_FLAG_TABLE_CELL_BG_PASS | NS_PAINT_FLAG_TABLE_BG_PAINT);
}
#ifdef DEBUG
// for debug...
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
aRenderingContext.SetColor(NS_RGB(0, 0, 128));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
}
#endif
// paint the children unless we've been told not to
if (paintChildren) {
const nsStyleDisplay* disp = GetStyleDisplay();
// if the cell originates in a row and/or col that is collapsed, the
// bottom and/or right portion of the cell is painted by translating
// the rendering context.
nsPoint offset;
GetCollapseOffset(offset);
PRBool pushed = PR_FALSE;
if ((0 != offset.x) || (0 != offset.y)) {
aRenderingContext.PushState();
pushed = PR_TRUE;
aRenderingContext.Translate(offset.x, offset.y);
aRenderingContext.SetClipRect(nsRect(-offset.x, -offset.y, mRect.width, mRect.height),
nsClipCombine_kIntersect);
}
else {
// XXXldb HIDDEN should really create a scrollframe,
// but use |IsTableClip| here since it doesn't.
if (disp->IsTableClip() ||
(HasPctOverHeight() && eCompatibility_NavQuirks == aPresContext->CompatibilityMode())) {
aRenderingContext.PushState();
pushed = PR_TRUE;
SetOverflowClipRect(aRenderingContext);
}
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer, aFlags);
if (pushed) {
aRenderingContext.PopState();
}
}
DO_GLOBAL_REFLOW_COUNT_DSP_J("nsTableCellFrame", &aRenderingContext, 0);
return NS_OK;
/*nsFrame::Paint(aPresContext,
aRenderingContext,
aDirtyRect,
aWhichLayer);*/
}
// This implements part of the algorithm for legacy behavior described in
// http://www.whatwg.org/specs/web-apps/current-work/complete/common-microsyntaxes.html#rules-for-parsing-a-legacy-color-value
NS_GFX_(PRBool) NS_LooseHexToRGB(const nsString& aColorSpec, nscolor* aResult)
{
if (aColorSpec.EqualsLiteral("transparent")) {
return PR_FALSE;
}
int nameLen = aColorSpec.Length();
const PRUnichar* colorSpec = aColorSpec.get();
if (nameLen > 128) {
nameLen = 128;
}
if ('#' == colorSpec[0]) {
++colorSpec;
--nameLen;
}
// digits per component
int dpc = (nameLen + 2) / 3;
int newdpc = dpc;
// Use only the rightmost 8 characters of each component.
if (newdpc > 8) {
nameLen -= newdpc - 8;
colorSpec += newdpc - 8;
newdpc = 8;
}
// And then keep trimming characters at the left until we'd trim one
// that would leave a nonzero value, but not past 2 characters per
// component.
while (newdpc > 2) {
PRBool haveNonzero = PR_FALSE;
for (int c = 0; c < 3; ++c) {
NS_ABORT_IF_FALSE(c * dpc < nameLen,
"should not pass end of string while newdpc > 2");
PRUnichar ch = colorSpec[c * dpc];
if (('1' <= ch && ch <= '9') ||
('A' <= ch && ch <= 'F') ||
('a' <= ch && ch <= 'f')) {
haveNonzero = PR_TRUE;
break;
}
}
if (haveNonzero) {
break;
}
--newdpc;
--nameLen;
++colorSpec;
}
// Translate components from hex to binary
int r = ComponentValue(colorSpec, nameLen, 0, dpc);
int g = ComponentValue(colorSpec, nameLen, 1, dpc);
int b = ComponentValue(colorSpec, nameLen, 2, dpc);
NS_ASSERTION((r >= 0) && (r <= 255), "bad r");
NS_ASSERTION((g >= 0) && (g <= 255), "bad g");
NS_ASSERTION((b >= 0) && (b <= 255), "bad b");
*aResult = NS_RGB(r, g, b);
return PR_TRUE;
}
