bool pt_PieceTable::insertStrux(PT_DocPosition dpos,
PTStruxType pts,
pf_Frag_Strux ** ppfs_ret)
{
if(m_pDocument->isMarkRevisions())
{
// when the strux is inserted in non-revision mode, it inherits the AP from the previous
// strux. In revision mode this does not necessarily work because we may need to have a
// different revision attribute. Consequently, we need to ensure that the AP that gets
// assigned to the new strux contains all relevant attrs and props from the AP of the
// previous strux -- we do this by obtaining the index of the AP of the previous strux and
// running it through _translateRevisionAttribute() which will gives back all attrs and
// props that need to be passed to _realInsertStrux()
pf_Frag_Strux * pfsContainer = NULL;
bool bFoundContainer = _getStruxFromPosition(dpos,&pfsContainer); // the orig. strux
UT_return_val_if_fail(bFoundContainer, false);
if(isEndFootnote(pfsContainer))
{
bFoundContainer = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail(bFoundContainer, false);
}
PT_AttrPropIndex indexAP = 0;
if (pfsContainer->getStruxType() == pts)
{
indexAP = pfsContainer->getIndexAP();
}
PP_RevisionAttr Revisions(NULL);
const gchar ** ppRevAttrib = NULL;
const gchar ** ppRevProps = NULL;
_translateRevisionAttribute(Revisions, indexAP, PP_REVISION_ADDITION, ppRevAttrib, ppRevProps, 0, 0);
//return _realChangeStruxFmt(PTC_AddFmt, dpos, dpos + iLen, ppRevAttrib,ppRevProps,pts);
return _realInsertStrux(dpos,pts,ppRevAttrib,ppRevProps,ppfs_ret);
}
else
{
return _realInsertStrux(dpos,pts,0,0,ppfs_ret);
}
}
bool pt_PieceTable::_realChangeSpanFmt(PTChangeFmt ptc,
PT_DocPosition dpos1,
PT_DocPosition dpos2,
const gchar ** attributes,
const gchar ** properties,
bool bRevisionDelete)
{
// apply a span-level formatting change to the given region.
UT_return_val_if_fail (m_pts==PTS_Editing,false);
_tweakFieldSpan(dpos1,dpos2);
//
// Deal with case of exactly selecting the endOfFootnote
//
pf_Frag * pfEndDum = m_fragments.findFirstFragBeforePos(dpos2);
if(isEndFootnote(pfEndDum))
{
if(dpos2 > dpos1)
{
dpos2--;
}
}
//
// Deal with addStyle
//
bool bApplyStyle = (PTC_AddStyle == ptc);
const gchar ** sProps = NULL;
const gchar ** lProps = properties;
if(bApplyStyle)
{
//
// OK for styles we expand out all defined properties including BasedOn styles
// Then we use these to eliminate any specfic properties in the current strux
// Then properties in the current strux will resolve to those defined in the
// style (they exist there) to specifc values in strux (if not overridden by
// the style) then finally to default value.
//
const gchar * szStyle = UT_getAttribute(PT_STYLE_ATTRIBUTE_NAME,attributes);
PD_Style * pStyle = NULL;
UT_return_val_if_fail (szStyle,false);
getDocument()->getStyle(szStyle,&pStyle);
UT_return_val_if_fail (pStyle,false);
UT_Vector vProps;
//
// Get the vector of properties
//
pStyle->getAllProperties(&vProps,0);
//
// Finally make the const gchar * array of properties
//
UT_uint32 countp = vProps.getItemCount() + 1;
sProps = (const gchar **) UT_calloc(countp, sizeof(gchar *));
countp--;
UT_uint32 i;
for(i=0; i<countp; i++)
{
sProps[i] = (const gchar *) vProps.getNthItem(i);
}
sProps[i] = NULL;
lProps = sProps;
}
if (dpos1 == dpos2) // if length of change is zero, then we have a toggle format.
{
UT_uint32 startUndoPos = m_history.getUndoPos();
bool bRes = _insertFmtMarkFragWithNotify(ptc,dpos1,attributes,lProps);
UT_uint32 endUndoPos = m_history.getUndoPos();
// Won't be a persistant change if it's just a toggle
PX_ChangeRecord *pcr=0;
m_history.getUndo(&pcr,true);
if (pcr && (startUndoPos != endUndoPos) )
{
UT_DEBUGMSG(("Setting persistance of change to false\n"));
pcr->setPersistance(false);
m_history.setSavePosition(m_history.getSavePosition()+1);
}
if(bApplyStyle)
{
FREEP(sProps);
}
return bRes;
}
UT_return_val_if_fail (dpos1 < dpos2,false);
bool bHaveAttributes, bHaveProperties;
bHaveAttributes = (attributes && *attributes);
bHaveProperties = (lProps && *lProps);
pf_Frag * pf_First;
pf_Frag * pf_End;
PT_BlockOffset fragOffset_First;
PT_BlockOffset fragOffset_End;
bool bFound;
bFound = getFragsFromPositions(dpos1,dpos2,&pf_First,&fragOffset_First,&pf_End,&fragOffset_End);
UT_return_val_if_fail (bFound, false);
#if 0
{
pf_Frag * pf1, * pf2;
PT_BlockOffset fo1, fo2;
bool bFound1 = getFragFromPosition(dpos1,&pf1,&fo1);
bool bFound2 = getFragFromPosition(dpos2,&pf2,&fo2);
UT_return_val_if_fail (bFound1 && bFound2, false);
UT_return_val_if_fail ((pf1==pf_First) && (fragOffset_First==fo1), false);
UT_return_val_if_fail ((pf2==pf_End) && (fragOffset_End==fo2), false);
}
#endif
// see if the amount of text to be changed is completely
// contained within a single fragment. if so, we have a
// simple change. otherwise, we need to set up a multi-step
// change -- it may not actually take more than one step,
// but it is too complicated to tell at this point, so we
// assume it will and don't worry about it.
//
// we are in a simple change if the beginning and end are
// within the same fragment.
// NOTE: if we call beginMultiStepGlob() we ***MUST*** call
// NOTE: endMultiStepGlob() before we return -- otherwise,
// NOTE: the undo/redo won't be properly bracketed.
bool bSimple = (pf_First == pf_End);
if (!bSimple)
beginMultiStepGlob();
pf_Frag_Strux * pfsContainer = NULL;
pf_Frag * pfNewEnd;
UT_uint32 fragOffsetNewEnd;
UT_uint32 length = dpos2 - dpos1;
while (length != 0)
{
// FIXME: Special check to support a FmtMark at the end of the
// document. This is necessary because FmtMarks don't have a
// length... See bug 452.
if (0 == length
&& (!pf_First || pf_Frag::PFT_FmtMark != pf_First->getType()))
break;
UT_return_val_if_fail (dpos1+length==dpos2, false);
UT_uint32 lengthInFrag = pf_First->getLength() - fragOffset_First;
UT_uint32 lengthThisStep = UT_MIN(lengthInFrag, length);
switch (pf_First->getType())
{
case pf_Frag::PFT_EndOfDoc:
default:
UT_DEBUGMSG(("fragment type: %d\n",pf_First->getType()));
UT_ASSERT_HARMLESS(0);
if(bApplyStyle)
{
FREEP(sProps);
}
return false;
case pf_Frag::PFT_Strux:
{
// we are only applying span-level changes, so we ignore strux.
// but we still need to update our loop indices.
pfNewEnd = pf_First->getNext();
fragOffsetNewEnd = 0;
pfsContainer = static_cast<pf_Frag_Strux *> (pf_First);
bool bFoundStrux = false;
if(isEndFootnote(pfsContainer))
{
bFoundStrux = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail (bFoundStrux, false);
}
}
break;
case pf_Frag::PFT_Text:
{
if (!pfsContainer)
{
bool bFoundStrux;
bFoundStrux = _getStruxFromPosition(dpos1,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote(pfsContainer))
{
bFoundStrux = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
}
}
bool bResult;
bResult = _fmtChangeSpanWithNotify(ptc,static_cast<pf_Frag_Text *>(pf_First),
fragOffset_First,dpos1,lengthThisStep,
attributes,lProps,
pfsContainer,&pfNewEnd,&fragOffsetNewEnd,bRevisionDelete);
UT_return_val_if_fail (bResult,false);
}
break;
case pf_Frag::PFT_Object:
{
if (!pfsContainer)
{
bool bFoundStrux;
bFoundStrux = _getStruxFromPosition(dpos1,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote(pfsContainer))
{
bFoundStrux = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
}
}
bool bResult;
bResult = _fmtChangeObjectWithNotify(ptc,static_cast<pf_Frag_Object *>(pf_First),
fragOffset_First,dpos1,lengthThisStep,
attributes,lProps,
pfsContainer,&pfNewEnd,&fragOffsetNewEnd,false);
UT_return_val_if_fail (bResult,false);
}
break;
case pf_Frag::PFT_FmtMark:
{
if (!pfsContainer)
{
bool bFoundStrux;
bFoundStrux = _getStruxFromPosition(dpos1,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote(pfsContainer))
{
bFoundStrux = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail (bFoundStrux,false);
}
}
bool bResult;
bResult = _fmtChangeFmtMarkWithNotify(ptc,static_cast<pf_Frag_FmtMark *>(pf_First),
dpos1, attributes,lProps,
pfsContainer,&pfNewEnd,&fragOffsetNewEnd);
UT_return_val_if_fail (bResult,false);
}
break;
}
dpos1 += lengthThisStep;
length -= lengthThisStep;
// since _fmtChange{Span,FmtMark,...}WithNotify(), can delete pf_First, mess with the
// fragment list, and does some aggressive coalescing of
// fragments, we cannot just do a pf_First->getNext() here.
// to advance to the next fragment, we use the *NewEnd variables
// that each of the cases routines gave us.
pf_First = pfNewEnd;
if (!pf_First)
length = 0;
fragOffset_First = fragOffsetNewEnd;
}
if(bApplyStyle)
{
FREEP(sProps);
}
if (!bSimple)
endMultiStepGlob();
return true;
}
bool pt_PieceTable::_doTheDo(const PX_ChangeRecord * pcr, bool bUndo)
{
// actually do the work of the undo or redo.
m_bDoingTheDo = true;
switch (pcr->getType())
{
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_GlobMarker:
DONE();
m_bDoingTheDo = false;
return true;
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrSpan = static_cast<const PX_ChangeRecord_Span *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
UT_DEBUGMSG(("_undo insertspan Pos = %d \n",pcr->getPosition()));
bool bFound = getFragFromPosition(pcrSpan->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
}
PT_BlockOffset newOffset = pcrSpan->getPosition() - pfs->getPos() -1;
if (!_insertSpan(pf,pcrSpan->getBufIndex(),fragOffset,
pcrSpan->getLength(),pcrSpan->getIndexAP(),
pcrSpan->getField()))
return false;
DONE();
pcrSpan->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_DeleteSpan:
{
// Our deleteSpan is much simpler than the main routine.
// We can do this becase the change history is composed
// of atomic operations, whereas the main routine has to
// to deal with whatever the user chose to do (and cut
// it into a series of steps).
const PX_ChangeRecord_Span * pcrSpan = static_cast<const PX_ChangeRecord_Span *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrSpan->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound,false);
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_Text,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux, false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux, false);
}
UNDO_return_val_if_fail (bFoundStrux, false);
UT_sint32 newOffset = pcrSpan->getPosition() - pfs->getPos() -1; //was -2
if(newOffset < 0)
newOffset = 0;
pf_Frag_Text * pft = static_cast<pf_Frag_Text *> (pf);
UNDO_return_val_if_fail (pft->getIndexAP() == pcrSpan->getIndexAP(),false);
xxx_UT_DEBUGMSG(("deletespan in _doTheDo length %d \n",pcrSpan->getLength()));
UT_uint32 iLenDeleted = fragOffset + pft->getLength();
if(iLenDeleted >= pcrSpan->getLength())
{
_deleteSpan(pft,fragOffset,pcrSpan->getBufIndex(),pcrSpan->getLength(),NULL,NULL);
}
else
{
pf_Frag_Text * pftNext = static_cast<pf_Frag_Text *>(pft->getNext());
UT_uint32 iLenDel = pft->getLength() - fragOffset;
iLenDeleted = 0;
while(pft && (pft ->getType() == pf_Frag::PFT_Text) && (iLenDeleted <pcrSpan->getLength()) )
{
_deleteSpan(pft,fragOffset,pcrSpan->getBufIndex(),iLenDel,NULL,NULL);
pft = pftNext;
pftNext = static_cast<pf_Frag_Text *>(pft->getNext());
iLenDeleted += iLenDel;
iLenDel = pcrSpan->getLength() - iLenDeleted;
if(iLenDel > pft->getLength())
iLenDel = pft->getLength();
fragOffset = 0;
}
}
UT_DEBUGMSG(("newOffset %d spanBlockOffset %d \n",newOffset,pcrSpan->getBlockOffset()));
pcrSpan->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
DONE();
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_ChangeSpan:
{
// ChangeSpan is it's own inverse. similarly, we have a much simpler
// job than the main routine, because we have broken up the user's
// request into atomic operations.
const PX_ChangeRecord_SpanChange * pcrs = static_cast<const PX_ChangeRecord_SpanChange *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrs->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound, false);
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_Text, false);
pf_Frag_Text * pft = static_cast<pf_Frag_Text *> (pf);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux, false);
}
UNDO_return_val_if_fail (bFoundStrux, false);
PT_BlockOffset newOffset = pcrs->getPosition() - pfs->getPos() -1;
// we need to loop here, because even though we have a simple (atomic) change,
// the document may be fragmented slightly differently (or rather, it may not
// yet be possible to coalesce it (until the end of the loop)).
pf_Frag * pfEnd;
UT_uint32 fragOffsetEnd;
UT_uint32 length = pcrs->getLength();
while (length)
{
UT_uint32 lengthInFrag = pft->getLength() - fragOffset;
UT_uint32 lengthThisStep = UT_MIN(lengthInFrag, length);
_fmtChangeSpan(pft,fragOffset,lengthThisStep,pcrs->getIndexAP(),&pfEnd,&fragOffsetEnd);
length -= lengthThisStep;
if (length == 0)
break;
UNDO_return_val_if_fail (pfEnd->getType() == pf_Frag::PFT_Text, false);
pft = static_cast<pf_Frag_Text *> (pfEnd);
fragOffset = fragOffsetEnd;
}
DONE();
pcrs->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_InsertStrux:
{
const PX_ChangeRecord_Strux * pcrStrux = static_cast<const PX_ChangeRecord_Strux *>(pcr);
pf_Frag_Strux * pfsNew = NULL;
if (!_createStrux(pcrStrux->getStruxType(),pcrStrux->getIndexAP(),&pfsNew))
return false;
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFoundFrag = getFragFromPosition(pcrStrux->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFoundFrag, false);
// get the strux containing the given position.
// TODO see if we can avoid this call to _getStruxFromPosition ??
pf_Frag_Strux * pfsContainer = NULL;
bool bFoundContainer = _getStruxFromPosition(pcrStrux->getPosition(),&pfsContainer);
UNDO_return_val_if_fail (bFoundContainer,false);
if(isEndFootnote(static_cast<pf_Frag *>(pfsContainer)))
{
bool bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfsContainer),&pfsContainer);
UNDO_return_val_if_fail (bFoundStrux, false);
}
_insertStrux(pf,fragOffset,pfsNew);
DONE();
m_pDocument->notifyListeners(pfsContainer,pfsNew,pcr);
}
return true;
case PX_ChangeRecord::PXT_DeleteStrux:
{
const PX_ChangeRecord_Strux * pcrStrux = static_cast<const PX_ChangeRecord_Strux *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFoundFrag = getFragFromPosition(pcrStrux->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFoundFrag,false);
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_Strux,false);
pf_Frag_Strux * pfs = static_cast<pf_Frag_Strux *> (pf);
UNDO_return_val_if_fail (pcrStrux->getStruxType() == pfs->getStruxType(),false);
bool bResult = _unlinkStrux(pfs,NULL,NULL);
m_pDocument->notifyListeners(pfs,pcr);
UNDO_return_val_if_fail (bResult,false);
DONE();
delete pfs;
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_ChangeStrux:
{
// ChangeStrux is it's own inverse.
const PX_ChangeRecord_StruxChange * pcrs = static_cast<const PX_ChangeRecord_StruxChange *>(pcr);
pf_Frag_Strux * pfs;
bool bFound = _getStruxFromPosition(pcrs->getPosition(),&pfs);
UNDO_return_val_if_fail (bFound,false);
bool bResult = _fmtChangeStrux(pfs,pcrs->getIndexAP());
UNDO_return_val_if_fail (bResult,false);
DONE();
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_InsertObject:
{
const PX_ChangeRecord_Object * pcrObject = static_cast<const PX_ChangeRecord_Object *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrObject->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound, false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux2 = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux2, false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bool bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
}
pf_Frag_Object * pfo = NULL;
if (!_insertObject(pf,fragOffset,pcrObject->getObjectType(),
pcrObject->getIndexAP(),pfo))
return false;
pcrObject->setObjectHandle(pfo);
UNDO_return_val_if_fail (pfo,false);
UT_sint32 newOffset = pcrObject->getPosition() - pfs->getPos() -1;
// need to set field pointers to values of new pointer
// as old field doesn't exist
pf = pfo->getNext();
while (pf&&pf->getType()==pf_Frag::PFT_Text&&
pf->getField())
{
pf_Frag_Text * pft =
static_cast<pf_Frag_Text *>(pf);
pft->setField(pfo->getField());
pf = pft->getNext();
}
DONE();
pcrObject->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
// don't update field until all of changes have been made
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_DeleteObject:
{
const PX_ChangeRecord_Object * pcrObject = static_cast<const PX_ChangeRecord_Object *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrObject->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound, false);
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_Object,false);
UNDO_return_val_if_fail (fragOffset == 0,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux2 = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux2,false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bool bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
}
UT_sint32 newOffset = pcrObject->getPosition() - pfs->getPos() -1; // was -2
if(newOffset < 0)
newOffset = 0;
pf_Frag_Object * pfo = static_cast<pf_Frag_Object *> (pf);
if((pfo->getObjectType() != PTO_Math) && ((pfo->getObjectType() != PTO_Embed)))
{
UNDO_return_val_if_fail (pfo->getIndexAP() == pcrObject->getIndexAP(),false);
}
_deleteObject(pfo,NULL,NULL);
DONE();
pcrObject->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_ChangeObject:
{
// ChangeSpan is it's own inverse.
const PX_ChangeRecord_ObjectChange * pcro = static_cast<const PX_ChangeRecord_ObjectChange *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcro->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound,false);
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_Object,false);
UNDO_return_val_if_fail (fragOffset == 0, false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux2 = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux2,false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bool bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
}
UT_sint32 newOffset = pcro->getPosition() - pfs->getPos() -1;
pf_Frag_Object * pfo = static_cast<pf_Frag_Object *> (pf);
_fmtChangeObject(pfo,pcro->getIndexAP(),NULL,NULL);
DONE();
pcro->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_InsertFmtMark:
{
const PX_ChangeRecord_FmtMark * pcrFM = static_cast<const PX_ChangeRecord_FmtMark *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrFM->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound, false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux2 = _getStruxFromFrag(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux2, false);
if(isEndFootnote(static_cast<pf_Frag *>(pfs)))
{
bool bFoundStrux = _getStruxFromFragSkip(static_cast<pf_Frag *>(pfs),&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
}
UT_sint32 newOffset = pcrFM->getPosition() - pfs->getPos() -1;
if (!_insertFmtMark(pf,fragOffset,pcrFM->getIndexAP()))
return false;
DONE();
pcrFM->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_DeleteFmtMark:
{
const PX_ChangeRecord_FmtMark * pcrFM = static_cast<const PX_ChangeRecord_FmtMark *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrFM->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound, false);
// we backup one because we have zero length and getFragFromPosition()
// returns the right-most thing with this document position.
if(pf->getType() != pf_Frag::PFT_FmtMark)
pf = pf->getPrev();
if(pf->getType()==pf_Frag::PFT_Strux)
{
if(pf->getNext() && pf->getNext()->getType() == pf_Frag::PFT_Strux)
{
DONE();
m_bDoingTheDo = false;
return true;
}
if(pf->getNext() && pf->getNext()->getType() == pf_Frag::PFT_Text)
{
pf = pf->getNext();
if(pf->getNext() && pf->getNext()->getType() == pf_Frag::PFT_FmtMark)
{
pf = pf->getNext();
}
}
}
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_FmtMark,false);
UNDO_return_val_if_fail (fragOffset == 0,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFragSkip(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
UT_sint32 newOffset = pcrFM->getPosition() - pfs->getPos() -1;
pf_Frag_FmtMark * pffm = static_cast<pf_Frag_FmtMark *> (pf);
// UNDO_return_val_if_fail (pffm->getIndexAP() == pcrFM->getIndexAP(),false);
_deleteFmtMark(pffm,NULL,NULL);
DONE();
pcrFM->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
m_bDoingTheDo = false;
return true;
case PX_ChangeRecord::PXT_ChangeFmtMark:
{
// ChangeFmt is it's own inverse.
const PX_ChangeRecord_FmtMarkChange * pcrFMC = static_cast<const PX_ChangeRecord_FmtMarkChange *>(pcr);
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(pcrFMC->getPosition(),&pf,&fragOffset);
UNDO_return_val_if_fail (bFound,false);
// we backup one because we have zero length and getFragFromPosition()
// returns the right-most thing with this document position.
if(pf->getType() != pf_Frag::PFT_FmtMark)
pf = pf->getPrev();
if(pf->getType()==pf_Frag::PFT_Strux)
{
if(pf->getNext() && pf->getNext()->getType() == pf_Frag::PFT_Strux)
{
DONE();
m_bDoingTheDo = false;
return true;
}
}
UNDO_return_val_if_fail (pf->getType() == pf_Frag::PFT_FmtMark,false);
UNDO_return_val_if_fail (fragOffset == 0,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFragSkip(pf,&pfs);
UNDO_return_val_if_fail (bFoundStrux,false);
UT_sint32 newOffset = pcrFMC->getPosition() - pfs->getPos() -1;
pf_Frag_FmtMark * pffm = static_cast<pf_Frag_FmtMark *> (pf);
_fmtChangeFmtMark(pffm,pcrFMC->getIndexAP(),NULL,NULL);
DONE();
m_bDoingTheDo = false;
pcrFMC->AdjustBlockOffset(newOffset);
m_pDocument->notifyListeners(pfs,pcr);
}
return true;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
case PX_ChangeRecord::PXT_ChangePoint:
DONE();
m_pDocument->notifyListeners(NULL, pcr);
m_bDoingTheDo = false;
return true;
default:
UT_ASSERT_HARMLESS(0);
m_bDoingTheDo = false;
return false;
}
}
bool pt_PieceTable::_realInsertStrux(PT_DocPosition dpos,
PTStruxType pts,
const gchar ** attributes,
const gchar ** properties,
pf_Frag_Strux ** ppfs_ret)
{
// insert a new structure fragment at the given document position.
// this function can only be called while editing the document.
// Also can specify an indexAP to be used for the frag rather
// than that obtained by default. Very useful for insertting
// Cells where you can immediately specify the cell position in
// a table. this function can only be called while editing the
// document.
UT_return_val_if_fail (m_pts==PTS_Editing, false);
// get the fragment at the doc postion containing the given
// document position.
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFoundFrag = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFoundFrag, false);
// get the strux containing the given position.
pf_Frag_Strux * pfsContainer = NULL;
bool bFoundContainer = _getStruxFromPosition(dpos,&pfsContainer);
UT_return_val_if_fail (bFoundContainer,false);
//
// Can only insert an endTOC into a TOC
//
if((pfsContainer->getStruxType() == PTX_SectionTOC) && (pts != PTX_EndTOC))
{
bFoundContainer = _getStruxFromPosition(pfsContainer->getPos(),&pfsContainer);
dpos--;
}
if(isEndFootnote(pfsContainer))
{
bFoundContainer = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
}
// if we are inserting something similar to the previous strux,
// we will clone the attributes/properties; we assume that the
// new strux should have the same AP as the one which preceeds us.
// This is generally true for inserting a paragraph -- it should
// inherit the style of the one we just broke.
PT_AttrPropIndex indexAP = 0;
if (pfsContainer->getStruxType() == pts)
{
// TODO paul, add code here to see if this strux has a "followed-by"
// TODO paul, property (or property in the style) and get the a/p
// TODO paul, from there rather than just taking the attr/prop
// TODO paul, of the previous strux.
indexAP = pfsContainer->getIndexAP();
}
//
// Look to see if we're in the middle of a hyperlink span now.
//
pf_Frag * pHype = _findPrevHyperlink(pf);
if(pHype != NULL && (pts != PTX_SectionFrame) // allow annotations in
// hyperlinks
&& (pts != PTX_SectionAnnotation)
&& (pts != PTX_EndAnnotation)) // frames are always placed
// at the end of blocks
// so we don't need this
{
//
// We have an open hyperlink! FIXME later we should allow this by terminating
// the hyperlink span just before this strux, then doing the insert strux.
// Instead for now we'll just disallow this insertStrux.
//
// This assert is to remind use to write the code to terminate
// the hyperlink.
//
pf_Frag * pEndHype = _findNextHyperlink(pf);
PT_DocPosition posEnd = 0;
if(pEndHype)
{
posEnd = pEndHype->getPos();
}
//
// OK now insert a new end of hyperlink at pf
//
insertObject(dpos, PTO_Hyperlink,NULL,NULL);
m_fragments.cleanFrags();
dpos++;
if(posEnd > 0)
{
//
// Now delete the old endhyperlink.
//
pf_Frag * pfEnd = NULL;
UT_uint32 newOff = 0;
posEnd++; // from the insert
UT_uint32 offset = 0;
_deleteObjectWithNotify(posEnd,
static_cast<pf_Frag_Object*>(pEndHype),
offset,1,pfsContainer,&pfEnd,&newOff,true);
}
m_fragments.cleanFrags();
bFoundFrag = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFoundFrag, false);
}
//
// If desired, merge in the specified attributes/properties. This
// enables cells to inherit the properties of the block from which
// they were inserted.
//
if (attributes || properties)
{
PT_AttrPropIndex pAPIold = indexAP;
bool bMerged = m_varset.mergeAP(PTC_AddFmt,pAPIold,attributes,properties,&indexAP,getDocument());
UT_UNUSED(bMerged);
UT_ASSERT_HARMLESS(bMerged);
}
pf_Frag_Strux * pfsNew = NULL;
if (!_createStrux(pts,indexAP,&pfsNew))
return false;
pfsNew->setXID(getXID());
// when inserting paragraphs, we try to remember the current
// span formatting active at the insertion point and add a
// FmtMark immediately after the block. this way, if the
// user keeps typing text, the FmtMark will control it's
// attr/prop -- if the user warps away and/or edits elsewhere
// and then comes back to this point (the FmtMark may or may
// not still be here) new text will either use the FmtMark or
// look to the right.
bool bNeedGlob = false;
PT_AttrPropIndex apFmtMark = 0;
if (pfsNew->getStruxType() == PTX_Block)
{
bNeedGlob = _computeFmtMarkForNewBlock(pfsNew,pf,fragOffset,&apFmtMark);
if (bNeedGlob)
beginMultiStepGlob();
// if we are leaving an empty block (are stealing all it's content) we should
// put a FmtMark in it to remember the active span fmt at the time.
// this lets things like hitting two consecutive CR's and then comming
// back to the first empty paragraph behave as expected.
// fixme sevior here
if ((pf->getType()==pf_Frag::PFT_Text) && (fragOffset == 0) &&
(pf->getPrev()!=NULL) && (pf->getPrev()->getType()==pf_Frag::PFT_Strux))
{
pf_Frag_Strux *pfsStrux = static_cast<pf_Frag_Strux *>(pf->getPrev());
if(pfsStrux->getStruxType() == PTX_Block)
{
_insertFmtMarkAfterBlockWithNotify(pfsContainer,dpos,apFmtMark);
}
}
}
//
// Look if we're placing an endcell in an empty block. If so,
// insert a format mark
//
if (pfsNew->getStruxType() == PTX_EndCell)
{
if((pf->getPrev()!=NULL) && (pf->getPrev()->getType()==pf_Frag::PFT_Strux))
{
pf_Frag_Strux *pfsStrux = static_cast<pf_Frag_Strux *>(pf->getPrev());
if(pfsStrux->getStruxType() == PTX_Block)
{
_insertFmtMarkAfterBlockWithNotify(pfsContainer,dpos,apFmtMark);
}
}
}
// insert this frag into the fragment list. Update the container strux as needed
_insertStrux(pf,fragOffset,pfsNew);
if (ppfs_ret)
*ppfs_ret = pfsNew;
// create a change record to describe the change, add
// it to the history, and let our listeners know about it.
if(pfsNew->getStruxType() == PTX_SectionFrame)
{
// Inserting a sectionFrame screws up dos. It goes just before the next
// block strux found.
dpos = pfsNew->getPrev()->getPos() + pfsNew->getPrev()->getLength();
}
PX_ChangeRecord_Strux * pcrs
= new PX_ChangeRecord_Strux(PX_ChangeRecord::PXT_InsertStrux,
dpos,indexAP,pfsNew->getXID(), pts);
UT_return_val_if_fail (pcrs,false);
// add record to history. we do not attempt to coalesce these.
m_history.addChangeRecord(pcrs);
m_pDocument->notifyListeners(pfsContainer,pfsNew,pcrs);
if (bNeedGlob)
{
UT_return_val_if_fail (!pfsNew->getNext() || pfsNew->getNext()->getType()!=pf_Frag::PFT_FmtMark, false);
_insertFmtMarkAfterBlockWithNotify(pfsNew,dpos+pfsNew->getLength(),apFmtMark);
endMultiStepGlob();
}
return true;
}
bool pt_PieceTable::insertStrux(PT_DocPosition dpos,
PTStruxType pts,
const gchar ** attributes,
const gchar ** properties,
pf_Frag_Strux ** ppfs_ret)
{
if(m_pDocument->isMarkRevisions())
{
// This is just like the previous method, except that in addition to calling
// _translateRevisionAttribute() we also need to set the attrs and props
// passed to us.
pf_Frag_Strux * pfsContainer = NULL;
bool bFoundContainer = _getStruxFromPosition(dpos,&pfsContainer); // the orig. strux
UT_return_val_if_fail(bFoundContainer, false);
if(isEndFootnote(pfsContainer))
{
bFoundContainer = _getStruxFromFragSkip(pfsContainer,&pfsContainer);
UT_return_val_if_fail(bFoundContainer, false);
}
PT_AttrPropIndex indexAP = 0;
if (pfsContainer->getStruxType() == pts)
{
indexAP = pfsContainer->getIndexAP();
}
PP_RevisionAttr Revisions(NULL);
const gchar ** ppRevAttrs = NULL;
const gchar ** ppRevProps = NULL;
_translateRevisionAttribute(Revisions, indexAP, PP_REVISION_ADDITION,
ppRevAttrs, ppRevProps, NULL, NULL);
// count original attributes and the revision-inherited attributes
// and add them to the revision attribute
UT_uint32 iAttrCount = 0;
for (; attributes && attributes[iAttrCount]; iAttrCount+=2){}
UT_uint32 iRevAttrCount = 0;
for (; ppRevAttrs && ppRevAttrs[iRevAttrCount]; iRevAttrCount+=2){}
const gchar ** ppRevAttrib = NULL;
if(iAttrCount + iRevAttrCount > 0)
{
ppRevAttrib = new const gchar * [iAttrCount + iRevAttrCount + 1];
UT_return_val_if_fail( ppRevAttrib, false );
UT_uint32 i = 0;
for (i = 0; i < iAttrCount; ++i)
{
ppRevAttrib[i] = attributes[i];
}
for (; i < iRevAttrCount + iAttrCount; ++i)
{
ppRevAttrib[i] = ppRevAttrs[i - iAttrCount];
}
ppRevAttrib[i] = NULL;
}
//return _realChangeStruxFmt(PTC_AddFmt, dpos, dpos + iLen, ppRevAttrib,NULL,pts);
bool bRet = _realInsertStrux(dpos,pts,ppRevAttrib,properties,ppfs_ret);
delete [] ppRevAttrib;
return bRet;
}
else
{
return _realInsertStrux(dpos,pts,attributes,properties,ppfs_ret);
}
}
