private static void MoveUnitBounded(MarkupPointer p, MoveDirection direction, MoveContextFilter continueFilter, MarkupPointer boundary)
{
MarkupPointer p1 = p.Clone();
MarkupPointer lastGoodPosition = p.Clone();
MarkupContext context = new MarkupContext();
MoveFilterResult result = MoveFilterResult.CONTINUE;
while (CheckMoveBoundary(p1, boundary, direction) && result == MoveFilterResult.CONTINUE)
{
lastGoodPosition.MoveToPointer(p1);
MovePointer(p1, direction, context);
result = continueFilter(context);
}
if (result == MoveFilterResult.CONTINUE)
{
//we hit the boundary, so position pointer at the boundary
p1.MoveToPointer(boundary);
}
else if (result == MoveFilterResult.STOP_BACK)
{
p1.MoveToPointer(lastGoodPosition);
}
p.MoveToPointer(p1);
}
/// <summary>
/// Creates an instance of the IMarkupPointer object with an initial position
/// at the same location as another pointer.
/// </summary>
/// <param name="initialPosition"></param>
/// <returns></returns>
public MarkupPointer CreateMarkupPointer(MarkupPointer initialPosition)
{
MarkupPointer pointer = CreateMarkupPointer();
pointer.MoveToPointer(initialPosition);
return(pointer);
}
/// <summary>
/// Walk through the markup range in reverse, letting the walker visit each position.
/// </summary>
/// <param name="walker">the delegate walking navigating the the markup range</param>
/// <param name="inScopeElementsOnly">if true, enter/exit notifications about out-of-scope elements will be suppressed.</param>
/// <returns></returns>
public void WalkRangeReverse(MarkupRangeWalker walker, bool inScopeContextsOnly)
{
MarkupPointer p1 = MarkupServices.CreateMarkupPointer(End);
MarkupPointer p2 = MarkupServices.CreateMarkupPointer(End);
p1.Cling = false;
p2.Cling = false;
MarkupContext context = new MarkupContext();
bool continueWalking = true;
MarkupRange currentRange = null;
while (continueWalking && p2.IsRightOf(Start))
{
string text = null;
bool isInScope = true;
p2.Left(true, context);
currentRange = new MarkupRange(p2.Clone(), p1.Clone(), MarkupServices);
if (inScopeContextsOnly)
{
if (context.Element != null)
{
if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_EnterScope)
{
p1.MoveAdjacentToElement(context.Element, _ELEMENT_ADJACENCY.ELEM_ADJ_AfterEnd);
isInScope = InRange(p1);
}
else if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_ExitScope)
{
p1.MoveAdjacentToElement(context.Element, _ELEMENT_ADJACENCY.ELEM_ADJ_BeforeBegin);
isInScope = InRange(p1);
}
}
else if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_Text)
{
// It's possible part of the text is out of scope, so only return the in-scope text.
if (currentRange.Start.IsLeftOf(Start))
{
currentRange.Start.MoveToPointer(Start);
}
}
}
if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_Text)
{
text = currentRange.Text;
}
if (!inScopeContextsOnly || isInScope)
{
continueWalking = walker(currentRange, context, text);
}
p1.MoveToPointer(p2);
}
}
public void ExpandToInclude(MarkupRange range)
{
if (range == null)
{
return;
}
if (Positioned)
{
if (range.Start.IsLeftOf(Start))
{
Start.MoveToPointer(range.Start);
}
if (range.End.IsRightOf(End))
{
End.MoveToPointer(range.End);
}
}
else
{
MoveToRange(range);
}
}
public void MoveToWordEnd(MarkupPointer p)
{
lock (_p)
{
_p.MoveToPointer(p);
_p2.MoveToPointer(p);
_p.MoveUnit(_MOVEUNIT_ACTION.MOVEUNIT_NEXTWORDBEGIN);
_p2.MoveUnit(_MOVEUNIT_ACTION.MOVEUNIT_NEXTWORDEND);
// If CurrentScope is null, this means we have walked off the end of the
// document, in that case we don't want to move the pointer, at is already
// at the end of word.
if (_p2.IsLeftOfOrEqualTo(_p) && _p.CurrentScope != null)
p.MoveToPointer(_p2);
//else, the pointer is already at the end of the current word
}
}
public void MoveToWordStart(MarkupPointer p)
{
lock (_p)
{
_p.MoveToPointer(p);
_p2.MoveToPointer(p);
_p.MoveUnit(_MOVEUNIT_ACTION.MOVEUNIT_PREVWORDEND);
_p2.MoveUnit(_MOVEUNIT_ACTION.MOVEUNIT_PREVWORDBEGIN);
if (_p2.IsRightOfOrEqualTo(_p))
p.MoveToPointer(_p2);
//else, the pointer is already at the start of the current word
}
}
private bool OverwriteDestinationBlockIfEmpty(MarkupPointer destinationStart, MarkupRange bounds)
{
bool blockOverwritten = false;
IHTMLElement parentBlockElement = destinationStart.GetParentElement(ElementFilters.BLOCK_ELEMENTS);
if (parentBlockElement != null)
{
MarkupRange parentBlockRange = MarkupServices.CreateMarkupRange(parentBlockElement, false);
if (bounds.InRange(parentBlockRange, false))
{
if (PrimaryEditableBounds == null || PrimaryEditableBounds.InRange(parentBlockRange))
{
if (parentBlockRange.IsEmptyOfContent())
{
parentBlockRange.MoveToElement(parentBlockElement, true);
DeleteContentNoCling(parentBlockRange.Start, parentBlockRange.End);
// Check to see if the delete we just did caused the insertion point to be
// to become a no longer positioned, and if it did we move it to the start
// of what we deleted
if (!destinationStart.Positioned)
{
//Debug.WriteLine("Invalid pointer after delete, moving the target pointer to the start of the deleted markup.");
destinationStart.MoveToPointer(parentBlockRange.Start);
}
blockOverwritten = true;
}
}
}
}
return blockOverwritten;
}
protected virtual void InsertHtml(MarkupPointer start, MarkupPointer end, string html, string sourceUrl, bool allowBlockBreakout)
{
MarkupRange range = MarkupServices.CreateMarkupRange(start, end);
if (!IsValidContentInsertionPoint(range))
{
DisplayMessage.Show(MessageId.InvalidInsertionPoint);
return;
}
Trace.Assert(start.Positioned && end.Positioned, string.Format(CultureInfo.InvariantCulture, "Invalid pointer being used for insert. start:({0}),end:({1})", start.Positioned, end.Positioned));
// begin undo unit
IUndoUnit undoUnit = CreateUndoUnit();
start.PushCling(true);
end.PushCling(true);
using (undoUnit)
{
// Any changes to the way we remove the content in the destination may need to be changed in
// KeepSourceFormatting.PasteSourceOverDestination as well!
MarkupPointerMoveHelper.PerformImageBreakout(start);
MarkupPointerMoveHelper.PerformImageBreakout(end);
//if the start and endpoints are not equal, then we need to paste over the selection
//so delete the selected region (which will collapse the pointers to now be equal.
if (!start.IsEqualTo(end))
{
//delete the selected content
if (ContentIsDeletableForInsert(start, end))
{
// CT: There is currently a case where we leave empty blocks behind
// see bug 628054. This happens when the start and end markup pointers don't completely
// contain the selected blocks, like: <p>|line1</p><p>line2|</p>. In this case, calling
// deleteNoContentNoClient will leave you with <p>|</p><p>|</p>. The next line collapses
// the end pointer back to the start point since that is where selection started.
DeleteContentNoCling(start, end);
end.MoveToPointer(start);
}
}
if (!string.IsNullOrEmpty(html))
{
//Note: we use MarkupServices to insert the content so that IE doesn't try to fix up URLs.
//Element.insertAdjacentHTML() is a no-no because it rewrites relaive URLs to include
//the fullpath from the local filesytem.
//MarkupServices.ParseString() doesn't attempt to fix up URLs, so its safe to use.
//We will now stage the new content into a MarkupContainer, and then move it into
//the working document.
MarkupPointer sc1 = MarkupServices.CreateMarkupPointer();
MarkupPointer sc2 = MarkupServices.CreateMarkupPointer();
// Do the work ahead of time to get an <p></P> ready to be inserted
// doing this work after the insert this html was called with sometimes
// causes mshtml to not paint things until they are moused over(embeds)
// BUG: 624122, 622715
MarkupPointer mpStart = MarkupServices.CreateMarkupPointer();
MarkupPointer mpEnd = MarkupServices.CreateMarkupPointer();
// Make a temp document and load our ending html into it.
MarkupServices.ParseString(CONTENT_BODY_PADDING, mpStart, mpEnd);
//Create a temporary document from the html and set the start/end pointers to the
//start and end of the document.
MarkupServices.ParseString(html, sc1, sc2);
IHTMLDocument2 doc = sc1.GetDocument();
MarkupRange stagingRange = MarkupServices.CreateMarkupRange(sc1, sc2);
stagingRange.MoveToElement(doc.body, false);
// We only need to insert the ending new line if there was a div or image added
bool allowNewLineInsert = ShouldAllowNewLineInsert(html);
Trace.Assert(stagingRange.Positioned && stagingRange.Start.Positioned && stagingRange.End.Positioned && sc1.Positioned && sc2.Positioned, String.Format(CultureInfo.InvariantCulture, "Staging document is not ready. stagingRange:({0}),stagingRange.Start:({1}),stagingRange.End:({2}),sc1:({3}),sc2:({4})", stagingRange.Positioned, stagingRange.Start.Positioned, stagingRange.End.Positioned, sc1.Positioned, sc2.Positioned));
try
{
// Any changes to the way we remove the content in the destination may need to be changed in
// KeepSourceFormatting.PasteSourceOverDestination as well!
bool emptyBlockRemoved;
if (stagingRange.ContainsElements(ElementFilters.IsBlockOrTableElement))
{
// if the destination is an empty block element then just overwrite it
emptyBlockRemoved = OverwriteDestinationBlockIfEmpty(start, PrimaryEditableBounds);
if (!emptyBlockRemoved && allowBlockBreakout)
{
// otherwise split the destination block or move outside of the block
MarkupHelpers.SplitBlockForInsertionOrBreakout(MarkupServices, PrimaryEditableBounds, start);
}
end.MoveToPointer(start);
}
}
catch (COMException ex)
{
Trace.WriteLine(String.Format(CultureInfo.InvariantCulture, "RemoveBlockOrTableElement Failed ({0},{1},{2},{4}): {3}", stagingRange.Start.Positioned, stagingRange.End.Positioned, end.Positioned, ex, start.Positioned));
throw;
}
InflateEmptyParagraphs(stagingRange);
FixUpStickyBrs(stagingRange);
if (HTMLDocumentHelper.IsQuirksMode(HTMLDocument))
{
ForceTablesToInheritFontColor(stagingRange);
}
Trace.Assert(stagingRange.Positioned && stagingRange.Start.Positioned && stagingRange.End.Positioned && sc1.Positioned && sc2.Positioned, String.Format(CultureInfo.InvariantCulture, "Staging document corrupt after RemoveBlockOrTableElement. stagingRange:({0}),stagingRange.Start:({1}),stagingRange.End:({2}),sc1:({3}),sc2:({4})", stagingRange.Positioned, stagingRange.Start.Positioned, stagingRange.End.Positioned, sc1.Positioned, sc2.Positioned));
IDisposable damageTracker = null;
try
{
damageTracker = CreateDamageTracking(end, true);
}
catch (COMException ex)
{
Trace.WriteLine(String.Format(CultureInfo.InvariantCulture, "CreateDamageTracking Failed ({0}): {1}", end.Positioned, ex));
throw;
}
Trace.Assert(stagingRange.Positioned && stagingRange.Start.Positioned && stagingRange.End.Positioned && sc1.Positioned && sc2.Positioned, String.Format(CultureInfo.InvariantCulture, "Staging document corrupt after CreateDamageTracking. stagingRange:({0}),stagingRange.Start:({1}),stagingRange.End:({2}),sc1:({3}),sc2:({4})", stagingRange.Positioned, stagingRange.Start.Positioned, stagingRange.End.Positioned, sc1.Positioned, sc2.Positioned));
using (damageTracker)
{
// CT: Because we don't set gravity, these pointers can end up in indeterminant positions.
// For example, when inserting HTML over a selection inside of a block, the start
// pointer can end up on the right side of the end pointer. Pushing gravity onto
// the pointers before we call this should provide consistent markup pointer behavior.
try
{
start.PushGravity(_POINTER_GRAVITY.POINTER_GRAVITY_Left);
end.PushGravity(_POINTER_GRAVITY.POINTER_GRAVITY_Right);
Trace.Assert(stagingRange.Positioned && stagingRange.Start.Positioned && stagingRange.End.Positioned && sc1.Positioned && sc2.Positioned, String.Format(CultureInfo.InvariantCulture, "Staging document corrupt after applying gravity. stagingRange:({0}),stagingRange.Start:({1}),stagingRange.End:({2}),sc1:({3}),sc2:({4})", stagingRange.Positioned, stagingRange.Start.Positioned, stagingRange.End.Positioned, sc1.Positioned, sc2.Positioned));
try
{
MarkupServices.Move(stagingRange.Start, stagingRange.End, end);
}
catch (COMException ex)
{
Trace.WriteLine(
String.Format(CultureInfo.InvariantCulture, "MarkupServices.Move Failed ({0},{1},{2}): {3}",
stagingRange.Start.Positioned, stagingRange.End.Positioned,
end.Positioned, ex));
throw;
}
}
finally
{
end.PopGravity();
start.PopGravity();
}
if (allowNewLineInsert && TidyWhitespace)
{
try
{
EnsureNewLineAtDocEnd(mpStart, mpEnd);
}
catch (Exception ex)
{
Trace.WriteLine("Failed to insert new line at end of document: " + ex);
}
}
}
}
// note that we have completed our edit
undoUnit.Commit();
start.PopCling();
end.PopCling();
}
}
/// <summary>
/// Safely removes the content within this range without leaving the document badly formed.
/// </summary>
public void RemoveContent()
{
//delete the selection by moving a delete range right (from the start).
//Each time that a tag that does not entirely exist within this selection
//is encountered, the range content will be deleted, the deleteRange will
//skip over the element.
MarkupRange deleteRange = this.Clone();
Trace.Assert(deleteRange.Start.Positioned, "Trying to remove content from selection that contains pointers that are not positioned.");
deleteRange.End.MoveToPointer(deleteRange.Start);
MarkupPointer p = MarkupServices.CreateMarkupPointer();
MarkupPointer previousPosition = MarkupServices.CreateMarkupPointer(deleteRange.End);
MarkupContext context = new MarkupContext();
deleteRange.End.Right(true, context);
while (deleteRange.End.IsLeftOf(End))
{
if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_EnterScope)
{
p.MoveAdjacentToElement(context.Element, _ELEMENT_ADJACENCY.ELEM_ADJ_AfterEnd);
if (p.IsRightOf(End))
{
//this element does not exist entirely in this selection, so we need to
//ignore it in the delete.
//save this position so that the delete range can be repositioned here
p.MoveToPointer(deleteRange.End);
//move the end left since we overstepped the valid delete range
deleteRange.End.MoveToPointer(previousPosition);
//delete the content in the deleteRange, and move it back to this position
deleteRangeContentAndMoveToPosition(deleteRange, p);
}
else
{
//this element exists entirely in this selection, so skip to its end (since
//we know it can be deleted)
deleteRange.End.MoveToPointer(p);
}
}
else if (context.Context == _MARKUP_CONTEXT_TYPE.CONTEXT_TYPE_ExitScope)
{
p.MoveAdjacentToElement(context.Element, _ELEMENT_ADJACENCY.ELEM_ADJ_BeforeBegin);
if (p.IsLeftOf(Start))
{
//this element does not exist entirely in this selection, so we need to
//ignore it in the delete.
//save this position so that the delete range can be repositioned here
p.MoveToPointer(deleteRange.End);
//move the end left since we overstepped the valid delete range
deleteRange.End.MoveToPointer(previousPosition);
//delete the content in the deleteRange, and move it back to this position
deleteRangeContentAndMoveToPosition(deleteRange, p);
}
else
{
//this element exists entirely in this selection, so skip to its end (since
//we know it can be deleted)
deleteRange.End.MoveToPointer(p);
}
}
previousPosition.MoveToPointer(deleteRange.End);
deleteRange.End.Right(true, context);
}
//delete the last part of the range
deleteRange.End.MoveToPointer(End);
if (!deleteRange.Start.Equals(deleteRange.End))
{
MarkupServices.Remove(deleteRange.Start, deleteRange.End);
}
}
private static void MoveUnitBounded(MarkupPointer p, MoveDirection direction, MoveContextFilter continueFilter, MarkupPointer boundary)
{
MarkupPointer p1 = p.Clone();
MarkupPointer lastGoodPosition = p.Clone();
MarkupContext context = new MarkupContext();
MoveFilterResult result = MoveFilterResult.CONTINUE;
while (CheckMoveBoundary(p1, boundary, direction) && result == MoveFilterResult.CONTINUE)
{
lastGoodPosition.MoveToPointer(p1);
MovePointer(p1, direction, context);
result = continueFilter(context);
}
if (result == MoveFilterResult.CONTINUE)
{
//we hit the boundary, so position pointer at the boundary
p1.MoveToPointer(boundary);
}
else if (result == MoveFilterResult.STOP_BACK)
{
p1.MoveToPointer(lastGoodPosition);
}
p.MoveToPointer(p1);
}