void
EventTarget::DispatchEvent(Event& aEvent, ErrorResult& aRv)
{
// The caller type doesn't really matter if we don't care about the
// return value, but let's be safe and pass NonSystem.
Unused << DispatchEvent(aEvent, CallerType::NonSystem, IgnoreErrors());
}
void DataTransferItemList::GenerateFiles(FileList* aFiles,
nsIPrincipal* aFilesPrincipal) {
MOZ_ASSERT(aFiles);
MOZ_ASSERT(aFilesPrincipal);
// For non-system principals, the Files list should be empty if the
// DataTransfer is protected.
if (!nsContentUtils::IsSystemPrincipal(aFilesPrincipal) &&
mDataTransfer->IsProtected()) {
return;
}
uint32_t count = Length();
for (uint32_t i = 0; i < count; i++) {
bool found;
RefPtr<DataTransferItem> item = IndexedGetter(i, found);
MOZ_ASSERT(found);
if (item->Kind() == DataTransferItem::KIND_FILE) {
RefPtr<File> file = item->GetAsFile(*aFilesPrincipal, IgnoreErrors());
if (NS_WARN_IF(!file)) {
continue;
}
aFiles->Append(file);
}
}
}
nsresult HTMLTextAreaElement::Reset() {
nsAutoString resetVal;
GetDefaultValue(resetVal, IgnoreErrors());
SetValueChanged(false);
nsresult rv =
SetValueInternal(resetVal, nsTextEditorState::eSetValue_Internal);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
void HTMLMarqueeElement::DispatchEventToShadowRoot(
const nsAString& aEventTypeArg) {
// Dispatch the event to the UA Widget Shadow Root, make it inaccessible to
// document.
RefPtr<nsINode> shadow = GetShadowRoot();
MOZ_ASSERT(shadow);
RefPtr<Event> event = new Event(shadow, nullptr, nullptr);
event->InitEvent(aEventTypeArg, false, false);
event->SetTrusted(true);
shadow->DispatchEvent(*event, IgnoreErrors());
}
NS_IMETHODIMP
CompositionTransaction::DoTransaction() {
if (NS_WARN_IF(!mEditorBase)) {
return NS_ERROR_NOT_INITIALIZED;
}
// Fail before making any changes if there's no selection controller
nsCOMPtr<nsISelectionController> selCon;
mEditorBase->GetSelectionController(getter_AddRefs(selCon));
NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
// Advance caret: This requires the presentation shell to get the selection.
if (mReplaceLength == 0) {
ErrorResult rv;
mTextNode->InsertData(mOffset, mStringToInsert, rv);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
mEditorBase->RangeUpdaterRef().SelAdjInsertText(*mTextNode, mOffset,
mStringToInsert);
} else {
uint32_t replaceableLength = mTextNode->TextLength() - mOffset;
ErrorResult rv;
mTextNode->ReplaceData(mOffset, mReplaceLength, mStringToInsert, rv);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
mEditorBase->RangeUpdaterRef().SelAdjDeleteText(mTextNode, mOffset,
mReplaceLength);
mEditorBase->RangeUpdaterRef().SelAdjInsertText(*mTextNode, mOffset,
mStringToInsert);
// If IME text node is multiple node, ReplaceData doesn't remove all IME
// text. So we need remove remained text into other text node.
if (replaceableLength < mReplaceLength) {
int32_t remainLength = mReplaceLength - replaceableLength;
nsCOMPtr<nsINode> node = mTextNode->GetNextSibling();
while (node && node->IsText() && remainLength > 0) {
Text* text = static_cast<Text*>(node.get());
uint32_t textLength = text->TextLength();
text->DeleteData(0, remainLength, IgnoreErrors());
mEditorBase->RangeUpdaterRef().SelAdjDeleteText(text, 0, remainLength);
remainLength -= textLength;
node = node->GetNextSibling();
}
}
}
nsresult rv = SetSelectionForRanges();
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
void HeeksDxfRead::OnReadSpline(TColgp_Array1OfPnt &control, TColStd_Array1OfReal &weight, TColStd_Array1OfReal &knot,TColStd_Array1OfInteger &mult, int degree, bool periodic, bool rational)
{
try{
Geom_BSplineCurve spline(control,weight,knot,mult,degree,periodic,rational);
HSpline* new_object = new HSpline(spline, ActiveColorPtr(m_aci));
AddObject(new_object);
}
catch(Standard_Failure)
{
if (! IgnoreErrors()) throw; // Re-throw the exception.
}
}
nsresult
VideoDocument::CreateSyntheticVideoDocument()
{
// make our generic document
nsresult rv = MediaDocument::CreateSyntheticDocument();
NS_ENSURE_SUCCESS(rv, rv);
Element* body = GetBodyElement();
if (!body) {
NS_WARNING("no body on video document!");
return NS_ERROR_FAILURE;
}
// make content
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::video, nullptr,
kNameSpaceID_XHTML,
nsINode::ELEMENT_NODE);
RefPtr<HTMLMediaElement> element =
static_cast<HTMLMediaElement*>(NS_NewHTMLVideoElement(nodeInfo.forget(),
NOT_FROM_PARSER));
if (!element)
return NS_ERROR_OUT_OF_MEMORY;
element->SetAutoplay(true, IgnoreErrors());
element->SetControls(true, IgnoreErrors());
element->LoadWithChannel(mChannel,
getter_AddRefs(mStreamListener->mNextStream));
UpdateTitle(mChannel);
if (nsContentUtils::IsChildOfSameType(this)) {
// Video documents that aren't toplevel should fill their frames and
// not have margins
element->SetAttr(kNameSpaceID_None, nsGkAtoms::style,
NS_LITERAL_STRING("position:absolute; top:0; left:0; width:100%; height:100%"),
true);
}
return body->AppendChildTo(element, false);
}
nsresult FilteredContentIterator::Init(nsINode* aRoot) {
NS_ENSURE_ARG_POINTER(aRoot);
mIsOutOfRange = false;
mDirection = eForward;
mCurrentIterator = &mPreIterator;
mRange = new nsRange(aRoot);
mRange->SelectNode(*aRoot, IgnoreErrors());
nsresult rv = mPreIterator.Init(mRange);
NS_ENSURE_SUCCESS(rv, rv);
return mPostIterator.Init(mRange);
}
void JSWindowActor::QueryHandler::SendReply(JSContext* aCx,
JSWindowActorMessageKind aKind,
ipc::StructuredCloneData&& aData) {
MOZ_ASSERT(mActor);
JSWindowActorMessageMeta meta;
meta.actorName() = mActor->Name();
meta.messageName() = mMessageName;
meta.queryId() = mQueryId;
meta.kind() = aKind;
mActor->SendRawMessage(meta, std::move(aData), IgnoreErrors());
mActor = nullptr;
}
bool HTMLTextAreaElement::RestoreState(PresState* aState) {
const PresContentData& state = aState->contentData();
if (state.type() == PresContentData::TnsString) {
ErrorResult rv;
SetValue(state.get_nsString(), rv);
ENSURE_SUCCESS(rv, false);
}
if (aState->disabledSet() && !aState->disabled()) {
SetDisabled(false, IgnoreErrors());
}
return false;
}
DOMSVGLength* DOMSVGLength::Copy() {
NS_ASSERTION(HasOwner() || IsReflectingAttribute(), "unexpected caller");
DOMSVGLength* copy = new DOMSVGLength();
uint16_t unit;
float value;
if (mVal) {
unit = mVal->mSpecifiedUnitType;
value = mIsAnimValItem ? mVal->mAnimVal : mVal->mBaseVal;
} else {
SVGLength& length = InternalItem();
unit = length.GetUnit();
value = length.GetValueInCurrentUnits();
}
copy->NewValueSpecifiedUnits(unit, value, IgnoreErrors());
return copy;
}
nsresult XULTooltipElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) {
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::label) {
// When the label attribute of this node changes propagate the text down
// into child description element.
nsCOMPtr<nsIContent> description = GetFirstChild();
if (description && description->IsXULElement(nsGkAtoms::description)) {
nsAutoString value;
if (aValue) {
aValue->ToString(value);
}
nsContentUtils::AddScriptRunner(NS_NewRunnableFunction(
"XULTooltipElement::AfterSetAttr", [description, value]() {
Element* descriptionElement = description->AsElement();
descriptionElement->SetTextContent(value, IgnoreErrors());
}));
}
}
return nsXULElement::AfterSetAttr(aNameSpaceID, aName, aValue, aOldValue,
aSubjectPrincipal, aNotify);
}
// static
nsresult CompositionTransaction::SetIMESelection(
EditorBase& aEditorBase, Text* aTextNode, uint32_t aOffsetInNode,
uint32_t aLengthOfCompositionString, const TextRangeArray* aRanges) {
RefPtr<Selection> selection = aEditorBase.GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
SelectionBatcher selectionBatcher(selection);
// First, remove all selections of IME composition.
static const RawSelectionType kIMESelections[] = {
nsISelectionController::SELECTION_IME_RAWINPUT,
nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT,
nsISelectionController::SELECTION_IME_CONVERTEDTEXT,
nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT};
nsCOMPtr<nsISelectionController> selCon;
aEditorBase.GetSelectionController(getter_AddRefs(selCon));
NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
nsresult rv = NS_OK;
for (uint32_t i = 0; i < ArrayLength(kIMESelections); ++i) {
RefPtr<Selection> selectionOfIME = selCon->GetSelection(kIMESelections[i]);
if (!selectionOfIME) {
continue;
}
selectionOfIME->RemoveAllRanges(IgnoreErrors());
}
// Set caret position and selection of IME composition with TextRangeArray.
bool setCaret = false;
uint32_t countOfRanges = aRanges ? aRanges->Length() : 0;
#ifdef DEBUG
// Bounds-checking on debug builds
uint32_t maxOffset = aTextNode->Length();
#endif
// NOTE: composition string may be truncated when it's committed and
// maxlength attribute value doesn't allow input of all text of this
// composition.
for (uint32_t i = 0; i < countOfRanges; ++i) {
const TextRange& textRange = aRanges->ElementAt(i);
// Caret needs special handling since its length may be 0 and if it's not
// specified explicitly, we need to handle it ourselves later.
if (textRange.mRangeType == TextRangeType::eCaret) {
NS_ASSERTION(!setCaret, "The ranges already has caret position");
NS_ASSERTION(!textRange.Length(),
"EditorBase doesn't support wide caret");
int32_t caretOffset = static_cast<int32_t>(
aOffsetInNode +
std::min(textRange.mStartOffset, aLengthOfCompositionString));
MOZ_ASSERT(caretOffset >= 0 &&
static_cast<uint32_t>(caretOffset) <= maxOffset);
rv = selection->Collapse(aTextNode, caretOffset);
setCaret = setCaret || NS_SUCCEEDED(rv);
if (NS_WARN_IF(!setCaret)) {
continue;
}
// If caret range is specified explicitly, we should show the caret if
// it should be so.
aEditorBase.HideCaret(false);
continue;
}
// If the clause length is 0, it should be a bug.
if (!textRange.Length()) {
NS_WARNING("Any clauses must not be empty");
continue;
}
RefPtr<nsRange> clauseRange;
int32_t startOffset = static_cast<int32_t>(
aOffsetInNode +
std::min(textRange.mStartOffset, aLengthOfCompositionString));
MOZ_ASSERT(startOffset >= 0 &&
static_cast<uint32_t>(startOffset) <= maxOffset);
int32_t endOffset = static_cast<int32_t>(
aOffsetInNode +
std::min(textRange.mEndOffset, aLengthOfCompositionString));
MOZ_ASSERT(endOffset >= startOffset &&
static_cast<uint32_t>(endOffset) <= maxOffset);
rv = nsRange::CreateRange(aTextNode, startOffset, aTextNode, endOffset,
getter_AddRefs(clauseRange));
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create a DOM range for a clause of composition");
break;
}
// Set the range of the clause to selection.
RefPtr<Selection> selectionOfIME =
selCon->GetSelection(ToRawSelectionType(textRange.mRangeType));
if (!selectionOfIME) {
NS_WARNING("Failed to get IME selection");
break;
}
IgnoredErrorResult err;
selectionOfIME->AddRange(*clauseRange, err);
if (err.Failed()) {
NS_WARNING("Failed to add selection range for a clause of composition");
break;
}
// Set the style of the clause.
rv = selectionOfIME->SetTextRangeStyle(clauseRange, textRange.mRangeStyle);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to set selection style");
break; // but this is unexpected...
}
}
// If the ranges doesn't include explicit caret position, let's set the
// caret to the end of composition string.
if (!setCaret) {
int32_t caretOffset =
static_cast<int32_t>(aOffsetInNode + aLengthOfCompositionString);
MOZ_ASSERT(caretOffset >= 0 &&
static_cast<uint32_t>(caretOffset) <= maxOffset);
rv = selection->Collapse(aTextNode, caretOffset);
NS_ASSERTION(NS_SUCCEEDED(rv),
"Failed to set caret at the end of composition string");
// If caret range isn't specified explicitly, we should hide the caret.
// Hiding the caret benefits a Windows build (see bug 555642 comment #6).
// However, when there is no range, we should keep showing caret.
if (countOfRanges) {
aEditorBase.HideCaret(true);
}
}
return rv;
}
HTMLTextAreaElement::GetDefaultValueFromContent(nsAString& aValue) {
GetDefaultValue(aValue, IgnoreErrors());
}