/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim:set ts=4 sw=4 sts=4 et cindent: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "nsTextBoxFrame.h" #include "gfx2DGlue.h" #include "gfxUtils.h" #include "mozilla/gfx/2D.h" #include "nsFontMetrics.h" #include "nsReadableUtils.h" #include "nsCOMPtr.h" #include "nsGkAtoms.h" #include "nsPresContext.h" #include "nsRenderingContext.h" #include "nsStyleContext.h" #include "nsIContent.h" #include "nsNameSpaceManager.h" #include "nsBoxLayoutState.h" #include "nsMenuBarListener.h" #include "nsXPIDLString.h" #include "nsIServiceManager.h" #include "nsIDOMElement.h" #include "nsIDOMXULLabelElement.h" #include "mozilla/EventStateManager.h" #include "nsITheme.h" #include "nsUnicharUtils.h" #include "nsContentUtils.h" #include "nsDisplayList.h" #include "nsCSSRendering.h" #include "nsIReflowCallback.h" #include "nsBoxFrame.h" #include "mozilla/Preferences.h" #include "nsLayoutUtils.h" #include "mozilla/Attributes.h" #include "nsUnicodeProperties.h" #ifdef ACCESSIBILITY #include "nsAccessibilityService.h" #endif #include "nsBidiUtils.h" #include "nsBidiPresUtils.h" using namespace mozilla; using namespace mozilla::gfx; class nsAccessKeyInfo { public: int32_t mAccesskeyIndex; nscoord mBeforeWidth, mAccessWidth, mAccessUnderlineSize, mAccessOffset; }; bool nsTextBoxFrame::gAlwaysAppendAccessKey = false; bool nsTextBoxFrame::gAccessKeyPrefInitialized = false; bool nsTextBoxFrame::gInsertSeparatorBeforeAccessKey = false; bool nsTextBoxFrame::gInsertSeparatorPrefInitialized = false; nsIFrame* NS_NewTextBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext) { return new (aPresShell) nsTextBoxFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsTextBoxFrame) NS_QUERYFRAME_HEAD(nsTextBoxFrame) NS_QUERYFRAME_ENTRY(nsTextBoxFrame) NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame) nsresult nsTextBoxFrame::AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) { bool aResize; bool aRedraw; UpdateAttributes(aAttribute, aResize, aRedraw); if (aResize) { PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); } else if (aRedraw) { nsBoxLayoutState state(PresContext()); XULRedraw(state); } // If the accesskey changed, register for the new value // The old value has been unregistered in nsXULElement::SetAttr if (aAttribute == nsGkAtoms::accesskey || aAttribute == nsGkAtoms::control) RegUnregAccessKey(true); return NS_OK; } nsTextBoxFrame::nsTextBoxFrame(nsStyleContext* aContext): nsLeafBoxFrame(aContext), mAccessKeyInfo(nullptr), mCropType(CropRight), mNeedsReflowCallback(false) { MarkIntrinsicISizesDirty(); } nsTextBoxFrame::~nsTextBoxFrame() { delete mAccessKeyInfo; } void nsTextBoxFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) { nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow); bool aResize; bool aRedraw; UpdateAttributes(nullptr, aResize, aRedraw); /* update all */ // register access key RegUnregAccessKey(true); } void nsTextBoxFrame::DestroyFrom(nsIFrame* aDestructRoot) { // unregister access key RegUnregAccessKey(false); nsLeafBoxFrame::DestroyFrom(aDestructRoot); } bool nsTextBoxFrame::AlwaysAppendAccessKey() { if (!gAccessKeyPrefInitialized) { gAccessKeyPrefInitialized = true; const char* prefName = "intl.menuitems.alwaysappendaccesskeys"; nsAdoptingString val = Preferences::GetLocalizedString(prefName); gAlwaysAppendAccessKey = val.EqualsLiteral("true"); } return gAlwaysAppendAccessKey; } bool nsTextBoxFrame::InsertSeparatorBeforeAccessKey() { if (!gInsertSeparatorPrefInitialized) { gInsertSeparatorPrefInitialized = true; const char* prefName = "intl.menuitems.insertseparatorbeforeaccesskeys"; nsAdoptingString val = Preferences::GetLocalizedString(prefName); gInsertSeparatorBeforeAccessKey = val.EqualsLiteral("true"); } return gInsertSeparatorBeforeAccessKey; } class nsAsyncAccesskeyUpdate final : public nsIReflowCallback { public: explicit nsAsyncAccesskeyUpdate(nsIFrame* aFrame) : mWeakFrame(aFrame) { } virtual bool ReflowFinished() override { bool shouldFlush = false; nsTextBoxFrame* frame = static_cast<nsTextBoxFrame*>(mWeakFrame.GetFrame()); if (frame) { shouldFlush = frame->UpdateAccesskey(mWeakFrame); } delete this; return shouldFlush; } virtual void ReflowCallbackCanceled() override { delete this; } nsWeakFrame mWeakFrame; }; bool nsTextBoxFrame::UpdateAccesskey(nsWeakFrame& aWeakThis) { nsAutoString accesskey; nsCOMPtr<nsIDOMXULLabelElement> labelElement = do_QueryInterface(mContent); NS_ENSURE_TRUE(aWeakThis.IsAlive(), false); if (labelElement) { // Accesskey may be stored on control. labelElement->GetAccessKey(accesskey); NS_ENSURE_TRUE(aWeakThis.IsAlive(), false); } else { mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accesskey); } if (!accesskey.Equals(mAccessKey)) { // Need to get clean mTitle. RecomputeTitle(); mAccessKey = accesskey; UpdateAccessTitle(); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); return true; } return false; } void nsTextBoxFrame::UpdateAttributes(nsIAtom* aAttribute, bool& aResize, bool& aRedraw) { bool doUpdateTitle = false; aResize = false; aRedraw = false; if (aAttribute == nullptr || aAttribute == nsGkAtoms::crop) { static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::left, &nsGkAtoms::start, &nsGkAtoms::center, &nsGkAtoms::right, &nsGkAtoms::end, &nsGkAtoms::none, nullptr}; CroppingStyle cropType; switch (mContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::crop, strings, eCaseMatters)) { case 0: case 1: cropType = CropLeft; break; case 2: cropType = CropCenter; break; case 3: case 4: cropType = CropRight; break; case 5: cropType = CropNone; break; default: cropType = CropAuto; break; } if (cropType != mCropType) { aResize = true; mCropType = cropType; } } if (aAttribute == nullptr || aAttribute == nsGkAtoms::value) { RecomputeTitle(); doUpdateTitle = true; } if (aAttribute == nullptr || aAttribute == nsGkAtoms::accesskey) { mNeedsReflowCallback = true; // Ensure that layout is refreshed and reflow callback called. aResize = true; } if (doUpdateTitle) { UpdateAccessTitle(); aResize = true; } } class nsDisplayXULTextBox : public nsDisplayItem { public: nsDisplayXULTextBox(nsDisplayListBuilder* aBuilder, nsTextBoxFrame* aFrame) : nsDisplayItem(aBuilder, aFrame), mDisableSubpixelAA(false) { MOZ_COUNT_CTOR(nsDisplayXULTextBox); } #ifdef NS_BUILD_REFCNT_LOGGING virtual ~nsDisplayXULTextBox() { MOZ_COUNT_DTOR(nsDisplayXULTextBox); } #endif virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override; virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override; NS_DISPLAY_DECL_NAME("XULTextBox", TYPE_XUL_TEXT_BOX) virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override; virtual void DisableComponentAlpha() override { mDisableSubpixelAA = true; } void PaintTextToContext(nsRenderingContext* aCtx, nsPoint aOffset, const nscolor* aColor); bool mDisableSubpixelAA; }; static void PaintTextShadowCallback(nsRenderingContext* aCtx, nsPoint aShadowOffset, const nscolor& aShadowColor, void* aData) { reinterpret_cast<nsDisplayXULTextBox*>(aData)-> PaintTextToContext(aCtx, aShadowOffset, &aShadowColor); } void nsDisplayXULTextBox::Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) { DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(), mDisableSubpixelAA); // Paint the text shadow before doing any foreground stuff nsRect drawRect = static_cast<nsTextBoxFrame*>(mFrame)->mTextDrawRect + ToReferenceFrame(); nsLayoutUtils::PaintTextShadow(mFrame, aCtx, drawRect, mVisibleRect, mFrame->StyleColor()->mColor, PaintTextShadowCallback, (void*)this); PaintTextToContext(aCtx, nsPoint(0, 0), nullptr); } void nsDisplayXULTextBox::PaintTextToContext(nsRenderingContext* aCtx, nsPoint aOffset, const nscolor* aColor) { static_cast<nsTextBoxFrame*>(mFrame)-> PaintTitle(*aCtx, mVisibleRect, ToReferenceFrame() + aOffset, aColor); } nsRect nsDisplayXULTextBox::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) { *aSnap = false; return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame(); } nsRect nsDisplayXULTextBox::GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) { return static_cast<nsTextBoxFrame*>(mFrame)->GetComponentAlphaBounds() + ToReferenceFrame(); } void nsTextBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { if (!IsVisibleForPainting(aBuilder)) return; nsLeafBoxFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists); aLists.Content()->AppendNewToTop(new (aBuilder) nsDisplayXULTextBox(aBuilder, this)); } void nsTextBoxFrame::PaintTitle(nsRenderingContext& aRenderingContext, const nsRect& aDirtyRect, nsPoint aPt, const nscolor* aOverrideColor) { if (mTitle.IsEmpty()) return; DrawText(aRenderingContext, aDirtyRect, mTextDrawRect + aPt, aOverrideColor); } void nsTextBoxFrame::DrawText(nsRenderingContext& aRenderingContext, const nsRect& aDirtyRect, const nsRect& aTextRect, const nscolor* aOverrideColor) { nsPresContext* presContext = PresContext(); int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel(); DrawTarget* drawTarget = aRenderingContext.GetDrawTarget(); // paint the title nscolor overColor = 0; nscolor underColor = 0; nscolor strikeColor = 0; uint8_t overStyle = 0; uint8_t underStyle = 0; uint8_t strikeStyle = 0; // Begin with no decorations uint8_t decorations = NS_STYLE_TEXT_DECORATION_LINE_NONE; // A mask of all possible decorations. uint8_t decorMask = NS_STYLE_TEXT_DECORATION_LINE_LINES_MASK; WritingMode wm = GetWritingMode(); bool vertical = wm.IsVertical(); nsIFrame* f = this; do { // find decoration colors nsStyleContext* context = f->StyleContext(); if (!context->HasTextDecorationLines()) { break; } const nsStyleTextReset* styleText = context->StyleTextReset(); if (decorMask & styleText->mTextDecorationLine) { // a decoration defined here nscolor color; if (aOverrideColor) { color = *aOverrideColor; } else { color = context->StyleColor()-> CalcComplexColor(styleText->mTextDecorationColor); } uint8_t style = styleText->mTextDecorationStyle; if (NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE & decorMask & styleText->mTextDecorationLine) { underColor = color; underStyle = style; decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; decorations |= NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; } if (NS_STYLE_TEXT_DECORATION_LINE_OVERLINE & decorMask & styleText->mTextDecorationLine) { overColor = color; overStyle = style; decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERLINE; decorations |= NS_STYLE_TEXT_DECORATION_LINE_OVERLINE; } if (NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH & decorMask & styleText->mTextDecorationLine) { strikeColor = color; strikeStyle = style; decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH; decorations |= NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH; } } } while (0 != decorMask && (f = nsLayoutUtils::GetParentOrPlaceholderFor(f))); RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f); fontMet->SetVertical(wm.IsVertical()); fontMet->SetTextOrientation(StyleVisibility()->mTextOrientation); nscoord offset; nscoord size; nscoord ascent = fontMet->MaxAscent(); nsPoint baselinePt; if (wm.IsVertical()) { baselinePt.x = presContext->RoundAppUnitsToNearestDevPixels(aTextRect.x + (wm.IsVerticalRL() ? aTextRect.width - ascent : ascent)); baselinePt.y = aTextRect.y; } else { baselinePt.x = aTextRect.x; baselinePt.y = presContext->RoundAppUnitsToNearestDevPixels(aTextRect.y + ascent); } nsCSSRendering::PaintDecorationLineParams params; params.dirtyRect = ToRect(presContext->AppUnitsToGfxUnits(aDirtyRect)); params.pt = Point(presContext->AppUnitsToGfxUnits(aTextRect.x), presContext->AppUnitsToGfxUnits(aTextRect.y)); params.icoordInFrame = Float(PresContext()->AppUnitsToGfxUnits(mTextDrawRect.x)); params.lineSize = Size(presContext->AppUnitsToGfxUnits(aTextRect.width), 0); params.ascent = presContext->AppUnitsToGfxUnits(ascent); params.vertical = vertical; // XXX todo: vertical-mode support for decorations not tested yet, // probably won't be positioned correctly // Underlines are drawn before overlines, and both before the text // itself, per http://www.w3.org/TR/CSS21/zindex.html point 7.2.1.4.1.1. // (We don't apply this rule to the access-key underline because we only // find out where that is as a side effect of drawing the text, in the // general case -- see below.) if (decorations & (NS_STYLE_TEXT_DECORATION_LINE_OVERLINE | NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE)) { fontMet->GetUnderline(offset, size); params.lineSize.height = presContext->AppUnitsToGfxUnits(size); if ((decorations & NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE) && underStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) { params.color = underColor; params.offset = presContext->AppUnitsToGfxUnits(offset); params.decoration = NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; params.style = underStyle; nsCSSRendering::PaintDecorationLine(this, *drawTarget, params); } if ((decorations & NS_STYLE_TEXT_DECORATION_LINE_OVERLINE) && overStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) { params.color = overColor; params.offset = params.ascent; params.decoration = NS_STYLE_TEXT_DECORATION_LINE_OVERLINE; params.style = overStyle; nsCSSRendering::PaintDecorationLine(this, *drawTarget, params); } } nsRenderingContext refContext( PresContext()->PresShell()->CreateReferenceRenderingContext()); DrawTarget* refDrawTarget = refContext.GetDrawTarget(); CalculateUnderline(refDrawTarget, *fontMet); nscolor c = aOverrideColor ? *aOverrideColor : StyleColor()->mColor; ColorPattern color(ToDeviceColor(c)); aRenderingContext.ThebesContext()->SetColor(Color::FromABGR(c)); nsresult rv = NS_ERROR_FAILURE; if (mState & NS_FRAME_IS_BIDI) { presContext->SetBidiEnabled(); nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(StyleContext()); if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) { // We let the RenderText function calculate the mnemonic's // underline position for us. nsBidiPositionResolve posResolve; posResolve.logicalIndex = mAccessKeyInfo->mAccesskeyIndex; rv = nsBidiPresUtils::RenderText(mCroppedTitle.get(), mCroppedTitle.Length(), level, presContext, aRenderingContext, refDrawTarget, *fontMet, baselinePt.x, baselinePt.y, &posResolve, 1); mAccessKeyInfo->mBeforeWidth = posResolve.visualLeftTwips; mAccessKeyInfo->mAccessWidth = posResolve.visualWidth; } else { rv = nsBidiPresUtils::RenderText(mCroppedTitle.get(), mCroppedTitle.Length(), level, presContext, aRenderingContext, refDrawTarget, *fontMet, baselinePt.x, baselinePt.y); } } if (NS_FAILED(rv)) { fontMet->SetTextRunRTL(false); if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) { // In the simple (non-BiDi) case, we calculate the mnemonic's // underline position by getting the text metric. // XXX are attribute values always two byte? if (mAccessKeyInfo->mAccesskeyIndex > 0) mAccessKeyInfo->mBeforeWidth = nsLayoutUtils:: AppUnitWidthOfString(mCroppedTitle.get(), mAccessKeyInfo->mAccesskeyIndex, *fontMet, refDrawTarget); else mAccessKeyInfo->mBeforeWidth = 0; } fontMet->DrawString(mCroppedTitle.get(), mCroppedTitle.Length(), baselinePt.x, baselinePt.y, &aRenderingContext, refDrawTarget); } if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) { nsRect r(aTextRect.x + mAccessKeyInfo->mBeforeWidth, aTextRect.y + mAccessKeyInfo->mAccessOffset, mAccessKeyInfo->mAccessWidth, mAccessKeyInfo->mAccessUnderlineSize); Rect devPxRect = NSRectToSnappedRect(r, appUnitsPerDevPixel, *drawTarget); drawTarget->FillRect(devPxRect, color); } // Strikeout is drawn on top of the text, per // http://www.w3.org/TR/CSS21/zindex.html point 7.2.1.4.1.1. if ((decorations & NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH) && strikeStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) { fontMet->GetStrikeout(offset, size); params.color = strikeColor; params.lineSize.height = presContext->AppUnitsToGfxUnits(size); params.offset = presContext->AppUnitsToGfxUnits(offset); params.decoration = NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH; params.style = strikeStyle; nsCSSRendering::PaintDecorationLine(this, *drawTarget, params); } } void nsTextBoxFrame::CalculateUnderline(DrawTarget* aDrawTarget, nsFontMetrics& aFontMetrics) { if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) { // Calculate all fields of mAccessKeyInfo which // are the same for both BiDi and non-BiDi frames. const char16_t *titleString = mCroppedTitle.get(); aFontMetrics.SetTextRunRTL(false); mAccessKeyInfo->mAccessWidth = nsLayoutUtils:: AppUnitWidthOfString(titleString[mAccessKeyInfo->mAccesskeyIndex], aFontMetrics, aDrawTarget); nscoord offset, baseline; aFontMetrics.GetUnderline(offset, mAccessKeyInfo->mAccessUnderlineSize); baseline = aFontMetrics.MaxAscent(); mAccessKeyInfo->mAccessOffset = baseline - offset; } } nscoord nsTextBoxFrame::CalculateTitleForWidth(nsRenderingContext& aRenderingContext, nscoord aWidth) { DrawTarget* drawTarget = aRenderingContext.GetDrawTarget(); if (mTitle.IsEmpty()) { mCroppedTitle.Truncate(); return 0; } RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f); // see if the text will completely fit in the width given nscoord titleWidth = nsLayoutUtils::AppUnitWidthOfStringBidi(mTitle, this, *fm, aRenderingContext); if (titleWidth <= aWidth) { mCroppedTitle = mTitle; if (HasRTLChars(mTitle) || StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) { mState |= NS_FRAME_IS_BIDI; } return titleWidth; // fits, done. } const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis(); if (mCropType != CropNone) { // start with an ellipsis mCroppedTitle.Assign(kEllipsis); // see if the width is even smaller than the ellipsis // if so, clear the text (XXX set as many '.' as we can?). fm->SetTextRunRTL(false); titleWidth = nsLayoutUtils::AppUnitWidthOfString(kEllipsis, *fm, drawTarget); if (titleWidth > aWidth) { mCroppedTitle.SetLength(0); return 0; } // if the ellipsis fits perfectly, no use in trying to insert if (titleWidth == aWidth) return titleWidth; aWidth -= titleWidth; } else { mCroppedTitle.Truncate(0); titleWidth = 0; } using mozilla::unicode::ClusterIterator; using mozilla::unicode::ClusterReverseIterator; // ok crop things switch (mCropType) { case CropAuto: case CropNone: case CropRight: { ClusterIterator iter(mTitle.Data(), mTitle.Length()); const char16_t* dataBegin = iter; const char16_t* pos = dataBegin; nscoord charWidth; nscoord totalWidth = 0; while (!iter.AtEnd()) { iter.Next(); const char16_t* nextPos = iter; ptrdiff_t length = nextPos - pos; charWidth = nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget); if (totalWidth + charWidth > aWidth) { break; } if (UCS2_CHAR_IS_BIDI(*pos)) { mState |= NS_FRAME_IS_BIDI; } pos = nextPos; totalWidth += charWidth; } if (pos == dataBegin) { return titleWidth; } // insert what character we can in. nsAutoString title(mTitle); title.Truncate(pos - dataBegin); mCroppedTitle.Insert(title, 0); } break; case CropLeft: { ClusterReverseIterator iter(mTitle.Data(), mTitle.Length()); const char16_t* dataEnd = iter; const char16_t* prevPos = dataEnd; nscoord charWidth; nscoord totalWidth = 0; while (!iter.AtEnd()) { iter.Next(); const char16_t* pos = iter; ptrdiff_t length = prevPos - pos; charWidth = nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget); if (totalWidth + charWidth > aWidth) { break; } if (UCS2_CHAR_IS_BIDI(*pos)) { mState |= NS_FRAME_IS_BIDI; } prevPos = pos; totalWidth += charWidth; } if (prevPos == dataEnd) { return titleWidth; } nsAutoString copy; mTitle.Right(copy, dataEnd - prevPos); mCroppedTitle += copy; } break; case CropCenter: { nscoord stringWidth = nsLayoutUtils::AppUnitWidthOfStringBidi(mTitle, this, *fm, aRenderingContext); if (stringWidth <= aWidth) { // the entire string will fit in the maximum width mCroppedTitle.Insert(mTitle, 0); break; } // determine how much of the string will fit in the max width nscoord charWidth = 0; nscoord totalWidth = 0; ClusterIterator leftIter(mTitle.Data(), mTitle.Length()); ClusterReverseIterator rightIter(mTitle.Data(), mTitle.Length()); const char16_t* dataBegin = leftIter; const char16_t* dataEnd = rightIter; const char16_t* leftPos = dataBegin; const char16_t* rightPos = dataEnd; const char16_t* pos; ptrdiff_t length; nsAutoString leftString, rightString; while (leftPos < rightPos) { leftIter.Next(); pos = leftIter; length = pos - leftPos; charWidth = nsLayoutUtils::AppUnitWidthOfString(leftPos, length, *fm, drawTarget); if (totalWidth + charWidth > aWidth) { break; } if (UCS2_CHAR_IS_BIDI(*leftPos)) { mState |= NS_FRAME_IS_BIDI; } leftString.Append(leftPos, length); leftPos = pos; totalWidth += charWidth; if (leftPos >= rightPos) { break; } rightIter.Next(); pos = rightIter; length = rightPos - pos; charWidth = nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget); if (totalWidth + charWidth > aWidth) { break; } if (UCS2_CHAR_IS_BIDI(*pos)) { mState |= NS_FRAME_IS_BIDI; } rightString.Insert(pos, 0, length); rightPos = pos; totalWidth += charWidth; } mCroppedTitle = leftString + kEllipsis + rightString; } break; } return nsLayoutUtils::AppUnitWidthOfStringBidi(mCroppedTitle, this, *fm, aRenderingContext); } #define OLD_ELLIPSIS NS_LITERAL_STRING("...") // the following block is to append the accesskey to mTitle if there is an accesskey // but the mTitle doesn't have the character void nsTextBoxFrame::UpdateAccessTitle() { /* * Note that if you change appending access key label spec, * you need to maintain same logic in following methods. See bug 324159. * toolkit/content/commonDialog.js (setLabelForNode) * toolkit/content/widgets/text.xml (formatAccessKey) */ int32_t menuAccessKey; nsMenuBarListener::GetMenuAccessKey(&menuAccessKey); if (!menuAccessKey || mAccessKey.IsEmpty()) return; if (!AlwaysAppendAccessKey() && FindInReadable(mAccessKey, mTitle, nsCaseInsensitiveStringComparator())) return; nsAutoString accessKeyLabel; accessKeyLabel += '('; accessKeyLabel += mAccessKey; ToUpperCase(accessKeyLabel); accessKeyLabel += ')'; if (mTitle.IsEmpty()) { mTitle = accessKeyLabel; return; } const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis(); uint32_t offset = mTitle.Length(); if (StringEndsWith(mTitle, kEllipsis)) { offset -= kEllipsis.Length(); } else if (StringEndsWith(mTitle, OLD_ELLIPSIS)) { // Try to check with our old ellipsis (for old addons) offset -= OLD_ELLIPSIS.Length(); } else { // Try to check with // our default ellipsis (for non-localized addons) or ':' const char16_t kLastChar = mTitle.Last(); if (kLastChar == char16_t(0x2026) || kLastChar == char16_t(':')) offset--; } if (InsertSeparatorBeforeAccessKey() && offset > 0 && !NS_IS_SPACE(mTitle[offset - 1])) { mTitle.Insert(' ', offset); offset++; } mTitle.Insert(accessKeyLabel, offset); } void nsTextBoxFrame::UpdateAccessIndex() { int32_t menuAccessKey; nsMenuBarListener::GetMenuAccessKey(&menuAccessKey); if (menuAccessKey) { if (mAccessKey.IsEmpty()) { if (mAccessKeyInfo) { delete mAccessKeyInfo; mAccessKeyInfo = nullptr; } } else { if (!mAccessKeyInfo) { mAccessKeyInfo = new nsAccessKeyInfo(); if (!mAccessKeyInfo) return; } nsAString::const_iterator start, end; mCroppedTitle.BeginReading(start); mCroppedTitle.EndReading(end); // remember the beginning of the string nsAString::const_iterator originalStart = start; bool found; if (!AlwaysAppendAccessKey()) { // not appending access key - do case-sensitive search // first found = FindInReadable(mAccessKey, start, end); if (!found) { // didn't find it - perform a case-insensitive search start = originalStart; found = FindInReadable(mAccessKey, start, end, nsCaseInsensitiveStringComparator()); } } else { found = RFindInReadable(mAccessKey, start, end, nsCaseInsensitiveStringComparator()); } if (found) mAccessKeyInfo->mAccesskeyIndex = Distance(originalStart, start); else mAccessKeyInfo->mAccesskeyIndex = kNotFound; } } } void nsTextBoxFrame::RecomputeTitle() { mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::value, mTitle); // This doesn't handle language-specific uppercasing/lowercasing // rules, unlike textruns. uint8_t textTransform = StyleText()->mTextTransform; if (textTransform == NS_STYLE_TEXT_TRANSFORM_UPPERCASE) { ToUpperCase(mTitle); } else if (textTransform == NS_STYLE_TEXT_TRANSFORM_LOWERCASE) { ToLowerCase(mTitle); } // We can't handle NS_STYLE_TEXT_TRANSFORM_CAPITALIZE because we // have no clue about word boundaries here. We also don't handle // NS_STYLE_TEXT_TRANSFORM_FULL_WIDTH. } void nsTextBoxFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext) { if (!aOldStyleContext) { // We're just being initialized return; } const nsStyleText* oldTextStyle = aOldStyleContext->PeekStyleText(); // We should really have oldTextStyle here, since we asked for our // nsStyleText during Init(), but if it's not there for some reason // just assume the worst and recompute mTitle. if (!oldTextStyle || oldTextStyle->mTextTransform != StyleText()->mTextTransform) { RecomputeTitle(); UpdateAccessTitle(); } } NS_IMETHODIMP nsTextBoxFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState) { if (mNeedsReflowCallback) { nsIReflowCallback* cb = new nsAsyncAccesskeyUpdate(this); if (cb) { PresContext()->PresShell()->PostReflowCallback(cb); } mNeedsReflowCallback = false; } nsresult rv = nsLeafBoxFrame::DoXULLayout(aBoxLayoutState); CalcDrawRect(*aBoxLayoutState.GetRenderingContext()); const nsStyleText* textStyle = StyleText(); nsRect scrollBounds(nsPoint(0, 0), GetSize()); nsRect textRect = mTextDrawRect; RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f); nsBoundingMetrics metrics = fontMet->GetInkBoundsForVisualOverflow(mCroppedTitle.get(), mCroppedTitle.Length(), aBoxLayoutState.GetRenderingContext()->GetDrawTarget()); WritingMode wm = GetWritingMode(); LogicalRect tr(wm, textRect, GetSize()); tr.IStart(wm) -= metrics.leftBearing; tr.ISize(wm) = metrics.width; // In DrawText() we always draw with the baseline at MaxAscent() (relative to mTextDrawRect), tr.BStart(wm) += fontMet->MaxAscent() - metrics.ascent; tr.BSize(wm) = metrics.ascent + metrics.descent; textRect = tr.GetPhysicalRect(wm, GetSize()); // Our scrollable overflow is our bounds; our visual overflow may // extend beyond that. nsRect visualBounds; visualBounds.UnionRect(scrollBounds, textRect); nsOverflowAreas overflow(visualBounds, scrollBounds); if (textStyle->mTextShadow) { // text-shadow extends our visual but not scrollable bounds nsRect &vis = overflow.VisualOverflow(); vis.UnionRect(vis, nsLayoutUtils::GetTextShadowRectsUnion(mTextDrawRect, this)); } FinishAndStoreOverflow(overflow, GetSize()); return rv; } nsRect nsTextBoxFrame::GetComponentAlphaBounds() { if (StyleText()->mTextShadow) { return GetVisualOverflowRectRelativeToSelf(); } return mTextDrawRect; } bool nsTextBoxFrame::ComputesOwnOverflowArea() { return true; } /* virtual */ void nsTextBoxFrame::MarkIntrinsicISizesDirty() { mNeedsRecalc = true; nsLeafBoxFrame::MarkIntrinsicISizesDirty(); } void nsTextBoxFrame::GetTextSize(nsRenderingContext& aRenderingContext, const nsString& aString, nsSize& aSize, nscoord& aAscent) { RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f); aSize.height = fontMet->MaxHeight(); aSize.width = nsLayoutUtils::AppUnitWidthOfStringBidi(aString, this, *fontMet, aRenderingContext); aAscent = fontMet->MaxAscent(); } void nsTextBoxFrame::CalcTextSize(nsBoxLayoutState& aBoxLayoutState) { if (mNeedsRecalc) { nsSize size; nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext(); if (rendContext) { GetTextSize(*rendContext, mTitle, size, mAscent); if (GetWritingMode().IsVertical()) { Swap(size.width, size.height); } mTextSize = size; mNeedsRecalc = false; } } } void nsTextBoxFrame::CalcDrawRect(nsRenderingContext &aRenderingContext) { WritingMode wm = GetWritingMode(); LogicalRect textRect(wm, LogicalPoint(wm, 0, 0), GetLogicalSize(wm)); nsMargin borderPadding; GetXULBorderAndPadding(borderPadding); textRect.Deflate(wm, LogicalMargin(wm, borderPadding)); // determine (cropped) title and underline position // determine (cropped) title which fits in aRect, and its width // (where "width" is the text measure along its baseline, i.e. actually // a physical height in vertical writing modes) nscoord titleWidth = CalculateTitleForWidth(aRenderingContext, textRect.ISize(wm)); #ifdef ACCESSIBILITY // Make sure to update the accessible tree in case when cropped title is // changed. nsAccessibilityService* accService = GetAccService(); if (accService) { accService->UpdateLabelValue(PresContext()->PresShell(), mContent, mCroppedTitle); } #endif // determine if and at which position to put the underline UpdateAccessIndex(); // make the rect as small as our (cropped) text. nscoord outerISize = textRect.ISize(wm); textRect.ISize(wm) = titleWidth; // Align our text within the overall rect by checking our text-align property. const nsStyleText* textStyle = StyleText(); if (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_CENTER) { textRect.IStart(wm) += (outerISize - textRect.ISize(wm)) / 2; } else if (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_END || (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_LEFT && !wm.IsBidiLTR()) || (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_RIGHT && wm.IsBidiLTR())) { textRect.IStart(wm) += (outerISize - textRect.ISize(wm)); } mTextDrawRect = textRect.GetPhysicalRect(wm, GetSize()); } /** * Ok return our dimensions */ nsSize nsTextBoxFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) { CalcTextSize(aBoxLayoutState); nsSize size = mTextSize; DISPLAY_PREF_SIZE(this, size); AddBorderAndPadding(size); bool widthSet, heightSet; nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet); return size; } /** * Ok return our dimensions */ nsSize nsTextBoxFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) { CalcTextSize(aBoxLayoutState); nsSize size = mTextSize; DISPLAY_MIN_SIZE(this, size); // if there is cropping our min width becomes our border and padding if (mCropType != CropNone && mCropType != CropAuto) { if (GetWritingMode().IsVertical()) { size.height = 0; } else { size.width = 0; } } AddBorderAndPadding(size); bool widthSet, heightSet; nsIFrame::AddXULMinSize(aBoxLayoutState, this, size, widthSet, heightSet); return size; } nscoord nsTextBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) { CalcTextSize(aBoxLayoutState); nscoord ascent = mAscent; nsMargin m(0,0,0,0); GetXULBorderAndPadding(m); WritingMode wm = GetWritingMode(); ascent += LogicalMargin(wm, m).BStart(wm); return ascent; } #ifdef DEBUG_FRAME_DUMP nsresult nsTextBoxFrame::GetFrameName(nsAString& aResult) const { MakeFrameName(NS_LITERAL_STRING("TextBox"), aResult); aResult += NS_LITERAL_STRING("[value=") + mTitle + NS_LITERAL_STRING("]"); return NS_OK; } #endif // If you make changes to this function, check its counterparts // in nsBoxFrame and nsXULLabelFrame nsresult nsTextBoxFrame::RegUnregAccessKey(bool aDoReg) { // if we have no content, we can't do anything if (!mContent) return NS_ERROR_FAILURE; // check if we have a |control| attribute // do this check first because few elements have control attributes, and we // can weed out most of the elements quickly. // XXXjag a side-effect is that we filter out anonymous <label>s // in e.g. <menu>, <menuitem>, <button>. These <label>s inherit // |accesskey| and would otherwise register themselves, overwriting // the content we really meant to be registered. if (!mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::control)) return NS_OK; // see if we even have an access key nsAutoString accessKey; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey); if (accessKey.IsEmpty()) return NS_OK; // With a valid PresContext we can get the ESM // and (un)register the access key EventStateManager* esm = PresContext()->EventStateManager(); uint32_t key = accessKey.First(); if (aDoReg) esm->RegisterAccessKey(mContent, key); else esm->UnregisterAccessKey(mContent, key); return NS_OK; }