bool pt_PieceTable::_realInsertObject(PT_DocPosition dpos,
PTObjectType pto,
const gchar ** attributes,
const gchar ** properties, pf_Frag_Object ** ppfo)
{
UT_ASSERT_HARMLESS((pto == PTO_Math) || (pto == PTO_Embed) || (properties == NULL));
// dpos == 1 seems to be generally bad. - plam
// I'm curious about how often it happens. Please mail me if it does!
UT_ASSERT_HARMLESS(dpos > 1);
// TODO currently we force the caller to pass in the attr/prop.
// TODO this is probably a good thing for Images, but might be
// TODO bogus for things like Fields.
UT_return_val_if_fail (m_pts==PTS_Editing, false);
// store the attributes and properties and get an index to them.
PT_AttrPropIndex apiOld = 0, indexAP;
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFound,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote((pf_Frag *) pfs))
{
bFoundStrux = _getStruxFromFragSkip((pf_Frag *)pfs,&pfs);
}
UT_return_val_if_fail (bFoundStrux, false);
apiOld = _chooseIndexAP(pf,fragOffset);
if (!m_varset.mergeAP(PTC_AddFmt, apiOld, attributes, properties, &indexAP, m_pDocument))
return false;
// get the fragment at the given document position.
PT_BlockOffset blockOffset = _computeBlockOffset(pfs,pf) + fragOffset;
pf_Frag_Object * pfo = NULL;
if (!_insertObject(pf,fragOffset,pto,indexAP,pfo))
return false;
// create a change record, add it to the history, and notify
// anyone listening.
PX_ChangeRecord_Object * pcr
= new PX_ChangeRecord_Object(PX_ChangeRecord::PXT_InsertObject,
dpos,indexAP, pfo->getXID(), pto,blockOffset,
pfo->getField(),reinterpret_cast<PL_ObjectHandle>(pfo));
UT_return_val_if_fail (pcr,false);
m_history.addChangeRecord(pcr);
m_pDocument->notifyListeners(pfs,pcr);
*ppfo = pfo;
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::_realInsertObject(PT_DocPosition dpos,
PTObjectType pto,
const gchar ** attributes,
const gchar ** properties )
{
// dpos == 1 seems to be generally bad. - plam
// I'm curious about how often it happens. Please mail me if it does!
UT_ASSERT_HARMLESS(dpos > 1);
// TODO currently we force the caller to pass in the attr/prop.
// TODO this is probably a good thing for Images, but might be
// TODO bogus for things like Fields.
UT_return_val_if_fail (m_pts==PTS_Editing,false);
// store the attributes and properties and get an index to them.
UT_UTF8String sProps;
UT_sint32 i = 0;
sProps.clear();
if(properties != NULL)
{
for(i=0;(properties[i] != NULL);i+=2)
{
UT_DEBUGMSG(("Object: szProps = |%s| \n",properties[i]));
sProps +=properties[i];
sProps += ":";
sProps += properties[i+1];
if(properties[i+2] != NULL)
{
sProps += ";";
}
}
}
UT_GenericVector<const gchar*> Atts;
Atts.clear();
if(attributes)
{
for(i=0; attributes[i] != 0; i++)
{
Atts.addItem(attributes[i]);
}
}
if(sProps.size() > 0)
{
Atts.addItem("props");
Atts.addItem(sProps.utf8_str());
}
PT_AttrPropIndex indexAP;
if (!m_varset.storeAP(&Atts,&indexAP))
return false;
// get the fragment at the given document position.
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFound,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote((pf_Frag *) pfs))
{
bFoundStrux = _getStruxFromFragSkip((pf_Frag *)pfs,&pfs);
}
UT_return_val_if_fail (bFoundStrux,false);
PT_BlockOffset blockOffset = _computeBlockOffset(pfs,pf) + fragOffset;
pf_Frag_Object * pfo = NULL;
if (!_insertObject(pf,fragOffset,pto,indexAP,pfo))
return false;
// create a change record, add it to the history, and notify
// anyone listening.
PX_ChangeRecord_Object * pcr
= new PX_ChangeRecord_Object(PX_ChangeRecord::PXT_InsertObject,
dpos,indexAP,pfo->getXID(),pto,blockOffset,
pfo->getField(),reinterpret_cast<PL_ObjectHandle>(pfo));
UT_return_val_if_fail (pcr,false);
m_history.addChangeRecord(pcr);
m_pDocument->notifyListeners(pfs,pcr);
return true;
}
