--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -563,17 +563,17 @@ HTMLEditRules::WillDoAction(Selection* a
bool* aHandled)
{
MOZ_ASSERT(aInfo && aCancel && aHandled);
*aCancel = false;
*aHandled = false;
// my kingdom for dynamic cast
- nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
+ TextRulesInfo* info = static_cast<TextRulesInfo*>(aInfo);
// Deal with actions for which we don't need to check whether the selection is
// editable.
if (info->action == EditAction::outputText ||
info->action == EditAction::undo ||
info->action == EditAction::redo) {
return TextEditRules::WillDoAction(aSelection, aInfo, aCancel, aHandled);
}
@@ -657,17 +657,17 @@ HTMLEditRules::WillDoAction(Selection* a
}
}
NS_IMETHODIMP
HTMLEditRules::DidDoAction(Selection* aSelection,
nsRulesInfo* aInfo,
nsresult aResult)
{
- nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
+ TextRulesInfo* info = static_cast<TextRulesInfo*>(aInfo);
switch (info->action)
{
case EditAction::insertBreak:
return DidInsertBreak(aSelection, aResult);
case EditAction::deleteSelection:
return DidDeleteSelection(aSelection, info->collapsedAction, aResult);
case EditAction::makeBasicBlock:
case EditAction::indent:
--- a/editor/libeditor/TextEditRules.cpp
+++ b/editor/libeditor/TextEditRules.cpp
@@ -246,17 +246,17 @@ TextEditRules::WillDoAction(Selection* a
{
// null selection is legal
MOZ_ASSERT(aInfo && aCancel && aHandled);
*aCancel = false;
*aHandled = false;
// my kingdom for dynamic cast
- nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
+ TextRulesInfo* info = static_cast<TextRulesInfo*>(aInfo);
switch (info->action) {
case EditAction::insertBreak:
UndefineCaretBidiLevel(aSelection);
return WillInsertBreak(aSelection, aCancel, aHandled, info->maxLength);
case EditAction::insertText:
case EditAction::insertIMEText:
UndefineCaretBidiLevel(aSelection);
@@ -294,17 +294,17 @@ TextEditRules::DidDoAction(Selection* aS
NS_ENSURE_STATE(mEditor);
// don't let any txns in here move the selection around behind our back.
// Note that this won't prevent explicit selection setting from working.
AutoTransactionsConserveSelection dontSpazMySelection(mEditor);
NS_ENSURE_TRUE(aSelection && aInfo, NS_ERROR_NULL_POINTER);
// my kingdom for dynamic cast
- nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
+ TextRulesInfo* info = static_cast<TextRulesInfo*>(aInfo);
switch (info->action)
{
case EditAction::insertBreak:
return DidInsertBreak(aSelection, aResult);
case EditAction::insertText:
case EditAction::insertIMEText:
return DidInsertText(aSelection, aResult);
--- a/editor/libeditor/TextEditRules.h
+++ b/editor/libeditor/TextEditRules.h
@@ -248,65 +248,61 @@ protected:
nsCOMPtr<nsITimer> mTimer;
uint32_t mLastStart;
uint32_t mLastLength;
// friends
friend class nsAutoLockRulesSniffing;
};
-} // namespace mozilla
-
-class nsTextRulesInfo : public nsRulesInfo
+class TextRulesInfo final : public nsRulesInfo
{
- public:
-
- explicit nsTextRulesInfo(EditAction aAction) :
- nsRulesInfo(aAction),
- inString(0),
- outString(0),
- outputFormat(0),
- maxLength(-1),
- collapsedAction(nsIEditor::eNext),
- stripWrappers(nsIEditor::eStrip),
- bOrdered(false),
- entireList(false),
- bulletType(0),
- alignType(0),
- blockType(0),
- insertElement(0)
- {}
-
- virtual ~nsTextRulesInfo() {}
+public:
+ explicit TextRulesInfo(EditAction aAction)
+ : nsRulesInfo(aAction)
+ , inString(nullptr)
+ , outString(nullptr)
+ , outputFormat(nullptr)
+ , maxLength(-1)
+ , collapsedAction(nsIEditor::eNext)
+ , stripWrappers(nsIEditor::eStrip)
+ , bOrdered(false)
+ , entireList(false)
+ , bulletType(nullptr)
+ , alignType(nullptr)
+ , blockType(nullptr)
+ , insertElement(nullptr)
+ {}
// kInsertText
- const nsAString *inString;
- nsAString *outString;
- const nsAString *outputFormat;
+ const nsAString* inString;
+ nsAString* outString;
+ const nsAString* outputFormat;
int32_t maxLength;
// kDeleteSelection
nsIEditor::EDirection collapsedAction;
nsIEditor::EStripWrappers stripWrappers;
// kMakeList
bool bOrdered;
bool entireList;
- const nsAString *bulletType;
+ const nsAString* bulletType;
// kAlign
- const nsAString *alignType;
+ const nsAString* alignType;
// kMakeBasicBlock
- const nsAString *blockType;
+ const nsAString* blockType;
// kInsertElement
const nsIDOMElement* insertElement;
};
+} // namespace mozilla
/***************************************************************************
* stack based helper class for StartOperation()/EndOperation() sandwich.
* this class sets a bool letting us know to ignore any rules sniffing
* that tries to occur reentrantly.
*/
class nsAutoLockRulesSniffing
{
--- a/editor/libeditor/nsHTMLAbsPosition.cpp
+++ b/editor/libeditor/nsHTMLAbsPosition.cpp
@@ -60,18 +60,18 @@ nsHTMLEditor::AbsolutePositionSelection(
EditAction::removeAbsolutePosition,
nsIEditor::eNext);
// the line below does not match the code; should it be removed?
// Find out if the selection is collapsed:
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(aEnabled ? EditAction::setAbsolutePosition :
- EditAction::removeAbsolutePosition);
+ TextRulesInfo ruleInfo(aEnabled ? EditAction::setAbsolutePosition :
+ EditAction::removeAbsolutePosition);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (NS_FAILED(res) || cancel)
return res;
return mRules->DidDoAction(selection, &ruleInfo, res);
@@ -164,18 +164,18 @@ nsHTMLEditor::RelativeChangeZIndex(int32
(aChange < 0) ? EditAction::decreaseZIndex :
EditAction::increaseZIndex,
nsIEditor::eNext);
// brade: can we get rid of this comment?
// Find out if the selection is collapsed:
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(aChange < 0 ? EditAction::decreaseZIndex :
- EditAction::increaseZIndex);
+ TextRulesInfo ruleInfo(aChange < 0 ? EditAction::decreaseZIndex :
+ EditAction::increaseZIndex);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || NS_FAILED(res))
return res;
return mRules->DidDoAction(selection, &ruleInfo, res);
--- a/editor/libeditor/nsHTMLDataTransfer.cpp
+++ b/editor/libeditor/nsHTMLDataTransfer.cpp
@@ -110,17 +110,17 @@ nsHTMLEditor::LoadHTML(const nsAString &
ForceCompositionEnd();
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::loadHTML, nsIEditor::eNext);
// Get selection
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_STATE(selection);
- nsTextRulesInfo ruleInfo(EditAction::loadHTML);
+ TextRulesInfo ruleInfo(EditAction::loadHTML);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel) {
return NS_OK; // rules canceled the operation
}
@@ -360,17 +360,17 @@ nsHTMLEditor::DoInsertHTMLWithContext(co
rv = DeleteTableCell(1);
NS_ENSURE_SUCCESS(rv, rv);
}
// collapse selection to beginning of deleted table content
selection->CollapseToStart();
}
// give rules a chance to handle or cancel
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
bool cancel, handled;
rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel) {
return NS_OK; // rules canceled the operation
}
if (!handled)
@@ -1659,17 +1659,17 @@ NS_IMETHODIMP nsHTMLEditor::PasteAsCited
AutoRules beginRulesSniffing(this, EditAction::insertQuotation,
nsIEditor::eNext);
// get selection
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
// give rules a chance to handle or cancel
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel || handled) {
return NS_OK; // rules canceled the operation
}
@@ -1848,17 +1848,17 @@ nsHTMLEditor::InsertAsPlaintextQuotation
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::insertQuotation,
nsIEditor::eNext);
// give rules a chance to handle or cancel
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel || handled) {
return NS_OK; // rules canceled the operation
}
@@ -1938,17 +1938,17 @@ nsHTMLEditor::InsertAsCitedQuotation(con
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::insertQuotation,
nsIEditor::eNext);
// give rules a chance to handle or cancel
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
bool cancel, handled;
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel || handled) {
return NS_OK; // rules canceled the operation
}
--- a/editor/libeditor/nsHTMLEditor.cpp
+++ b/editor/libeditor/nsHTMLEditor.cpp
@@ -1499,17 +1499,17 @@ nsHTMLEditor::InsertElementAtSelection(n
RefPtr<Selection> selection = GetSelection();
if (!selection) {
return NS_ERROR_FAILURE;
}
// hand off to the rules system, see if it has anything to say about this
bool cancel, handled;
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
ruleInfo.insertElement = aElement;
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
if (!handled)
{
if (aDeleteSelection)
{
@@ -1936,17 +1936,17 @@ nsHTMLEditor::MakeOrChangeList(const nsA
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::makeList, nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::makeList);
+ TextRulesInfo ruleInfo(EditAction::makeList);
ruleInfo.blockType = &aListType;
ruleInfo.entireList = entireList;
ruleInfo.bulletType = &aBulletType;
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
if (!handled)
{
@@ -2009,17 +2009,17 @@ nsHTMLEditor::RemoveList(const nsAString
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::removeList, nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::removeList);
+ TextRulesInfo ruleInfo(EditAction::removeList);
if (aListType.LowerCaseEqualsLiteral("ol"))
ruleInfo.bOrdered = true;
else ruleInfo.bOrdered = false;
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
// no default behavior for this yet. what would it mean?
@@ -2040,17 +2040,17 @@ nsHTMLEditor::MakeDefinitionItem(const n
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::makeDefListItem,
nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::makeDefListItem);
+ TextRulesInfo ruleInfo(EditAction::makeDefListItem);
ruleInfo.blockType = &aItemType;
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
if (!handled)
{
// todo: no default for now. we count on rules to handle it.
}
@@ -2072,17 +2072,17 @@ nsHTMLEditor::InsertBasicBlock(const nsA
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::makeBasicBlock,
nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::makeBasicBlock);
+ TextRulesInfo ruleInfo(EditAction::makeBasicBlock);
ruleInfo.blockType = &aBlockType;
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
if (!handled)
{
// Find out if the selection is collapsed:
bool isCollapsed = selection->Collapsed();
@@ -2146,17 +2146,17 @@ nsHTMLEditor::Indent(const nsAString& aI
}
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, opID, nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(opID);
+ TextRulesInfo ruleInfo(opID);
res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || (NS_FAILED(res))) return res;
if (!handled)
{
// Do default - insert a blockquote node if selection collapsed
bool isCollapsed = selection->Collapsed();
@@ -2220,17 +2220,17 @@ nsHTMLEditor::Align(const nsAString& aAl
AutoRules beginRulesSniffing(this, EditAction::align, nsIEditor::eNext);
nsCOMPtr<nsIDOMNode> node;
bool cancel, handled;
// Find out if the selection is collapsed:
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::align);
+ TextRulesInfo ruleInfo(EditAction::align);
ruleInfo.alignType = &aAlignType;
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (cancel || NS_FAILED(res))
return res;
res = mRules->DidDoAction(selection, &ruleInfo, res);
return res;
}
@@ -4537,17 +4537,17 @@ nsHTMLEditor::SetCSSBackgroundColor(cons
AutoEditBatch batchIt(this);
AutoRules beginRulesSniffing(this, EditAction::insertElement,
nsIEditor::eNext);
AutoSelectionRestorer selectionRestorer(selection, this);
AutoTransactionsConserveSelection dontSpazMySelection(this);
bool cancel, handled;
- nsTextRulesInfo ruleInfo(EditAction::setTextProperty);
+ TextRulesInfo ruleInfo(EditAction::setTextProperty);
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(res, res);
if (!cancel && !handled) {
// Loop through the ranges in the selection
NS_NAMED_LITERAL_STRING(bgcolor, "bgcolor");
for (uint32_t i = 0; i < selection->RangeCount(); i++) {
RefPtr<nsRange> range = selection->GetRangeAt(i);
NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
--- a/editor/libeditor/nsHTMLEditorStyle.cpp
+++ b/editor/libeditor/nsHTMLEditorStyle.cpp
@@ -125,17 +125,17 @@ nsHTMLEditor::SetInlineProperty(nsIAtom*
AutoEditBatch batchIt(this);
AutoRules beginRulesSniffing(this, EditAction::insertElement,
nsIEditor::eNext);
AutoSelectionRestorer selectionRestorer(selection, this);
AutoTransactionsConserveSelection dontSpazMySelection(this);
bool cancel, handled;
- nsTextRulesInfo ruleInfo(EditAction::setTextProperty);
+ TextRulesInfo ruleInfo(EditAction::setTextProperty);
// Protect the edit rules object from dying
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(res, res);
if (!cancel && !handled) {
// Loop through the ranges in the selection
uint32_t rangeCount = selection->RangeCount();
for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; rangeIdx++) {
RefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
@@ -1213,17 +1213,17 @@ nsHTMLEditor::RemoveInlinePropertyImpl(n
AutoEditBatch batchIt(this);
AutoRules beginRulesSniffing(this, EditAction::removeTextProperty,
nsIEditor::eNext);
AutoSelectionRestorer selectionRestorer(selection, this);
AutoTransactionsConserveSelection dontSpazMySelection(this);
bool cancel, handled;
- nsTextRulesInfo ruleInfo(EditAction::removeTextProperty);
+ TextRulesInfo ruleInfo(EditAction::removeTextProperty);
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(res, res);
if (!cancel && !handled) {
// Loop through the ranges in the selection
uint32_t rangeCount = selection->RangeCount();
for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
--- a/editor/libeditor/nsPlaintextEditor.cpp
+++ b/editor/libeditor/nsPlaintextEditor.cpp
@@ -681,17 +681,17 @@ nsPlaintextEditor::DeleteSelection(EDire
NS_ENSURE_SUCCESS(result, result);
}
else
{
aAction = eNone;
}
}
- nsTextRulesInfo ruleInfo(EditAction::deleteSelection);
+ TextRulesInfo ruleInfo(EditAction::deleteSelection);
ruleInfo.collapsedAction = aAction;
ruleInfo.stripWrappers = aStripWrappers;
bool cancel, handled;
result = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(result, result);
if (!cancel && !handled)
{
result = DeleteSelectionImpl(aAction, aStripWrappers);
@@ -721,17 +721,17 @@ NS_IMETHODIMP nsPlaintextEditor::InsertT
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
nsAutoString resultString;
// XXX can we trust instring to outlive ruleInfo,
// XXX and ruleInfo not to refer to instring in its dtor?
//nsAutoString instring(aStringToInsert);
- nsTextRulesInfo ruleInfo(opID);
+ TextRulesInfo ruleInfo(opID);
ruleInfo.inString = &aStringToInsert;
ruleInfo.outString = &resultString;
ruleInfo.maxLength = mMaxTextLength;
bool cancel, handled;
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(res, res);
if (!cancel && !handled)
@@ -755,17 +755,17 @@ NS_IMETHODIMP nsPlaintextEditor::InsertL
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::insertBreak, nsIEditor::eNext);
// pre-process
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
- nsTextRulesInfo ruleInfo(EditAction::insertBreak);
+ TextRulesInfo ruleInfo(EditAction::insertBreak);
ruleInfo.maxLength = mMaxTextLength;
bool cancel, handled;
nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(res, res);
if (!cancel && !handled)
{
// get the (collapsed) selection location
NS_ENSURE_STATE(selection->GetRangeAt(0));
@@ -1096,17 +1096,17 @@ nsPlaintextEditor::Undo(uint32_t aCount)
AutoUpdateViewBatch beginViewBatching(this);
ForceCompositionEnd();
NotifyEditorObservers(eNotifyEditorObserversOfBefore);
AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
- nsTextRulesInfo ruleInfo(EditAction::undo);
+ TextRulesInfo ruleInfo(EditAction::undo);
RefPtr<Selection> selection = GetSelection();
bool cancel, handled;
nsresult result = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (!cancel && NS_SUCCEEDED(result))
{
result = nsEditor::Undo(aCount);
result = mRules->DidDoAction(selection, &ruleInfo, result);
@@ -1125,17 +1125,17 @@ nsPlaintextEditor::Redo(uint32_t aCount)
AutoUpdateViewBatch beginViewBatching(this);
ForceCompositionEnd();
NotifyEditorObservers(eNotifyEditorObserversOfBefore);
AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
- nsTextRulesInfo ruleInfo(EditAction::redo);
+ TextRulesInfo ruleInfo(EditAction::redo);
RefPtr<Selection> selection = GetSelection();
bool cancel, handled;
nsresult result = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
if (!cancel && NS_SUCCEEDED(result))
{
result = nsEditor::Redo(aCount);
result = mRules->DidDoAction(selection, &ruleInfo, result);
@@ -1291,17 +1291,17 @@ NS_IMETHODIMP
nsPlaintextEditor::OutputToString(const nsAString& aFormatType,
uint32_t aFlags,
nsAString& aOutputString)
{
// Protect the edit rules object from dying
nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
nsString resultString;
- nsTextRulesInfo ruleInfo(EditAction::outputText);
+ TextRulesInfo ruleInfo(EditAction::outputText);
ruleInfo.outString = &resultString;
// XXX Struct should store a nsAReadable*
nsAutoString str(aFormatType);
ruleInfo.outputFormat = &str;
bool cancel, handled;
nsresult rv = mRules->WillDoAction(nullptr, &ruleInfo, &cancel, &handled);
if (cancel || NS_FAILED(rv)) { return rv; }
if (handled)
@@ -1424,17 +1424,17 @@ nsPlaintextEditor::InsertAsQuotation(con
// get selection
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
AutoEditBatch beginBatching(this);
AutoRules beginRulesSniffing(this, EditAction::insertText, nsIEditor::eNext);
// give rules a chance to handle or cancel
- nsTextRulesInfo ruleInfo(EditAction::insertElement);
+ TextRulesInfo ruleInfo(EditAction::insertElement);
bool cancel, handled;
rv = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
NS_ENSURE_SUCCESS(rv, rv);
if (cancel) return NS_OK; // rules canceled the operation
if (!handled)
{
rv = InsertText(quotedStuff);