startPos and
* endPos parameters specify with the newTextFlow parameter in
* theFlow.
* To delete elements, pass null for newTextFlow.
To insert an element, pass the same value for startPos and endPos.
*
To insert a newline after the newTextFlow is inserted, pass in
* true for insertParAfter
The new element will be inserted before the specified index.
*To append the TextFlow, pass theFlow.length for startPos and endPos.
theFlow at the indicies specified by startPos and
* endPos. The newSPB will take ownership of any FlowElements within the range and will split them
* as needed. If the parent of the FlowGroupElement indicated by startPos is the same as spgClass then
* the method fails and returns false because a spg cannot own children of the same class as itself. Any spg of type spgClass
* found within the indicies, however, is subsumed into newSPB, effectively replacing it.
*
* @param theFlow:TextFlow - The TextFlow that is the destination for the newSPB
* @param startPos:int - The absolute index value of the first position of the range in the TextFlow to perform the insertion.
* @param endPos:int - The index value following the end position of the range in the TextFlow to perform the insertion.
* @param newSPB:SubParagraphGroupElement - The new SubParagraphElement which is to be added into theFlow.
* @param spgClass:Class - the class of the fbe we intend to add.
*
* Examples: Simple and complex where insertion is of spgClass b. Selection is l~o
* 1) ghijklmnop
* 2) ghijklmnop
* 3) ghijkelem at the relative index of splitPos. If splitSubBlockContents
* is true, split the contents of elem if it is a SubParagraphGroupElement, otherwise just split elem
*
* @param elem:FlowElement - the FlowElement to split
* @param splitPos:int - The elem relative index indicating where to split
* @param splitSubBlockContents:Boolean - boolean indicating whether a SubParagraphGroupElement is to be split OR that it's contents
* should be split. For example, are we splitting a link or are we splitting the child of the link
*
* splitPos indicated index between C and D, then if splitSubBlockContents equals true,
* result is:
*
* splitSubBlockContents equals false, result is:
*
* elementIdx of fbe, iterate
* through the elements untill we find the one located at the aboslute index of startIdx. Upon
* locating the child, split either the element itself OR its children based on the value of splitSubBlockContents
*
* @param fbe:FlowGroupElement - the FBE into which the newSPB is being inserted.
* @param elementIdx:int - The index into the fbe's child list to start
* @param startIdx:int - The absolute index value into the TextFlow.
* @param splitSubBlockContents:Boolean - boolean indicating whether a subElement is to be split OR that it's contents
* should be split. For example, are we splitting a link or are we splitting the child of the link
*
* ZYXABCDEF123
* * if we are inserting a TCY into the link, splitSubBlockContents should be false. We want to split the span ABCDEF such that result is: *ZYXAB
ZYXABCDEF123
* * @return int - the index of the last child offbe processed.
*/
tlf_internal static function findAndSplitElement(fbe:FlowGroupElement, elementIdx:int, startIdx:int, splitSubBlockContents:Boolean):int
{
var curFlowEl:FlowElement = null;
var curIndexInPar:int = startIdx - fbe.getAbsoluteStart();
while(elementIdx < fbe.numChildren)
{
curFlowEl = fbe.getChildAt(elementIdx);
if (curIndexInPar == curFlowEl.parentRelativeStart)
return elementIdx;
if ((curIndexInPar > curFlowEl.parentRelativeStart) && (curIndexInPar < curFlowEl.parentRelativeEnd))
{
splitElement(curFlowEl, curIndexInPar - curFlowEl.parentRelativeStart, splitSubBlockContents);
}
++elementIdx;
}
return elementIdx;
}
/**
* @private
* subsumeElementsToSPBlock - incorporates all elements of parentFBE into
* the newSPB between the curPos and endPos. If a child of
* parentFBE is of type spgClass then the child's contents are removed from the child,
* added to the newSPB, the child is then removed from the parentFBE
*
* @param parentFBE:FlowGroupElement - the FBE into which the newSPB is being inserted.
* @param startPos:int - The index value of the first position of the replacement range in the TextFlow.
* @param endPos:int - The index value following the end position of the replacement range in the TextFlow.
* @param newSPB:SubParagraphGroupElement - the new SubParagraphGroupElement we intend to insert.
* @param spgClass:Class - the class of the fbe we intend to insert.
*
* @return int - the aboslute index in the text flow after insertion.
*
* Examples: Simple and complex where insertion is of spgClass b. Selection is l~o
* 1) ghijklmnop
* 2) ghijklmnop
*
* parentFBE =
* elementIdx = 1) 2, 2) 3
* curPos = 5
* endPos = 9
* newSPB is of type
*/
tlf_internal static function subsumeElementsToSPBlock(parentFBE:FlowGroupElement, elementIdx:int, curPos:int, endPos:int, newSPB:SubParagraphGroupElement, spgClass:Class):int
{
var curFlowEl:FlowElement = null;
//if we have an invalid index, then skip out. elementIdx will always point one
//element beyond the one we are inserting....
if(elementIdx >= parentFBE.numChildren)
return curPos;
while (curPos < endPos)
{
//running example: curFlowEl is the element immediately after the inserted newSPB:
// 1) ghijklmnop
// points to span-lmnop
// 2) ghijklmnop
// points to b-lm
curFlowEl = parentFBE.getChildAt(elementIdx);
//if the curFlowEl is of the Class we are adding (spgClass), and the entire thing is selected,
//then we are adding the entire block, but not spliting it - perform the split on the next block
//I think this can be safely removed from here as ownership of contents is handled below.
//leaving in commented out code in case we need to revert - gak 05.01.08
/* if(curFlowEl is spgClass && curPos == curFlowEl.getAbsoluteStart() && curFlowEl.getAbsoluteStart() + curFlowEl.textLength <= endPos)
{
curPos = parentFBE.getAbsoluteStart() + parentFBE.textLength;
continue;
}*/
//if the endPos is less than the length of the curFlowEl, then we need to split it.
//if the curFlowEl is NOT of class type spgClass, then we need to break it
//
//Use case: splitting a link in two (or three as will be the result with head and tail sharing
//attributes...
//running example 1 hits this, but 2 does not. Using variation of 2:
//
// example: 1) ghijklmnop
// 2a) foobar - selection: from o~a
//
// after this code:
// 1) ghijklmnop
// 2a) foobaor
if ((curPos + curFlowEl.textLength) > endPos)
{
splitElement(curFlowEl, endPos - curFlowEl.getAbsoluteStart(), !(curFlowEl is spgClass)); //changed to curFlowEl from newSPB as newSPB should be of type spgClass
}
//add the length before replacing the elements
curPos += curFlowEl.textLength;
//running example: after parentFBE.replaceChildren
//
// 1) curFlowEl = lmno
// ghijk{curFlowEl}p
//
// 2) curFlowEl = lm
// ghijk{curFlowEl}nop
parentFBE.replaceChildren(elementIdx, elementIdx + 1, null);
//if the curFlowEl is of type spgClass, then we need to take its children and
//add them to the newSPB because a spg cannot contain a child of the same class
//as itself
//
// exmaple: 2) curFlowEl = lm
if (curFlowEl is spgClass)
{
var subBlock:SubParagraphGroupElement = curFlowEl as SubParagraphGroupElement;
//elementCount == 1 - lm
while (subBlock.numChildren > 0)
{
//fe[0] = lm
var fe:FlowElement = subBlock.getChildAt(0);
//
subBlock.replaceChildren(0, 1, null);
//lm
newSPB.replaceChildren(newSPB.numChildren, newSPB.numChildren, fe);
}
//when compelete, example 2 is:
//2) ghijklmnop
}
else
{
//example 1, curFlowEl is lmno, so this is not hit
//
// extending element from foo~other
// foobarother
// curFlowEl = barother
//
// since is a spg, we need to walk it's contents and remove any elements
if(curFlowEl is SubParagraphGroupElement)
{
//we need to dive into this spgClass and remove any fbes of type spgClass
//pass in the curFlowEl as the newSPB, remove any spgs of type spgClass, then
//perform the replace on the newSPB passed in here
//
//ignore the return value of the recursive call as the length has already been
//accounted for above
flushSPBlock(curFlowEl as SubParagraphGroupElement, spgClass);
}
newSPB.replaceChildren(newSPB.numChildren, newSPB.numChildren, curFlowEl);
if(newSPB.numChildren == 1 && curFlowEl is SubParagraphGroupElement)
{
var childSPGE:SubParagraphGroupElement = curFlowEl as SubParagraphGroupElement;
//running example:
//a.precedence = 800, tcy.precedence = kMinSPGEPrecedence
//this = fooBar
//childSPGE = fooBar
if(childSPGE.textLength == newSPB.textLength && (curPos >= endPos))
{
CONFIG::debug { assert(childSPGE.precedence != newSPB.precedence, "normalizeRange found two equal SPGEs"); }
//if the child's precedence is higher than mine, I need to swap
if(childSPGE.precedence > newSPB.precedence)
{
//first, remove the child
//this = fooBar
newSPB.replaceChildren(newSPB.numChildren, newSPB.numChildren, tempFE);
}
var myIdx:int = newSPB.parent.getChildIndex(newSPB);
CONFIG::debug{ assert(myIdx >= 0, "Invalid index! How can a SubParagraphGroupElement normalizing not have a parent!"); }
//add childSPGE in my place
newSPB.parent.replaceChildren(myIdx, myIdx + 1, childSPGE)
//childSPGE = fooBar
childSPGE.replaceChildren(0,0,newSPB);
}
}
}
}
}
return curPos;
}
/**
* @private
* findAndRemoveFlowGroupElement
*
* @param theFlow The TextFlow that is containing the elements to remove.
* @param startPos The index value of the first position of the range in the TextFlow where we want to perform removal.
* @param endPos The index value following the end position of the range in the TextFlow where we want to perform removal.
* @param fbeClass Class the class of the fbe we intend to remove.
*
* Walks through the elements of theFlow looking for any FlowGroupElement of type fbeClass
* On finding one, it removes the FBE's contents and adds them back into the FBE's parent. If the class of object is
* embedded within another spg and this removal would break the parent spg, then the method does nothing.
*
* Example:
* ABCDEF GHI
* Selection is on E and removal of link is attempted.
* Because E is a child of a spg (tcy), and removing the link from E would split the parent spg (link),
* the action is disallowed.
*
* Running example:
* 1) foo bar
* @return Boolean - true if items are removed or none are found. false if operation is illegal.
*/
tlf_internal static function findAndRemoveFlowGroupElement(theFlow:TextFlow, startPos:int, endPos:int, fbeClass:Class):Boolean
{
var curPos:int = startPos;
var curEl:FlowElement;
//walk through the elements
while (curPos < endPos)
{
var containerFBE:FlowGroupElement = theFlow.findAbsoluteFlowGroupElement(curPos);
//if the start of the parent is the same as the start of the current containerFBE, then
//we potentially have the wrong object. We need to walk up the parents until we get to
//the one which starts at our start AND is the topmost object at that index.
//example: foo bar - getting the object at "f" will yield the element, not
while(containerFBE.parent && containerFBE.parent.getAbsoluteStart() == containerFBE.getAbsoluteStart() &&
!(containerFBE.parent is ParagraphElement)) //don't go beyond paragraph
{
containerFBE = containerFBE.parent;
}
//if the absoluteFBE is the item we are trying to remove, we need to work with its parent, so
//reassign containerFBE. For example, if an entire link were selected, we'd need to get it's parent to
//perform the removal
if(containerFBE is fbeClass)
containerFBE = containerFBE.parent;
//before processing this any further, we need to make sure that we are not
//splitting a spg which is contained within the same type of spg as the curFBE's parent.
//for example, if we had a tcyElement inside a linkElement, then we cannot allow a link element
//to be broken within the tcyElement as the link would have to split the TCY.
var ancestorOfFBE:FlowGroupElement = containerFBE.parent;
while(ancestorOfFBE != null && !(ancestorOfFBE is fbeClass))
{
if(ancestorOfFBE.parent is fbeClass)
{
return false;
}
ancestorOfFBE = ancestorOfFBE.parent;
}
//if this is a sbe block contained in another sbe, and it is entire within the
//selection bounds, we need to use the parent sbe's container. If it is splitting
//the child sbe, we don't allow this and it is handled later...
var containerFBEStart:int = containerFBE.getAbsoluteStart();
if(ancestorOfFBE is fbeClass && (containerFBEStart >= curPos && containerFBEStart + containerFBE.textLength <= endPos))
containerFBE = ancestorOfFBE.parent;
var childIdx:int = containerFBE.findChildIndexAtPosition(curPos - containerFBEStart);
curEl = containerFBE.getChildAt(childIdx);
if(curEl is fbeClass)
{
CONFIG::debug{ assert(curEl is SubParagraphGroupElement, "Wrong FBE type! Trying to remove illeage FBE!") };
var curFBE:FlowGroupElement = curEl as FlowGroupElement;
//get it's parent and the index of the curFBE
var parentBlock:FlowGroupElement = curFBE.parent;
var idxInParent:int = parentBlock.getChildIndex(curFBE);
//if the curPos is not at the head of the SPB, then we need to split it here
//curFBE will point to the FBE starting at curPos
if(curPos > curFBE.getAbsoluteStart())
{
splitElement(curFBE, curPos - curFBE.getAbsoluteStart(), false);
curPos = curFBE.getAbsoluteStart() + curFBE.textLength;
continue;
}
//if curFBE goes beyond the endPos, then we need to split off the tail.
if (curFBE.getAbsoluteStart() + curFBE.textLength > endPos)
{
splitElement(curFBE, endPos - curFBE.getAbsoluteStart(), false);
}
//apply the length of the curFBE to the curPos tracker. Do this before
//removing the contents or it will be 0!
curPos = curFBE.getAbsoluteStart() + curFBE.textLength;
//walk all the contents of the FBE into it's parent container
while (curFBE.numChildren > 0)
{
var childFE:FlowElement = curFBE.getChildAt(0);
curFBE.replaceChildren(0, 1, null);
parentBlock.replaceChildren(idxInParent, idxInParent, childFE);
idxInParent++;
}
//remove the curFBE
parentBlock.replaceChildren(idxInParent, idxInParent + 1, null);
}
else if(curEl is SubParagraphGroupElement) //check all the parents...
{
var curSPB:SubParagraphGroupElement = SubParagraphGroupElement(curEl);
if(curSPB.numChildren == 1)
curPos = curSPB.getAbsoluteStart() + curSPB.textLength;
else
{
curEl = curSPB.getChildAt(curSPB.findChildIndexAtPosition(curPos - curSPB.getAbsoluteStart()));
curPos = curEl.getAbsoluteStart() + curEl.textLength;
}
}
else
{
//the current block isn't the type we're looking for, so just go to the end of the
//FlowElement and continue
curPos = curEl.getAbsoluteStart() + curEl.textLength;
}
}
return true;
}
/**
* @private
* canInsertSPBlock
*
* validate that we a valid selection to allow for insertion of a subBlock. The rules are as
* follows:
* endPos > start
* the new block will not span multiple paragraphs
* if the block is going into a SubParagraphGroupElement, it must not split the block:
* example: Text - ABCDEFG with a link on CDE
* legal new Block - D, CD, CDE, [n-chars]CDE[n1-chars]
* illegal new Block - [1 + n-chars]C[D], [D]E[1 + n-chars]
* exception - if the newBlock is the same class as the one we are trying to split
* then we can truncate the original and add its contents to the new one, or extend it
* as appropriate
*
* @param theFlow The TextFlow that is containing the elements to validate.
* @param startPos The index value of the first position of the range in the TextFlow to test.
* @param endPos The index value following the end position of the range in the TextFlow to test.
* @param blockClass Class the class of the fbe we intend to insert.
*/
tlf_internal static function canInsertSPBlock(theFlow:TextFlow, startPos:int, endPos:int, blockClass:Class):Boolean
{
if(endPos <= startPos)
return false;
var anchorFBE:FlowGroupElement = theFlow.findAbsoluteFlowGroupElement(startPos);
if(anchorFBE.getParentByType(blockClass))
anchorFBE = anchorFBE.getParentByType(blockClass) as FlowGroupElement;
var tailFBE:FlowGroupElement = theFlow.findAbsoluteFlowGroupElement(endPos - 1);
if(tailFBE.getParentByType(blockClass))
tailFBE = tailFBE.getParentByType(blockClass) as FlowGroupElement;
//if these are the same FBEs then we are safe to insert a SubParagraphGroupElement
if(anchorFBE == tailFBE)
return true;
//make sure that the two FBEs belong to the same paragraph!
else if(anchorFBE.getParagraph() != tailFBE.getParagraph())
return false;
else if(anchorFBE is blockClass && tailFBE is blockClass)//they're the same class, OK to merge, split, etc...
return true;
else if(anchorFBE is SubParagraphGroupElement && !(anchorFBE is blockClass))
{
var anchorStart:int = anchorFBE.getAbsoluteStart();
if(startPos > anchorStart && endPos > anchorStart + anchorFBE.textLength)
return false;
}
else if((anchorFBE.parent is SubParagraphGroupElement || tailFBE.parent is SubParagraphGroupElement)
&& anchorFBE.parent != tailFBE.parent)
{
//if either FBE parent is a SPGE and they are not the same, prevent the split.
return false;
}
//if we got here, then the anchorFBE is OK, check the tail. If endPos is pointing to the
//0th character of a FlowGroupElement, we don't need to worry about the tail.
if(tailFBE is SubParagraphGroupElement && !(tailFBE is blockClass) && endPos > tailFBE.getAbsoluteStart())
{
var tailStart:int = tailFBE.getAbsoluteStart();
if(startPos < tailStart && endPos < tailStart + tailFBE.textLength)
return false;
}
return true;
}
/**
* @private flushSPBlock recursively walk a spg looking for elements of type spgClass. On finding one,
* remove it's children and then remove the object itself. Since spg's cannot hold children of the same type
* as themselves, recursion is only needed for spg's of a class other than that of spgClass.
*
* example: subPB = barother extending an element to include all of "other"
*/
tlf_internal static function flushSPBlock(subPB:SubParagraphGroupElement, spgClass:Class):void
{
var subParaIter:int = 0;
//example, subPB has 2 elements, bar and other
while(subParaIter < subPB.numChildren)
{
//subParaIter == 0, subFE = bar skip the FE and move to next
//subParaIter == 1, subFE = other - is a spgClass
var subFE:FlowElement = subPB.getChildAt(subParaIter);
if(subFE is spgClass)
{
//subParaIter == 1, subFE = other
var subChildFBE:FlowGroupElement = subFE as FlowGroupElement;
while(subChildFBE.numChildren > 0)
{
//subFEChild = other
var subFEChild:FlowElement = subChildFBE.getChildAt(0);
//subFEChild =
subChildFBE.replaceChildren(0, 1, null);
//subPB = barother
subPB.replaceChildren(subParaIter, subParaIter, subFEChild);
}
//increment so that subParaIter points to the element we just emptied
++subParaIter;
//remove the empty child
//subPB = barother
subPB.replaceChildren(subParaIter, subParaIter + 1, null);
}
else if(subFE is SubParagraphGroupElement)
{
flushSPBlock(subFE as SubParagraphGroupElement, spgClass);
++subParaIter;
}
else
++subParaIter;//go to next child
}
}
/** Joins this paragraph's next sibling to this if it is a paragraph */
static public function joinNextParagraph(para:ParagraphElement):Boolean
{
if (para && para.parent)
{
var myidx:int = para.parent.getChildIndex(para);
if (myidx != para.parent.numChildren-1)
{
// right now, you can only merge with other paragraphs
var sibParagraph:ParagraphElement = para.parent.getChildAt(myidx+1) as ParagraphElement;
if (sibParagraph)
{
while (sibParagraph.numChildren > 0)
{
var curFlowElement:FlowElement = sibParagraph.getChildAt(0);
sibParagraph.replaceChildren(0, 1, null);
para.replaceChildren(para.numChildren, para.numChildren, curFlowElement);
}
para.parent.replaceChildren(myidx+1, myidx+2, null);
return true;
}
}
}
return false;
}
/** Joins this paragraph's next sibling to this if it is a paragraph */
static public function joinToNextParagraph(para:ParagraphElement):Boolean
{
if (para && para.parent)
{
var myidx:int = para.parent.getChildIndex(para);
if (myidx != para.parent.numChildren-1)
{
// right now, you can only merge with other paragraphs
var sibParagraph:ParagraphElement = para.parent.getChildAt(myidx+1) as ParagraphElement;
if (sibParagraph)
{
// Add the first paragraph's children to the front of the next paragraph's child list
var addAtIndex:int = 0;
while (para.numChildren > 0)
{
var curFlowElement:FlowElement = para.getChildAt(0);
para.replaceChildren(0, 1, null);
sibParagraph.replaceChildren(addAtIndex, addAtIndex, curFlowElement);
++addAtIndex;
}
para.parent.replaceChildren(myidx, myidx+1, null);
return true;
}
}
}
return false;
}
}
}