зеркало из https://github.com/mozilla/gecko-dev.git
1147 строки
37 KiB
C++
1147 строки
37 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:set ts=4 sw=2 sts=2 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/Attributes.h"
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/layers/RenderRootStateManager.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsPresContext.h"
|
|
#include "gfxContext.h"
|
|
#include "nsIContent.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsBoxLayoutState.h"
|
|
#include "nsMenuBarListener.h"
|
|
#include "nsString.h"
|
|
#include "nsITheme.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsIReflowCallback.h"
|
|
#include "nsBoxFrame.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsUnicodeProperties.h"
|
|
#include "TextDrawTarget.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(PresShell* aPresShell, ComputedStyle* aStyle) {
|
|
return new (aPresShell) nsTextBoxFrame(aStyle, aPresShell->GetPresContext());
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsTextBoxFrame)
|
|
|
|
NS_QUERYFRAME_HEAD(nsTextBoxFrame)
|
|
NS_QUERYFRAME_ENTRY(nsTextBoxFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame)
|
|
|
|
nsresult nsTextBoxFrame::AttributeChanged(int32_t aNameSpaceID,
|
|
nsAtom* aAttribute,
|
|
int32_t aModType) {
|
|
bool aResize;
|
|
bool aRedraw;
|
|
|
|
UpdateAttributes(aAttribute, aResize, aRedraw);
|
|
|
|
if (aResize) {
|
|
PresShell()->FrameNeedsReflow(this, IntrinsicDirty::StyleChange,
|
|
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(ComputedStyle* aStyle,
|
|
nsPresContext* aPresContext)
|
|
: nsLeafBoxFrame(aStyle, aPresContext, kClassID),
|
|
mAccessKeyInfo(nullptr),
|
|
mCropType(CropRight),
|
|
mAscent(0),
|
|
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,
|
|
PostDestroyData& aPostDestroyData) {
|
|
// unregister access key
|
|
RegUnregAccessKey(false);
|
|
nsLeafBoxFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
|
|
}
|
|
|
|
bool nsTextBoxFrame::AlwaysAppendAccessKey() {
|
|
if (!gAccessKeyPrefInitialized) {
|
|
gAccessKeyPrefInitialized = true;
|
|
|
|
const char* prefName = "intl.menuitems.alwaysappendaccesskeys";
|
|
nsAutoString val;
|
|
Preferences::GetLocalizedString(prefName, val);
|
|
gAlwaysAppendAccessKey = val.EqualsLiteral("true");
|
|
}
|
|
return gAlwaysAppendAccessKey;
|
|
}
|
|
|
|
bool nsTextBoxFrame::InsertSeparatorBeforeAccessKey() {
|
|
if (!gInsertSeparatorPrefInitialized) {
|
|
gInsertSeparatorPrefInitialized = true;
|
|
|
|
const char* prefName = "intl.menuitems.insertseparatorbeforeaccesskeys";
|
|
nsAutoString val;
|
|
Preferences::GetLocalizedString(prefName, val);
|
|
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; }
|
|
|
|
WeakFrame mWeakFrame;
|
|
};
|
|
|
|
bool nsTextBoxFrame::UpdateAccesskey(WeakFrame& aWeakThis) {
|
|
nsAutoString accesskey;
|
|
mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey,
|
|
accesskey);
|
|
|
|
if (!accesskey.Equals(mAccessKey)) {
|
|
// Need to get clean mTitle.
|
|
RecomputeTitle();
|
|
mAccessKey = accesskey;
|
|
UpdateAccessTitle();
|
|
PresShell()->FrameNeedsReflow(this, IntrinsicDirty::StyleChange,
|
|
NS_FRAME_IS_DIRTY);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void nsTextBoxFrame::UpdateAttributes(nsAtom* aAttribute, bool& aResize,
|
|
bool& aRedraw) {
|
|
bool doUpdateTitle = false;
|
|
aResize = false;
|
|
aRedraw = false;
|
|
|
|
if (aAttribute == nullptr || aAttribute == nsGkAtoms::crop) {
|
|
static dom::Element::AttrValuesArray strings[] = {
|
|
nsGkAtoms::left, nsGkAtoms::start, nsGkAtoms::center,
|
|
nsGkAtoms::right, nsGkAtoms::end, nsGkAtoms::none,
|
|
nullptr};
|
|
CroppingStyle cropType;
|
|
switch (mContent->AsElement()->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 final : public nsPaintedDisplayItem {
|
|
public:
|
|
nsDisplayXULTextBox(nsDisplayListBuilder* aBuilder, nsTextBoxFrame* aFrame)
|
|
: nsPaintedDisplayItem(aBuilder, aFrame) {
|
|
MOZ_COUNT_CTOR(nsDisplayXULTextBox);
|
|
}
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayXULTextBox)
|
|
#endif
|
|
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
|
|
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
|
|
bool* aSnap) const override;
|
|
NS_DISPLAY_DECL_NAME("XULTextBox", TYPE_XUL_TEXT_BOX)
|
|
|
|
virtual nsRect GetComponentAlphaBounds(
|
|
nsDisplayListBuilder* aBuilder) const override;
|
|
|
|
void PaintTextToContext(gfxContext* aCtx, nsPoint aOffset,
|
|
const nscolor* aColor);
|
|
|
|
virtual bool CreateWebRenderCommands(
|
|
mozilla::wr::DisplayListBuilder& aBuilder,
|
|
mozilla::wr::IpcResourceUpdateQueue& aResources,
|
|
const StackingContextHelper& aSc,
|
|
mozilla::layers::RenderRootStateManager* aManager,
|
|
nsDisplayListBuilder* aDisplayListBuilder) override;
|
|
};
|
|
|
|
static void PaintTextShadowCallback(gfxContext* aCtx, nsPoint aShadowOffset,
|
|
const nscolor& aShadowColor, void* aData) {
|
|
reinterpret_cast<nsDisplayXULTextBox*>(aData)->PaintTextToContext(
|
|
aCtx, aShadowOffset, &aShadowColor);
|
|
}
|
|
|
|
void nsDisplayXULTextBox::Paint(nsDisplayListBuilder* aBuilder,
|
|
gfxContext* aCtx) {
|
|
DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
|
|
IsSubpixelAADisabled());
|
|
|
|
// Paint the text shadow before doing any foreground stuff
|
|
nsRect drawRect =
|
|
static_cast<nsTextBoxFrame*>(mFrame)->mTextDrawRect + ToReferenceFrame();
|
|
nsLayoutUtils::PaintTextShadow(mFrame, aCtx, drawRect, GetPaintRect(),
|
|
mFrame->StyleText()->mColor.ToColor(),
|
|
PaintTextShadowCallback, (void*)this);
|
|
|
|
PaintTextToContext(aCtx, nsPoint(0, 0), nullptr);
|
|
}
|
|
|
|
void nsDisplayXULTextBox::PaintTextToContext(gfxContext* aCtx, nsPoint aOffset,
|
|
const nscolor* aColor) {
|
|
static_cast<nsTextBoxFrame*>(mFrame)->PaintTitle(
|
|
*aCtx, GetPaintRect(), ToReferenceFrame() + aOffset, aColor);
|
|
}
|
|
|
|
bool nsDisplayXULTextBox::CreateWebRenderCommands(
|
|
mozilla::wr::DisplayListBuilder& aBuilder,
|
|
mozilla::wr::IpcResourceUpdateQueue& aResources,
|
|
const StackingContextHelper& aSc,
|
|
mozilla::layers::RenderRootStateManager* aManager,
|
|
nsDisplayListBuilder* aDisplayListBuilder) {
|
|
bool snap = false;
|
|
auto bounds = GetBounds(aDisplayListBuilder, &snap);
|
|
|
|
if (bounds.IsEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
auto appUnitsPerDevPixel = Frame()->PresContext()->AppUnitsPerDevPixel();
|
|
gfx::Point deviceOffset =
|
|
LayoutDevicePoint::FromAppUnits(bounds.TopLeft(), appUnitsPerDevPixel)
|
|
.ToUnknownPoint();
|
|
|
|
RefPtr<mozilla::layout::TextDrawTarget> textDrawer =
|
|
new mozilla::layout::TextDrawTarget(aBuilder, aResources, aSc, aManager,
|
|
this, bounds);
|
|
RefPtr<gfxContext> captureCtx =
|
|
gfxContext::CreateOrNull(textDrawer, deviceOffset);
|
|
|
|
Paint(aDisplayListBuilder, captureCtx);
|
|
textDrawer->TerminateShadows();
|
|
|
|
return textDrawer->Finish();
|
|
}
|
|
|
|
nsRect nsDisplayXULTextBox::GetBounds(nsDisplayListBuilder* aBuilder,
|
|
bool* aSnap) const {
|
|
*aSnap = false;
|
|
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
|
|
}
|
|
|
|
nsRect nsDisplayXULTextBox::GetComponentAlphaBounds(
|
|
nsDisplayListBuilder* aBuilder) const {
|
|
return static_cast<nsTextBoxFrame*>(mFrame)->GetComponentAlphaBounds() +
|
|
ToReferenceFrame();
|
|
}
|
|
|
|
void nsTextBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) {
|
|
if (!IsVisibleForPainting()) return;
|
|
|
|
nsLeafBoxFrame::BuildDisplayList(aBuilder, aLists);
|
|
|
|
aLists.Content()->AppendNewToTop<nsDisplayXULTextBox>(aBuilder, this);
|
|
}
|
|
|
|
void nsTextBoxFrame::PaintTitle(gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect, nsPoint aPt,
|
|
const nscolor* aOverrideColor) {
|
|
if (mTitle.IsEmpty()) return;
|
|
|
|
DrawText(aRenderingContext, aDirtyRect, mTextDrawRect + aPt, aOverrideColor);
|
|
}
|
|
|
|
void nsTextBoxFrame::DrawText(gfxContext& 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
|
|
auto decorations = StyleTextDecorationLine::NONE;
|
|
// A mask of all possible line decorations.
|
|
auto decorMask = StyleTextDecorationLine::UNDERLINE |
|
|
StyleTextDecorationLine::OVERLINE |
|
|
StyleTextDecorationLine::LINE_THROUGH;
|
|
|
|
WritingMode wm = GetWritingMode();
|
|
bool vertical = wm.IsVertical();
|
|
|
|
nsIFrame* f = this;
|
|
do { // find decoration colors
|
|
ComputedStyle* context = f->Style();
|
|
if (!context->HasTextDecorationLines()) {
|
|
break;
|
|
}
|
|
const nsStyleTextReset* styleText = context->StyleTextReset();
|
|
|
|
// a decoration defined here
|
|
if (decorMask & styleText->mTextDecorationLine) {
|
|
nscolor color;
|
|
if (aOverrideColor) {
|
|
color = *aOverrideColor;
|
|
} else {
|
|
color = styleText->mTextDecorationColor.CalcColor(*context);
|
|
}
|
|
uint8_t style = styleText->mTextDecorationStyle;
|
|
|
|
if (StyleTextDecorationLine::UNDERLINE & decorMask &
|
|
styleText->mTextDecorationLine) {
|
|
underColor = color;
|
|
underStyle = style;
|
|
decorMask &= ~StyleTextDecorationLine::UNDERLINE;
|
|
decorations |= StyleTextDecorationLine::UNDERLINE;
|
|
}
|
|
if (StyleTextDecorationLine::OVERLINE & decorMask &
|
|
styleText->mTextDecorationLine) {
|
|
overColor = color;
|
|
overStyle = style;
|
|
decorMask &= ~StyleTextDecorationLine::OVERLINE;
|
|
decorations |= StyleTextDecorationLine::OVERLINE;
|
|
}
|
|
if (StyleTextDecorationLine::LINE_THROUGH & decorMask &
|
|
styleText->mTextDecorationLine) {
|
|
strikeColor = color;
|
|
strikeStyle = style;
|
|
decorMask &= ~StyleTextDecorationLine::LINE_THROUGH;
|
|
decorations |= StyleTextDecorationLine::LINE_THROUGH;
|
|
}
|
|
}
|
|
} while (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 & (StyleTextDecorationLine::OVERLINE |
|
|
StyleTextDecorationLine::UNDERLINE)) {
|
|
fontMet->GetUnderline(offset, size);
|
|
params.lineSize.height = presContext->AppUnitsToGfxUnits(size);
|
|
if ((decorations & StyleTextDecorationLine::UNDERLINE) &&
|
|
underStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
|
|
params.color = underColor;
|
|
params.offset = presContext->AppUnitsToGfxUnits(offset);
|
|
params.decoration = StyleTextDecorationLine::UNDERLINE;
|
|
params.style = underStyle;
|
|
nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
|
|
}
|
|
if ((decorations & StyleTextDecorationLine::OVERLINE) &&
|
|
overStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
|
|
params.color = overColor;
|
|
params.offset = params.ascent;
|
|
params.decoration = StyleTextDecorationLine::OVERLINE;
|
|
params.style = overStyle;
|
|
nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
|
|
}
|
|
}
|
|
|
|
RefPtr<gfxContext> refContext =
|
|
PresShell()->CreateReferenceRenderingContext();
|
|
DrawTarget* refDrawTarget = refContext->GetDrawTarget();
|
|
|
|
CalculateUnderline(refDrawTarget, *fontMet);
|
|
|
|
DeviceColor color = ToDeviceColor(
|
|
aOverrideColor ? *aOverrideColor : StyleText()->mColor.ToColor());
|
|
ColorPattern colorPattern(color);
|
|
aRenderingContext.SetDeviceColor(color);
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
if (mState & NS_FRAME_IS_BIDI) {
|
|
presContext->SetBidiEnabled();
|
|
nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(Style());
|
|
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, colorPattern);
|
|
}
|
|
|
|
// 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 & StyleTextDecorationLine::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 = StyleTextDecorationLine::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(gfxContext& 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 == StyleDirection::Rtl) {
|
|
AddStateBits(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 (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
|
|
AddStateBits(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 (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
|
|
AddStateBits(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 (UTF16_CODE_UNIT_IS_BIDI(*leftPos)) {
|
|
AddStateBits(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 (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
|
|
AddStateBits(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/components/prompts/src/CommonDialog.jsm (setLabelForNode)
|
|
* toolkit/content/widgets/text.js (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;
|
|
}
|
|
|
|
if (StringEndsWith(mTitle, accessKeyLabel)) {
|
|
// Never append another "(X)" if the title already ends with "(X)".
|
|
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->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, mTitle);
|
|
|
|
// This doesn't handle language-specific uppercasing/lowercasing
|
|
// rules, unlike textruns.
|
|
StyleTextTransform textTransform = StyleText()->mTextTransform;
|
|
if (textTransform.case_ == StyleTextTransformCase::Uppercase) {
|
|
ToUpperCase(mTitle);
|
|
} else if (textTransform.case_ == StyleTextTransformCase::Lowercase) {
|
|
ToLowerCase(mTitle);
|
|
}
|
|
// We can't handle StyleTextTransformCase::Capitalize because we
|
|
// have no clue about word boundaries here. We also don't handle
|
|
// the full-width or full-size-kana transforms.
|
|
}
|
|
|
|
void nsTextBoxFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
|
|
nsLeafBoxFrame::DidSetComputedStyle(aOldComputedStyle);
|
|
|
|
if (!aOldComputedStyle) {
|
|
// We're just being initialized
|
|
return;
|
|
}
|
|
|
|
const nsStyleText* oldTextStyle = aOldComputedStyle->StyleText();
|
|
if (oldTextStyle->mTextTransform != StyleText()->mTextTransform) {
|
|
RecomputeTitle();
|
|
UpdateAccessTitle();
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsTextBoxFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState) {
|
|
if (mNeedsReflowCallback) {
|
|
nsIReflowCallback* cb = new nsAsyncAccesskeyUpdate(this);
|
|
if (cb) {
|
|
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->HasTextShadow()) {
|
|
// 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() const {
|
|
if (StyleText()->HasTextShadow()) {
|
|
return GetVisualOverflowRectRelativeToSelf();
|
|
}
|
|
return mTextDrawRect;
|
|
}
|
|
|
|
bool nsTextBoxFrame::XULComputesOwnOverflowArea() { return true; }
|
|
|
|
/* virtual */
|
|
void nsTextBoxFrame::MarkIntrinsicISizesDirty() {
|
|
mNeedsRecalc = true;
|
|
nsLeafBoxFrame::MarkIntrinsicISizesDirty();
|
|
}
|
|
|
|
void nsTextBoxFrame::GetTextSize(gfxContext& 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;
|
|
gfxContext* rendContext = aBoxLayoutState.GetRenderingContext();
|
|
if (rendContext) {
|
|
GetTextSize(*rendContext, mTitle, size, mAscent);
|
|
if (GetWritingMode().IsVertical()) {
|
|
std::swap(size.width, size.height);
|
|
}
|
|
mTextSize = size;
|
|
mNeedsRecalc = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsTextBoxFrame::CalcDrawRect(gfxContext& 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(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 == StyleTextAlign::Center) {
|
|
textRect.IStart(wm) += (outerISize - textRect.ISize(wm)) / 2;
|
|
} else if (textStyle->mTextAlign == StyleTextAlign::End ||
|
|
(textStyle->mTextAlign == StyleTextAlign::Left &&
|
|
wm.IsBidiRTL()) ||
|
|
(textStyle->mTextAlign == StyleTextAlign::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);
|
|
|
|
AddXULBorderAndPadding(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;
|
|
}
|
|
}
|
|
|
|
AddXULBorderAndPadding(size);
|
|
bool widthSet, heightSet;
|
|
nsIFrame::AddXULMinSize(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->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::control))
|
|
return NS_OK;
|
|
|
|
// see if we even have an access key
|
|
nsAutoString accessKey;
|
|
mContent->AsElement()->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->AsElement(), key);
|
|
else
|
|
esm->UnregisterAccessKey(mContent->AsElement(), key);
|
|
|
|
return NS_OK;
|
|
}
|