NS_IMETHODIMP nsFontMetricsPh::Init ( const nsFont& aFont, nsIAtom* aLangGroup, nsIDeviceContext* aContext )
{
NS_ASSERTION(!(nsnull == aContext), "attempt to init fontmetrics with null device context");
nsAutoString firstFace;
char *str = nsnull;
nsresult result;
PhRect_t extent;
if( !gFontMetricsCache ) {
nsresult res = InitGlobals( );
if( NS_FAILED(res) ) return res;
}
mFont = aFont;
mLangGroup = aLangGroup;
mDeviceContext = aContext;
result = aContext->FirstExistingFont(aFont, firstFace);
str = ToNewCString(firstFace);
#ifdef DEBUG_Adrian
printf( "\n\n\t\t\tIn nsFontMetricsPh::Init str=%s\n", str );
#endif
if( !str || !str[0] )
{
if( str ) free (str);
str = strdup("serif");
}
const char *cstring;
aLangGroup->GetUTF8String( &cstring );
char *prop = PR_smprintf( "font.name.%s.%s", str, cstring );
char *font_default = NULL;
if( prop )
{
gPref->CopyCharPref( prop, &font_default );
PR_smprintf_free( prop );
}
else gPref->CopyCharPref( "font.name.serif.x-western", &font_default );
if( font_default )
{
free (str);
/* font_default was allocated. in CopyCharPref. */
str = font_default;
}
float app2dev;
app2dev = mDeviceContext->AppUnitsToDevUnits();
PRInt32 sizePoints;
if( mFont.systemFont == PR_TRUE )
sizePoints = NSToIntRound( app2dev * mFont.size * 0.68 );
else sizePoints = NSToIntRound( app2dev * mFont.size * 0.74 );
char NSFullFontName[MAX_FONT_TAG];
unsigned int uiFlags = 0L;
if(aFont.weight > NS_FONT_WEIGHT_NORMAL)
uiFlags |= PF_STYLE_BOLD;
if(aFont.style & (NS_FONT_STYLE_ITALIC|NS_FONT_STYLE_OBLIQUE) )
uiFlags |= PF_STYLE_ITALIC;
if(aFont.style & NS_FONT_STYLE_ANTIALIAS)
uiFlags |= PF_STYLE_ANTIALIAS;
if( PfGenerateFontName( (char *)str, uiFlags, sizePoints, (char *)NSFullFontName ) == NULL )
{
#ifdef DEBUG_Adrian
printf( "!!!!!!!!!!!! PfGenerateFontName failed\n" );
#endif
PfGenerateFontName( "TextFont", uiFlags, sizePoints, (char *)NSFullFontName );
}
/* Once the Photon Font String is built get the attributes */
FontQueryInfo *node;
nsCStringKey key((char *)(NSFullFontName));
node = (FontQueryInfo *) gFontMetricsCache->Get(&key);
#ifdef DEBUG_Adrian
printf( "\t\t\tThe generated font name is NSFullFontName=%s\n", NSFullFontName );
if( node ) printf( "\t\t\t( cached ) The real font is desc=%s\n", node->desc );
#endif
if( !node )
{
node = (FontQueryInfo *)calloc(sizeof(FontQueryInfo), 1);
PfQueryFont(NSFullFontName, node);
#ifdef DEBUG_Adrian
printf( "\t\t\t(not cached ) The real font is desc=%s\n", node->desc );
printf( "\tCall PfLoadMetrics for NSFullFontName=%s\n", NSFullFontName );
#endif
gFontMetricsCache->Put(&key, node);
PfLoadMetrics( NSFullFontName );
}
float dev2app;
double height;
nscoord onePixel;
dev2app = mDeviceContext->DevUnitsToAppUnits();
onePixel = NSToCoordRound(1 * dev2app);
height = node->descender - node->ascender;
PfExtent( &extent, NULL, NSFullFontName, 0L, 0L, " ", 1, PF_SIMPLE_METRICS, NULL );
mSpaceWidth = NSToCoordRound((extent.lr.x - extent.ul.x + 1) * dev2app);
mLeading = NSToCoordRound(0);
mEmHeight = NSToCoordRound(height * dev2app);
mEmAscent = NSToCoordRound(node->ascender * dev2app * -1.0);
mEmDescent = NSToCoordRound(node->descender * dev2app);
mHeight = mMaxHeight = NSToCoordRound(height * dev2app);
mAscent = mMaxAscent = NSToCoordRound(node->ascender * dev2app * -1.0);
mDescent = mMaxDescent = NSToCoordRound(node->descender * dev2app);
mMaxAdvance = NSToCoordRound(node->width * dev2app);
mAveCharWidth = mSpaceWidth;
mXHeight = NSToCoordRound((float)node->ascender * dev2app * 0.56f * -1.0); // 56% of ascent, best guess for non-true type
mSuperscriptOffset = mXHeight; // XXX temporary code!
mSubscriptOffset = mXHeight; // XXX temporary code!
mStrikeoutSize = onePixel; // XXX this is a guess
mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0f); // 50% of xHeight
mUnderlineSize = onePixel; // XXX this is a guess
mUnderlineOffset = -NSToCoordRound((float)node->descender * dev2app * 0.30f); // 30% of descent
if (mFontHandle)
free (mFontHandle);
mFontHandle = strdup(NSFullFontName);
free (str);
return NS_OK;
}
void
nsThebesDeviceContext::CalcPrintingSize()
{
if (!mPrintingSurface)
return;
PRBool inPoints = PR_TRUE;
gfxSize size;
switch (mPrintingSurface->GetType()) {
case gfxASurface::SurfaceTypeImage:
inPoints = PR_FALSE;
size = reinterpret_cast<gfxImageSurface*>(mPrintingSurface.get())->GetSize();
break;
#if defined(MOZ_ENABLE_GTK2) || defined(XP_WIN) || defined(XP_OS2)
case gfxASurface::SurfaceTypePDF:
inPoints = PR_TRUE;
size = reinterpret_cast<gfxPDFSurface*>(mPrintingSurface.get())->GetSize();
break;
#endif
#ifdef MOZ_ENABLE_GTK2
case gfxASurface::SurfaceTypePS:
inPoints = PR_TRUE;
size = reinterpret_cast<gfxPSSurface*>(mPrintingSurface.get())->GetSize();
break;
#endif
#ifdef XP_MACOSX
case gfxASurface::SurfaceTypeQuartz:
inPoints = PR_TRUE; // this is really only true when we're printing
size = reinterpret_cast<gfxQuartzSurface*>(mPrintingSurface.get())->GetSize();
break;
#endif
#ifdef XP_WIN
case gfxASurface::SurfaceTypeWin32:
case gfxASurface::SurfaceTypeWin32Printing:
{
inPoints = PR_FALSE;
HDC dc = GetPrintHDC();
if (!dc)
dc = GetDC((HWND)mWidget->GetNativeData(NS_NATIVE_WIDGET));
size.width = NSFloatPixelsToAppUnits(::GetDeviceCaps(dc, HORZRES)/mPrintingScale, AppUnitsPerDevPixel());
size.height = NSFloatPixelsToAppUnits(::GetDeviceCaps(dc, VERTRES)/mPrintingScale, AppUnitsPerDevPixel());
mDepth = (PRUint32)::GetDeviceCaps(dc, BITSPIXEL);
if (dc != (HDC)GetPrintHDC())
ReleaseDC((HWND)mWidget->GetNativeData(NS_NATIVE_WIDGET), dc);
break;
}
#endif
#ifdef XP_OS2
case gfxASurface::SurfaceTypeOS2:
{
inPoints = PR_FALSE;
// we already set the size in the surface constructor we set for
// printing, so just get those values here
size = reinterpret_cast<gfxOS2Surface*>(mPrintingSurface.get())->GetSize();
// as they are in pixels we need to scale them to app units
size.width = NSFloatPixelsToAppUnits(size.width, AppUnitsPerDevPixel());
size.height = NSFloatPixelsToAppUnits(size.height, AppUnitsPerDevPixel());
// still need to get the depth from the device context
HDC dc = GetPrintHDC();
LONG value;
if (DevQueryCaps(dc, CAPS_COLOR_BITCOUNT, 1, &value))
mDepth = value;
else
mDepth = 8; // default to 8bpp, should be enough for printers
break;
}
#endif
default:
NS_ERROR("trying to print to unknown surface type");
}
if (inPoints) {
mWidth = NSToCoordRound(float(size.width) * AppUnitsPerInch() / 72);
mHeight = NSToCoordRound(float(size.height) * AppUnitsPerInch() / 72);
} else {
mWidth = NSToIntRound(size.width);
mHeight = NSToIntRound(size.height);
}
}
/*
* This is identical to nsCanvasRenderingContext2D::Render, we just don't
* have a good place to put it; though maybe I want a CanvasContextImpl that
* all this stuff can derive from?
*/
NS_METHOD
compzillaRenderingContext::Render (nsIRenderingContext *rc)
{
DEBUG ("Render\n");
nsresult rv = NS_OK;
#ifdef MOZ_CAIRO_GFX
DEBUG ("thebes\n");
gfxContext* ctx = (gfxContext*) rc->GetNativeGraphicData(nsIRenderingContext::NATIVE_THEBES_CONTEXT);
nsRefPtr<gfxPattern> pat = new gfxPattern(mThebesSurface);
// XXX I don't want to use PixelSnapped here, but layout doesn't guarantee
// pixel alignment for this stuff!
ctx->NewPath();
ctx->PixelSnappedRectangleAndSetPattern(gfxRect(0, 0, mWidth, mHeight), pat);
ctx->Fill();
#else
DEBUG ("non-thebes\n");
// non-Thebes; this becomes exciting
cairo_surface_t *dest = nsnull;
cairo_t *dest_cr = nsnull;
GdkDrawable *gdkdraw = nsnull;
#ifdef MOZILLA_1_8_BRANCH
rv = rc->RetrieveCurrentNativeGraphicData((void**) &gdkdraw);
if (NS_FAILED(rv) || !gdkdraw)
return NS_ERROR_FAILURE;
#else
gdkdraw = (GdkDrawable*) rc->GetNativeGraphicData(nsIRenderingContext::NATIVE_GDK_DRAWABLE);
if (!gdkdraw)
return NS_ERROR_FAILURE;
#endif
gint w, h;
gdk_drawable_get_size (gdkdraw, &w, &h);
dest = cairo_xlib_surface_create (GDK_DRAWABLE_XDISPLAY(gdkdraw),
GDK_DRAWABLE_XID(gdkdraw),
GDK_VISUAL_XVISUAL(gdk_drawable_get_visual(gdkdraw)),
w, h);
dest_cr = cairo_create (dest);
nsTransform2D *tx = nsnull;
rc->GetCurrentTransform(tx);
nsCOMPtr<nsIDeviceContext> dctx;
rc->GetDeviceContext(*getter_AddRefs(dctx));
float x0 = 0.0, y0 = 0.0;
float sx = 1.0, sy = 1.0;
if (tx->GetType() & MG_2DTRANSLATION) {
tx->Transform(&x0, &y0);
}
if (tx->GetType() & MG_2DSCALE) {
sx = sy = dctx->DevUnitsToTwips();
tx->TransformNoXLate(&sx, &sy);
}
cairo_translate (dest_cr, NSToIntRound(x0), NSToIntRound(y0));
if (sx != 1.0 || sy != 1.0)
cairo_scale (dest_cr, sx, sy);
cairo_rectangle (dest_cr, 0, 0, mWidth, mHeight);
cairo_clip (dest_cr);
cairo_set_source_surface (dest_cr, mSurface, 0, 0);
cairo_paint (dest_cr);
if (dest_cr)
cairo_destroy (dest_cr);
if (dest)
cairo_surface_destroy (dest);
#endif
return rv;
}
void
nsThebesDeviceContext::UpdateScaledAppUnits()
{
mAppUnitsPerDevPixel =
PR_MAX(1, NSToIntRound(float(mAppUnitsPerDevNotScaledPixel) / mPixelScale));
}
NS_IMETHODIMP
nsFieldSetFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame", aReflowState.reason);
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
// Initialize OUT parameter
aStatus = NS_FRAME_COMPLETE;
// Should we create a space manager?
nsAutoSpaceManager autoSpaceManager(NS_CONST_CAST(nsHTMLReflowState &, aReflowState));
// XXXldb If we start storing the space manager in the frame rather
// than keeping it around only during reflow then we should create it
// only when there are actually floats to manage. Otherwise things
// like tables will gain significant bloat.
if (NS_BLOCK_SPACE_MGR & mState)
autoSpaceManager.CreateSpaceManagerFor(aPresContext, this);
//------------ Handle Incremental Reflow -----------------
PRBool reflowContent = PR_TRUE;
PRBool reflowLegend = PR_TRUE;
nsReflowReason reason = aReflowState.reason;
if (reason == eReflowReason_Incremental) {
nsHTMLReflowCommand *command = aReflowState.path->mReflowCommand;
// See if it's targeted at us
if (command) {
nsReflowType reflowType;
command->GetType(reflowType);
switch (reflowType) {
case eReflowType_StyleChanged:
reason = eReflowReason_StyleChange;
break;
case eReflowType_ReflowDirty:
reason = eReflowReason_Dirty;
break;
default:
NS_ERROR("Unexpected Reflow Type");
}
} else {
reflowContent = PR_FALSE;
reflowLegend = PR_FALSE;
nsReflowPath::iterator iter = aReflowState.path->FirstChild();
nsReflowPath::iterator end = aReflowState.path->EndChildren();
for ( ; iter != end; ++iter) {
if (*iter == mLegendFrame)
reflowLegend = PR_TRUE;
else if (*iter == mContentFrame)
reflowContent = PR_TRUE;
}
}
}
if (aDesiredSize.mFlags & NS_REFLOW_CALC_MAX_WIDTH) {
reflowLegend = PR_TRUE;
reflowContent = PR_TRUE;
} else if (reason == eReflowReason_Dirty) {
// if dirty then check dirty flags
if (GetStateBits() & NS_FRAME_IS_DIRTY) {
reflowLegend = PR_TRUE;
reflowContent = PR_TRUE;
} else {
if (reflowContent) {
reflowContent = mContentFrame ?
(mContentFrame->GetStateBits()
& (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN)) != 0 : PR_FALSE;
}
if (reflowLegend) {
reflowLegend = mLegendFrame ?
(mLegendFrame->GetStateBits()
& (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN)) != 0 : PR_FALSE;
}
}
}
// availSize could have unconstrained values, don't perform any addition on them
nsSize availSize(aReflowState.mComputedWidth, aReflowState.availableHeight);
// get our border and padding
const nsMargin &borderPadding = aReflowState.mComputedBorderPadding;
const nsMargin &padding = aReflowState.mComputedPadding;
nsMargin border = borderPadding - padding;
if (aDesiredSize.mComputeMEW) {
aDesiredSize.mMaxElementWidth = borderPadding.left + borderPadding.right;
}
// Figure out how big the legend is if there is one.
// get the legend's margin
nsMargin legendMargin(0,0,0,0);
// reflow the legend only if needed
if (mLegendFrame) {
const nsStyleMargin* marginStyle = mLegendFrame->GetStyleMargin();
marginStyle->GetMargin(legendMargin);
if (reflowLegend) {
nsHTMLReflowState legendReflowState(aPresContext, aReflowState,
mLegendFrame, nsSize(NS_INTRINSICSIZE,NS_INTRINSICSIZE),
reason);
// always give the legend as much size as it needs
legendReflowState.mComputedWidth = NS_INTRINSICSIZE;
legendReflowState.mComputedHeight = NS_INTRINSICSIZE;
nsHTMLReflowMetrics legendDesiredSize(0,0);
ReflowChild(mLegendFrame, aPresContext, legendDesiredSize, legendReflowState,
0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
#ifdef NOISY_REFLOW
printf(" returned (%d, %d)\n", legendDesiredSize.width, legendDesiredSize.height);
if (legendDesiredSize.mComputeMEW)
printf(" and maxEW %d\n",
legendDesiredSize.mMaxElementWidth);
#endif
// figure out the legend's rectangle
mLegendRect.width = legendDesiredSize.width + legendMargin.left + legendMargin.right;
mLegendRect.height = legendDesiredSize.height + legendMargin.top + legendMargin.bottom;
mLegendRect.x = borderPadding.left;
mLegendRect.y = 0;
nscoord oldSpace = mLegendSpace;
mLegendSpace = 0;
if (mLegendRect.height > border.top) {
// center the border on the legend
mLegendSpace = mLegendRect.height - border.top;
} else {
mLegendRect.y = (border.top - mLegendRect.height)/2;
}
// if the legend space changes then we need to reflow the
// content area as well.
if (mLegendSpace != oldSpace) {
if (reflowContent == PR_FALSE || reason == eReflowReason_Dirty) {
reflowContent = PR_TRUE;
reason = eReflowReason_Resize;
}
}
// if we are contrained then remove the legend from our available height.
if (NS_INTRINSICSIZE != availSize.height) {
if (availSize.height >= mLegendSpace)
availSize.height -= mLegendSpace;
}
// don't get any smaller than the legend
if (NS_INTRINSICSIZE != availSize.width) {
if (availSize.width < mLegendRect.width)
availSize.width = mLegendRect.width;
}
FinishReflowChild(mLegendFrame, aPresContext, &legendReflowState,
legendDesiredSize, 0, 0, NS_FRAME_NO_MOVE_FRAME);
}
} else {
mLegendRect.Empty();
mLegendSpace = 0;
}
nsRect contentRect;
// reflow the content frame only if needed
if (mContentFrame) {
if (reflowContent) {
availSize.width = aReflowState.mComputedWidth;
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, mContentFrame,
availSize, reason);
nsHTMLReflowMetrics kidDesiredSize(aDesiredSize.mComputeMEW, aDesiredSize.mFlags);
// Reflow the frame
ReflowChild(mContentFrame, aPresContext, kidDesiredSize, kidReflowState,
borderPadding.left + kidReflowState.mComputedMargin.left,
borderPadding.top + mLegendSpace + kidReflowState.mComputedMargin.top,
0, aStatus);
// set the rect. make sure we add the margin back in.
contentRect.SetRect(borderPadding.left,borderPadding.top + mLegendSpace,kidDesiredSize.width ,kidDesiredSize.height);
if (aReflowState.mComputedHeight != NS_INTRINSICSIZE &&
borderPadding.top + mLegendSpace+kidDesiredSize.height > aReflowState.mComputedHeight) {
kidDesiredSize.height = aReflowState.mComputedHeight-(borderPadding.top + mLegendSpace);
}
FinishReflowChild(mContentFrame, aPresContext, &kidReflowState,
kidDesiredSize, contentRect.x, contentRect.y, 0);
if (aDesiredSize.mComputeMEW) {
aDesiredSize.mMaxElementWidth = kidDesiredSize.mMaxElementWidth;
if (eStyleUnit_Coord == aReflowState.mStylePosition->mWidth.GetUnit() &&
NS_INTRINSICSIZE != aReflowState.mComputedWidth)
aDesiredSize.mMaxElementWidth = aReflowState.mComputedWidth;
if (eStyleUnit_Percent == aReflowState.mStylePosition->mWidth.GetUnit())
aDesiredSize.mMaxElementWidth = 0;
aDesiredSize.mMaxElementWidth += borderPadding.left + borderPadding.right;
}
if (aDesiredSize.mFlags & NS_REFLOW_CALC_MAX_WIDTH) {
aDesiredSize.mMaximumWidth = kidDesiredSize.mMaximumWidth +
borderPadding.left + borderPadding.right;
}
NS_FRAME_TRACE_REFLOW_OUT("FieldSet::Reflow", aStatus);
} else {
// if we don't need to reflow just get the old size
contentRect = mContentFrame->GetRect();
const nsStyleMargin* marginStyle = mContentFrame->GetStyleMargin();
nsMargin m(0,0,0,0);
marginStyle->GetMargin(m);
contentRect.Inflate(m);
}
}
// use the computed width if the inner content does not fill it
if (aReflowState.mComputedWidth != NS_INTRINSICSIZE &&
aReflowState.mComputedWidth > contentRect.width) {
contentRect.width = aReflowState.mComputedWidth;
}
if (mLegendFrame) {
// if the content rect is larger then the legend we can align the legend
if (contentRect.width > mLegendRect.width) {
PRInt32 align = ((nsLegendFrame*)mLegendFrame)->GetAlign();
switch(align) {
case NS_STYLE_TEXT_ALIGN_RIGHT:
mLegendRect.x = contentRect.width - mLegendRect.width + borderPadding.left;
break;
case NS_STYLE_TEXT_ALIGN_CENTER:
float p2t;
p2t = aPresContext->PixelsToTwips();
mLegendRect.x = NSIntPixelsToTwips((nscoord) NSToIntRound((float)(contentRect.width/2 - mLegendRect.width/2 + borderPadding.left) / p2t),p2t);
break;
}
} else {
//otherwise make place for the legend
contentRect.width = mLegendRect.width;
}
// place the legend
nsRect actualLegendRect(mLegendRect);
actualLegendRect.Deflate(legendMargin);
nsPoint curOrigin = mLegendFrame->GetPosition();
// only if the origin changed
if ((curOrigin.x != mLegendRect.x) || (curOrigin.y != mLegendRect.y)) {
mLegendFrame->SetPosition(nsPoint(actualLegendRect.x , actualLegendRect.y));
nsContainerFrame::PositionFrameView(mLegendFrame);
// We need to recursively process the legend frame's
// children since we're moving the frame after Reflow.
nsContainerFrame::PositionChildViews(mLegendFrame);
}
}
// Return our size and our result
if (aReflowState.mComputedHeight == NS_INTRINSICSIZE) {
aDesiredSize.height = mLegendSpace +
borderPadding.top +
contentRect.height +
borderPadding.bottom;
} else {
nscoord min = borderPadding.top + borderPadding.bottom + mLegendRect.height;
aDesiredSize.height = aReflowState.mComputedHeight + borderPadding.top + borderPadding.bottom;
if (aDesiredSize.height < min)
aDesiredSize.height = min;
}
aDesiredSize.width = contentRect.width + borderPadding.left + borderPadding.right;
aDesiredSize.ascent = aDesiredSize.height;
aDesiredSize.descent = 0;
if (aDesiredSize.mComputeMEW) {
// if the legend is wider use it
if (aDesiredSize.mMaxElementWidth < mLegendRect.width + borderPadding.left + borderPadding.right)
aDesiredSize.mMaxElementWidth = mLegendRect.width + borderPadding.left + borderPadding.right;
}
aDesiredSize.mOverflowArea = nsRect(0, 0, aDesiredSize.width, aDesiredSize.height);
// make the mMaximumWidth large enough if the legendframe determines the size
if ((aDesiredSize.mFlags & NS_REFLOW_CALC_MAX_WIDTH) && mLegendFrame) {
aDesiredSize.mMaximumWidth = PR_MAX(aDesiredSize.mMaximumWidth, mLegendRect.width +
borderPadding.left + borderPadding.right);
}
if (mLegendFrame)
ConsiderChildOverflow(aDesiredSize.mOverflowArea, mLegendFrame);
if (mContentFrame)
ConsiderChildOverflow(aDesiredSize.mOverflowArea, mContentFrame);
FinishAndStoreOverflow(&aDesiredSize);
Invalidate(aDesiredSize.mOverflowArea);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
return NS_OK;
}
