2000-03-28 10:15:19 +00:00
|
|
|
/*
|
|
|
|
* The contents of this file are subject to the Mozilla Public
|
|
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
|
|
* except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla MathML Project.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is The University Of
|
|
|
|
* Queensland. Portions created by The University Of Queensland are
|
|
|
|
* Copyright (C) 1999 The University Of Queensland. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Roger B. Sidje <rbs@maths.uq.edu.au>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsHTMLParts.h"
|
|
|
|
#include "nsIHTMLContent.h"
|
|
|
|
#include "nsFrame.h"
|
|
|
|
#include "nsAreaFrame.h"
|
|
|
|
#include "nsLineLayout.h"
|
|
|
|
#include "nsHTMLIIDs.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsHTMLAtoms.h"
|
|
|
|
#include "nsUnitConversion.h"
|
|
|
|
#include "nsIStyleContext.h"
|
|
|
|
#include "nsStyleConsts.h"
|
|
|
|
#include "nsINameSpaceManager.h"
|
|
|
|
#include "nsIRenderingContext.h"
|
|
|
|
#include "nsIFontMetrics.h"
|
|
|
|
#include "nsStyleUtil.h"
|
|
|
|
|
2000-05-16 13:18:42 +00:00
|
|
|
#include "nsVoidArray.h"
|
|
|
|
#include "nsLayoutAtoms.h"
|
|
|
|
#include "nsIFrameManager.h"
|
|
|
|
#include "nsTableOuterFrame.h"
|
|
|
|
#include "nsTableCellFrame.h"
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
#include "nsMathMLmtableFrame.h"
|
|
|
|
|
|
|
|
//
|
|
|
|
// <mtable> -- table or matrix - implementation
|
|
|
|
//
|
|
|
|
|
2000-05-16 13:18:42 +00:00
|
|
|
// helper function to perform an in-place split of a space-delimited string,
|
2001-05-19 10:00:01 +00:00
|
|
|
// and return an array of pointers for the beginning of each segment, i.e.,
|
2000-05-16 13:18:42 +00:00
|
|
|
// aOffset[0] is the first string, aOffset[1] is the second string, etc.
|
|
|
|
// Used to parse attributes like columnalign='left right', rowalign='top bottom'
|
2001-05-19 10:00:01 +00:00
|
|
|
static void
|
2000-05-16 13:18:42 +00:00
|
|
|
SplitString(nsString& aString, // [IN/OUT]
|
|
|
|
nsVoidArray& aOffset) // [OUT]
|
|
|
|
{
|
|
|
|
static const PRUnichar kNullCh = PRUnichar('\0');
|
|
|
|
|
|
|
|
aString.Append(kNullCh); // put an extra null at the end
|
|
|
|
|
2001-06-30 11:02:25 +00:00
|
|
|
PRUnichar* start = (PRUnichar*)(const PRUnichar*)aString.get();
|
2000-05-16 13:18:42 +00:00
|
|
|
PRUnichar* end = start;
|
|
|
|
|
|
|
|
while (kNullCh != *start) {
|
|
|
|
while ((kNullCh != *start) && nsCRT::IsAsciiSpace(*start)) { // skip leading space
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
end = start;
|
|
|
|
|
|
|
|
while ((kNullCh != *end) && (PR_FALSE == nsCRT::IsAsciiSpace(*end))) { // look for space or end
|
|
|
|
end++;
|
|
|
|
}
|
|
|
|
*end = kNullCh; // end string here
|
|
|
|
|
|
|
|
if (start < end) {
|
|
|
|
aOffset.AppendElement(start); // record the beginning of this segment
|
|
|
|
}
|
|
|
|
|
|
|
|
start = ++end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct nsValueList
|
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
nsString mData;
|
|
|
|
nsVoidArray mArray;
|
2000-05-16 13:18:42 +00:00
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
nsValueList(nsString& aData) {
|
2000-05-16 13:18:42 +00:00
|
|
|
mData.Assign(aData);
|
|
|
|
SplitString(mData, mArray);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Each rowalign='top bottom' or columnalign='left right center' (from
|
|
|
|
// <mtable> or <mtr>) is split once (lazily) into a nsValueList which is
|
|
|
|
// stored in the frame manager. Cell frames query the frame manager
|
|
|
|
// to see what values apply to them.
|
|
|
|
|
|
|
|
// XXX these are essentially temporary hacks until the content model
|
|
|
|
// caters for MathML and the Style System has some provisions for MathML.
|
2001-05-19 10:00:01 +00:00
|
|
|
// See bug 69409 - MathML attributes are not mapped to style.
|
|
|
|
// This code is not suitable for dynamic updates, for example when the
|
2000-05-16 13:18:42 +00:00
|
|
|
// rowalign and columalign attributes are changed with JavaScript.
|
|
|
|
// The code doesn't include hooks for AttributeChanged() notifications.
|
|
|
|
|
|
|
|
static void
|
|
|
|
DestroyValueListFunc(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName,
|
|
|
|
void* aPropertyValue)
|
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
delete NS_STATIC_CAST(nsValueList*, aPropertyValue);
|
2000-05-16 13:18:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static PRUnichar*
|
|
|
|
GetAlignValueAt(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aTableOrRowFrame,
|
|
|
|
nsIAtom* aAttributeAtom,
|
|
|
|
PRInt32 aIndex)
|
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
PRUnichar* result = nsnull;
|
2000-05-16 13:18:42 +00:00
|
|
|
nsValueList* valueList = nsnull;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
aPresContext->GetShell(getter_AddRefs(presShell));
|
2001-05-19 10:00:01 +00:00
|
|
|
if (presShell) {
|
2000-05-16 13:18:42 +00:00
|
|
|
nsCOMPtr<nsIFrameManager> frameManager;
|
|
|
|
presShell->GetFrameManager(getter_AddRefs(frameManager));
|
2001-05-19 10:00:01 +00:00
|
|
|
if (frameManager) {
|
|
|
|
frameManager->GetFrameProperty(aTableOrRowFrame, aAttributeAtom,
|
2000-05-16 13:18:42 +00:00
|
|
|
0, (void**)&valueList);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (!valueList) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// The property isn't there yet, so set it
|
|
|
|
nsAutoString values;
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
aTableOrRowFrame->GetContent(getter_AddRefs(content));
|
2001-08-17 09:54:04 +00:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttr(kNameSpaceID_None, aAttributeAtom, values)) {
|
2000-05-16 13:18:42 +00:00
|
|
|
valueList = new nsValueList(values);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (valueList) {
|
2000-05-16 13:18:42 +00:00
|
|
|
frameManager->SetFrameProperty(aTableOrRowFrame, aAttributeAtom,
|
|
|
|
valueList, DestroyValueListFunc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
if (valueList) {
|
2000-05-16 13:18:42 +00:00
|
|
|
PRInt32 count = valueList->mArray.Count();
|
|
|
|
result = (aIndex < count)
|
|
|
|
? (PRUnichar*)(valueList->mArray[aIndex])
|
|
|
|
: (PRUnichar*)(valueList->mArray[count-1]);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
MapAlignAttributesInto(nsIPresContext* aPresContext,
|
2001-05-19 10:00:01 +00:00
|
|
|
nsIContent* aCellContent,
|
2000-05-16 13:18:42 +00:00
|
|
|
nsIFrame* aCellFrame,
|
2001-05-19 10:00:01 +00:00
|
|
|
nsIFrame* aCellInnerFrame)
|
2000-05-16 13:18:42 +00:00
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
nsresult rv;
|
|
|
|
PRInt32 index;
|
2000-05-16 13:18:42 +00:00
|
|
|
nsAutoString value;
|
|
|
|
|
|
|
|
nsTableCellFrame* cellFrame;
|
|
|
|
cellFrame = NS_STATIC_CAST(nsTableCellFrame*, aCellFrame);
|
|
|
|
|
|
|
|
nsIFrame* tableFrame;
|
|
|
|
nsIFrame* rowgroupFrame;
|
|
|
|
nsIFrame* rowFrame;
|
|
|
|
|
|
|
|
cellFrame->GetParent(&rowFrame);
|
|
|
|
rowFrame->GetParent(&rowgroupFrame);
|
|
|
|
rowgroupFrame->GetParent(&tableFrame);
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
// update rowalign on the cell
|
|
|
|
|
|
|
|
PRUnichar* rowalign = nsnull;
|
|
|
|
rv = cellFrame->GetRowIndex(index);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the rowalign attribute is not already set
|
|
|
|
nsIAtom* atom = nsMathMLAtoms::rowalign_;
|
2001-08-17 09:54:04 +00:00
|
|
|
rv = aCellContent->GetAttr(kNameSpaceID_None, atom, value);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_CONTENT_ATTR_NOT_THERE == rv) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the rowalign attribute is specified on the row
|
|
|
|
rowalign = GetAlignValueAt(aPresContext, rowFrame, atom, index);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (!rowalign) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the rowalign attribute is specified on the table
|
|
|
|
rowalign = GetAlignValueAt(aPresContext, tableFrame, atom, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
// update column on the cell
|
|
|
|
|
|
|
|
PRUnichar* columnalign = nsnull;
|
|
|
|
rv = cellFrame->GetColIndex(index);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the columnalign attribute is not already set
|
|
|
|
nsIAtom* atom = nsMathMLAtoms::columnalign_;
|
2001-08-17 09:54:04 +00:00
|
|
|
rv = aCellContent->GetAttr(kNameSpaceID_None, atom, value);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_CONTENT_ATTR_NOT_THERE == rv) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the columnalign attribute is specified on the row
|
|
|
|
columnalign = GetAlignValueAt(aPresContext, rowFrame, atom, index);
|
2001-05-19 10:00:01 +00:00
|
|
|
if (!columnalign) {
|
2000-05-16 13:18:42 +00:00
|
|
|
// see if the columnalign attribute is specified on the table
|
|
|
|
columnalign = GetAlignValueAt(aPresContext, tableFrame, atom, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
// set the attributes without notifying that we want a reflow
|
|
|
|
if (rowalign) {
|
2000-05-16 13:18:42 +00:00
|
|
|
value.Assign(rowalign);
|
2001-08-17 09:54:04 +00:00
|
|
|
aCellContent->SetAttr(kNameSpaceID_None, nsMathMLAtoms::rowalign_,
|
|
|
|
value, PR_FALSE);
|
2000-05-16 13:18:42 +00:00
|
|
|
}
|
2001-05-19 10:00:01 +00:00
|
|
|
if (columnalign) {
|
2000-05-16 13:18:42 +00:00
|
|
|
value.Assign(columnalign);
|
2001-08-17 09:54:04 +00:00
|
|
|
aCellContent->SetAttr(kNameSpaceID_None, nsMathMLAtoms::columnalign_,
|
|
|
|
value, PR_FALSE);
|
2001-05-19 10:00:01 +00:00
|
|
|
}
|
|
|
|
// then, re-resolve the style contexts in our subtree
|
|
|
|
if (rowalign || columnalign) {
|
|
|
|
nsCOMPtr<nsIStyleContext> parentContext;
|
|
|
|
nsCOMPtr<nsIStyleContext> newContext;
|
|
|
|
rowFrame->GetStyleContext(getter_AddRefs(parentContext));
|
|
|
|
aPresContext->ResolveStyleContextFor(aCellContent, parentContext,
|
|
|
|
PR_FALSE, getter_AddRefs(newContext));
|
|
|
|
nsCOMPtr<nsIStyleContext> oldContext;
|
|
|
|
aCellFrame->GetStyleContext(getter_AddRefs(oldContext));
|
|
|
|
if (oldContext != newContext) {
|
|
|
|
aCellFrame->SetStyleContext(aPresContext, newContext);
|
|
|
|
aPresContext->ReParentStyleContext(aCellInnerFrame, newContext);
|
|
|
|
}
|
2000-05-16 13:18:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
// --------
|
|
|
|
// implementation of nsMathMLmtableOuterFrame
|
|
|
|
|
2001-02-23 16:10:51 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsMathMLmtableOuterFrame, nsMathMLFrame)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsMathMLmtableOuterFrame, nsMathMLFrame)
|
|
|
|
NS_IMPL_QUERY_INTERFACE_INHERITED1(nsMathMLmtableOuterFrame, nsTableOuterFrame, nsMathMLFrame)
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
nsresult
|
|
|
|
NS_NewMathMLmtableOuterFrame (nsIPresShell* aPresShell, nsIFrame** aNewFrame)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
|
|
if (nsnull == aNewFrame) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
nsMathMLmtableOuterFrame* it = new (aPresShell) nsMathMLmtableOuterFrame;
|
|
|
|
if (!it)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
*aNewFrame = it;
|
|
|
|
return NS_OK;
|
2001-05-19 10:00:01 +00:00
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsMathMLmtableOuterFrame::nsMathMLmtableOuterFrame()
|
|
|
|
:nsTableOuterFrame()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsMathMLmtableOuterFrame::~nsMathMLmtableOuterFrame()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsMathMLmtableOuterFrame::Init(nsIPresContext* aPresContext,
|
|
|
|
nsIContent* aContent,
|
|
|
|
nsIFrame* aParent,
|
|
|
|
nsIStyleContext* aContext,
|
|
|
|
nsIFrame* aPrevInFlow)
|
|
|
|
{
|
|
|
|
nsresult rv = nsTableOuterFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
|
|
|
|
|
2001-02-23 16:10:51 +00:00
|
|
|
// XXX the REC says that by default, displaystyle=false in <mtable>
|
|
|
|
|
2002-01-12 03:04:14 +00:00
|
|
|
// now, inherit the scriptlevel and displaystyle from our parent
|
2002-01-12 08:06:08 +00:00
|
|
|
GetPresentationDataFrom(aParent, mPresentationData);
|
2001-02-23 16:10:51 +00:00
|
|
|
|
|
|
|
// see if the displaystyle attribute is there and let it override what we inherited
|
|
|
|
nsAutoString value;
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE ==
|
2002-01-12 08:06:08 +00:00
|
|
|
GetAttribute(mContent, nsnull, nsMathMLAtoms::displaystyle_, value)) {
|
2001-05-19 10:00:01 +00:00
|
|
|
if (value.Equals(NS_LITERAL_STRING("true"))) {
|
2001-02-23 16:10:51 +00:00
|
|
|
mPresentationData.flags |= NS_MATHML_DISPLAYSTYLE;
|
|
|
|
}
|
2001-05-19 10:00:01 +00:00
|
|
|
else if (value.Equals(NS_LITERAL_STRING("false"))) {
|
2001-02-23 16:10:51 +00:00
|
|
|
mPresentationData.flags &= ~NS_MATHML_DISPLAYSTYLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsMathMLmtableOuterFrame::Reflow(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
nsresult rv;
|
2000-05-16 13:18:42 +00:00
|
|
|
// we want to return a table that is centered according to the align attribute
|
2001-05-19 10:00:01 +00:00
|
|
|
|
|
|
|
nsHTMLReflowState reflowState(aReflowState);
|
|
|
|
if ((NS_FRAME_FIRST_REFLOW & mState) &&
|
|
|
|
(NS_UNCONSTRAINEDSIZE == reflowState.availableWidth)) {
|
|
|
|
// We are going to reflow twice because the table frame code is
|
|
|
|
// skipping the Pass 2 reflow when, at the Pass 1 reflow, the available
|
|
|
|
// size is unconstrained. Skipping the Pass2 messes the MathML vertical
|
|
|
|
// alignments that are resolved during the reflow of cell frames.
|
|
|
|
|
|
|
|
nscoord oldAvailableWidth = reflowState.availableWidth;
|
|
|
|
nscoord oldComputedWidth = reflowState.mComputedWidth;
|
|
|
|
|
|
|
|
reflowState.availableWidth = NS_UNCONSTRAINEDSIZE;
|
|
|
|
reflowState.mComputedWidth = NS_UNCONSTRAINEDSIZE;
|
|
|
|
reflowState.reason = eReflowReason_Initial;
|
|
|
|
|
|
|
|
rv = nsTableOuterFrame::Reflow(aPresContext, aDesiredSize, reflowState, aStatus);
|
|
|
|
|
|
|
|
// The second reflow will just be a reflow with a constrained width
|
|
|
|
reflowState.availableWidth = aDesiredSize.width;
|
|
|
|
reflowState.mComputedWidth = oldComputedWidth;
|
|
|
|
reflowState.reason = eReflowReason_StyleChange;
|
|
|
|
|
|
|
|
mState &= ~NS_FRAME_FIRST_REFLOW;
|
|
|
|
}
|
|
|
|
else if (mRect.width) {
|
|
|
|
reflowState.availableWidth = mRect.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = nsTableOuterFrame::Reflow(aPresContext, aDesiredSize, reflowState, aStatus);
|
|
|
|
NS_ASSERTION(aDesiredSize.height >= 0, "illegal height for mtable");
|
|
|
|
NS_ASSERTION(aDesiredSize.width >= 0, "illegal width for mtable");
|
2000-03-28 10:15:19 +00:00
|
|
|
|
2000-05-08 07:23:22 +00:00
|
|
|
// see if the user has set the align attribute on the <mtable>
|
2000-05-16 13:18:42 +00:00
|
|
|
// XXX should we also check <mstyle> ?
|
2000-05-08 07:23:22 +00:00
|
|
|
nsAutoString value;
|
|
|
|
PRBool alignAttribute = PR_FALSE;
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE ==
|
2002-01-12 08:06:08 +00:00
|
|
|
GetAttribute(mContent, nsnull, nsMathMLAtoms::align_, value)) {
|
2001-05-19 10:00:01 +00:00
|
|
|
if (value.Equals(NS_LITERAL_STRING("top"))) {
|
2000-05-08 07:23:22 +00:00
|
|
|
aDesiredSize.ascent = 0;
|
|
|
|
aDesiredSize.descent = aDesiredSize.height;
|
|
|
|
alignAttribute = PR_TRUE;
|
|
|
|
}
|
2001-05-19 10:00:01 +00:00
|
|
|
else if (value.Equals(NS_LITERAL_STRING("bottom"))) {
|
2000-05-08 07:23:22 +00:00
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
|
|
aDesiredSize.descent = 0;
|
|
|
|
alignAttribute = PR_TRUE;
|
|
|
|
}
|
2001-05-19 10:00:01 +00:00
|
|
|
else if (value.Equals(NS_LITERAL_STRING("center")) ||
|
|
|
|
value.Equals(NS_LITERAL_STRING("baseline"))) {
|
2000-05-08 07:23:22 +00:00
|
|
|
aDesiredSize.ascent = aDesiredSize.height/2;
|
|
|
|
aDesiredSize.descent = aDesiredSize.height - aDesiredSize.ascent;
|
|
|
|
alignAttribute = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!alignAttribute) {
|
|
|
|
// by default, center about the axis
|
|
|
|
|
2001-05-31 22:19:43 +00:00
|
|
|
const nsStyleFont *font = NS_STATIC_CAST(const nsStyleFont*,
|
|
|
|
mStyleContext->GetStyleData(eStyleStruct_Font));
|
2002-01-11 05:08:11 +00:00
|
|
|
aReflowState.rendContext->SetFont(font->mFont);
|
2000-05-08 07:23:22 +00:00
|
|
|
nsCOMPtr<nsIFontMetrics> fm;
|
2002-01-11 05:08:11 +00:00
|
|
|
aReflowState.rendContext->GetFontMetrics(*getter_AddRefs(fm));
|
2001-05-31 22:19:43 +00:00
|
|
|
|
2000-05-08 07:23:22 +00:00
|
|
|
nscoord axisHeight;
|
2002-01-10 23:40:40 +00:00
|
|
|
GetAxisHeight(*aReflowState.rendContext, fm, axisHeight);
|
2000-05-08 07:23:22 +00:00
|
|
|
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height/2 + axisHeight;
|
|
|
|
aDesiredSize.descent = aDesiredSize.height - aDesiredSize.ascent;
|
|
|
|
}
|
2000-03-28 10:15:19 +00:00
|
|
|
|
|
|
|
// just make-up a bounding metrics
|
|
|
|
mBoundingMetrics.Clear();
|
|
|
|
mBoundingMetrics.ascent = aDesiredSize.ascent;
|
|
|
|
mBoundingMetrics.descent = aDesiredSize.descent;
|
|
|
|
mBoundingMetrics.width = aDesiredSize.width;
|
|
|
|
mBoundingMetrics.leftBearing = 0;
|
|
|
|
mBoundingMetrics.rightBearing = aDesiredSize.width;
|
|
|
|
|
|
|
|
aDesiredSize.mBoundingMetrics = mBoundingMetrics;
|
2000-05-16 13:18:42 +00:00
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-05-16 13:18:42 +00:00
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
// --------
|
2001-05-19 10:00:01 +00:00
|
|
|
// implementation of nsMathMLmtdInnerFrame
|
2000-03-28 10:15:19 +00:00
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsMathMLmtdInnerFrame, nsMathMLFrame)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsMathMLmtdInnerFrame, nsMathMLFrame)
|
|
|
|
NS_IMPL_QUERY_INTERFACE_INHERITED1(nsMathMLmtdInnerFrame, nsBlockFrame, nsMathMLFrame)
|
2001-02-23 16:10:51 +00:00
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
nsresult
|
2001-05-19 10:00:01 +00:00
|
|
|
NS_NewMathMLmtdInnerFrame(nsIPresShell* aPresShell, nsIFrame** aNewFrame)
|
2000-03-28 10:15:19 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
|
|
if (nsnull == aNewFrame) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2001-05-19 10:00:01 +00:00
|
|
|
nsMathMLmtdInnerFrame* it = new (aPresShell) nsMathMLmtdInnerFrame;
|
2000-03-28 10:15:19 +00:00
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
*aNewFrame = it;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
nsMathMLmtdInnerFrame::nsMathMLmtdInnerFrame()
|
2000-03-28 10:15:19 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
nsMathMLmtdInnerFrame::~nsMathMLmtdInnerFrame()
|
2000-03-28 10:15:19 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2001-02-23 16:10:51 +00:00
|
|
|
NS_IMETHODIMP
|
2001-05-19 10:00:01 +00:00
|
|
|
nsMathMLmtdInnerFrame::Init(nsIPresContext* aPresContext,
|
2002-01-09 18:51:30 +00:00
|
|
|
nsIContent* aContent,
|
|
|
|
nsIFrame* aParent,
|
|
|
|
nsIStyleContext* aContext,
|
|
|
|
nsIFrame* aPrevInFlow)
|
2001-02-23 16:10:51 +00:00
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
rv = nsBlockFrame::Init(aPresContext, aContent, aParent, aContext, aPrevInFlow);
|
|
|
|
|
2001-05-19 10:00:01 +00:00
|
|
|
// record that children that are ignorable whitespace should be excluded
|
2001-02-23 16:10:51 +00:00
|
|
|
mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
|
|
|
|
|
2002-01-12 03:04:14 +00:00
|
|
|
// now, inherit the scriptlevel and displaystyle from our parent
|
2002-01-12 08:06:08 +00:00
|
|
|
GetPresentationDataFrom(aParent, mPresentationData);
|
2001-02-23 16:10:51 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
NS_IMETHODIMP
|
2001-05-19 10:00:01 +00:00
|
|
|
nsMathMLmtdInnerFrame::Reflow(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
2000-03-28 10:15:19 +00:00
|
|
|
{
|
2001-05-19 10:00:01 +00:00
|
|
|
// Map attributes to style (hopefully, bug 69409 will eventually help here).
|
2000-05-16 13:18:42 +00:00
|
|
|
if (NS_FRAME_FIRST_REFLOW & mState) {
|
2001-05-19 10:00:01 +00:00
|
|
|
MapAlignAttributesInto(aPresContext, mContent, mParent, this);
|
2000-05-16 13:18:42 +00:00
|
|
|
}
|
|
|
|
|
2000-03-28 10:15:19 +00:00
|
|
|
// Let the base class do the reflow
|
2000-05-11 23:03:19 +00:00
|
|
|
nsresult rv = nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
2000-03-28 10:15:19 +00:00
|
|
|
|
|
|
|
// more about <maligngroup/> and <malignmark/> later
|
|
|
|
// ...
|
|
|
|
return rv;
|
|
|
|
}
|