static uint32_t GetStretchHint(nsOperatorFlags aFlags, nsPresentationData aPresentationData, bool aIsVertical) { uint32_t stretchHint = NS_STRETCH_NONE; // See if it is okay to stretch, // starting from what the Operator Dictionary said if (NS_MATHML_OPERATOR_IS_MUTABLE(aFlags)) { // set the largeop or largeopOnly flags to suitably cover all the // 8 possible cases depending on whether displaystyle, largeop, // stretchy are true or false (see bug 69325). // . largeopOnly is taken if largeop=true and stretchy=false // . largeop is taken if largeop=true and stretchy=true if (NS_MATHML_IS_DISPLAYSTYLE(aPresentationData.flags) && NS_MATHML_OPERATOR_IS_LARGEOP(aFlags)) { stretchHint = NS_STRETCH_LARGEOP; // (largeopOnly, not mask!) if (NS_MATHML_OPERATOR_IS_INTEGRAL(aFlags)) { stretchHint |= NS_STRETCH_INTEGRAL; } if (NS_MATHML_OPERATOR_IS_STRETCHY(aFlags)) { stretchHint |= NS_STRETCH_NEARER | NS_STRETCH_LARGER; } } else if(NS_MATHML_OPERATOR_IS_STRETCHY(aFlags)) { if (aIsVertical) { // TeX hint. Can impact some sloppy markups missing <mrow></mrow> stretchHint = NS_STRETCH_NEARER; } else { stretchHint = NS_STRETCH_NORMAL; } } // else if the stretchy and largeop attributes have been disabled, // the operator is not mutable } return stretchHint; }
PRBool nsMathMLOperators::IsMutableOperator(const nsString& aOperator) { if (!gInitialized) { InitGlobals(); } // lookup all the variants of the operator and return true if there // is a variant that is stretchy or largeop nsOperatorFlags flags[4]; float lspace[4], rspace[4]; nsMathMLOperators::LookupOperators(aOperator, flags, lspace, rspace); nsOperatorFlags allFlags = flags[NS_MATHML_OPERATOR_FORM_INFIX] | flags[NS_MATHML_OPERATOR_FORM_POSTFIX] | flags[NS_MATHML_OPERATOR_FORM_PREFIX]; return NS_MATHML_OPERATOR_IS_STRETCHY(allFlags) || NS_MATHML_OPERATOR_IS_LARGEOP(allFlags); }
// get the text that we enclose and setup our nsMathMLChar void nsMathMLmoFrame::ProcessTextData() { mFlags = 0; nsAutoString data; nsContentUtils::GetNodeTextContent(mContent, false, data); data.CompressWhitespace(); int32_t length = data.Length(); PRUnichar ch = (length == 0) ? kNullCh : data[0]; if ((length == 1) && (ch == kInvisibleComma || ch == kApplyFunction || ch == kInvisibleTimes)) { mFlags |= NS_MATHML_OPERATOR_INVISIBLE; } // don't bother doing anything special if we don't have a // single child with a visible text content nsPresContext* presContext = PresContext(); if (NS_MATHML_OPERATOR_IS_INVISIBLE(mFlags) || mFrames.GetLength() != 1) { data.Truncate(); // empty data to reset the char mMathMLChar.SetData(presContext, data); ResolveMathMLCharStyle(presContext, mContent, mStyleContext, &mMathMLChar, false); return; } // special... in math mode, the usual minus sign '-' looks too short, so // what we do here is to remap <mo>-</mo> to the official Unicode minus // sign (U+2212) which looks much better. For background on this, see // http://groups.google.com/groups?hl=en&th=66488daf1ade7635&rnum=1 if (1 == length && ch == '-') { ch = 0x2212; data = ch; } // cache the special bits: mutable, accent, movablelimits, centered. // we need to do this in anticipation of other requirements, and these // bits don't change. Do not reset these bits unless the text gets changed. // lookup all the forms under which the operator is listed in the dictionary, // and record whether the operator has accent="true" or movablelimits="true" nsOperatorFlags flags[4]; float lspace[4], rspace[4]; nsMathMLOperators::LookupOperators(data, flags, lspace, rspace); nsOperatorFlags allFlags = flags[NS_MATHML_OPERATOR_FORM_INFIX] | flags[NS_MATHML_OPERATOR_FORM_POSTFIX] | flags[NS_MATHML_OPERATOR_FORM_PREFIX]; mFlags |= allFlags & NS_MATHML_OPERATOR_ACCENT; mFlags |= allFlags & NS_MATHML_OPERATOR_MOVABLELIMITS; bool isMutable = NS_MATHML_OPERATOR_IS_STRETCHY(allFlags) || NS_MATHML_OPERATOR_IS_LARGEOP(allFlags); if (isMutable) mFlags |= NS_MATHML_OPERATOR_MUTABLE; // see if this is an operator that should be centered to cater for // fonts that are not math-aware if (1 == length) { if ((ch == '+') || (ch == '=') || (ch == '*') || (ch == 0x2212) || // − (ch == 0x2264) || // ≤ (ch == 0x2265) || // ≥ (ch == 0x00D7)) { // × mFlags |= NS_MATHML_OPERATOR_CENTERED; } } // cache the operator mMathMLChar.SetData(presContext, data); ResolveMathMLCharStyle(presContext, mContent, mStyleContext, &mMathMLChar, isMutable); // cache the native direction -- beware of bug 133429... // mEmbellishData.direction must always retain our native direction, whereas // mMathMLChar.GetStretchDirection() may change later, when Stretch() is called mEmbellishData.direction = mMathMLChar.GetStretchDirection(); }