bool pt_PieceTable::_makeStrux(PTStruxType pts, const gchar ** attributes, pf_Frag_Strux * &pfs) { // create a new structure fragment at the current end of the document. // this function can only be called while loading the document. UT_return_val_if_fail (m_pts==PTS_Loading, false); // first, store the attributes and properties and get an index to them. PT_AttrPropIndex indexAP; if (!m_varset.storeAP(attributes,&indexAP)) return false; // // OK we've got to interogate attributes to determine what sort of section strux // we have. // if((pts == PTX_Section) && (attributes != NULL)) { const char * szStruxType = UT_getAttribute("type",attributes); if(szStruxType) { if(strcmp(szStruxType,"header") == 0 || strcmp(szStruxType,"footer") == 0 || strcmp(szStruxType,"header-even") == 0 || strcmp(szStruxType,"footer-even") == 0 || strcmp(szStruxType,"header-first") == 0 || strcmp(szStruxType,"footer-first") == 0 || strcmp(szStruxType,"header-last") == 0 || strcmp(szStruxType,"footer-last") == 0) { pts = PTX_SectionHdrFtr; } } } if (!_createStrux(pts,indexAP,&pfs)) return false; 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; }