/*! changes formatting of a strux while loading document */
bool pt_PieceTable::appendStruxFmt(pf_Frag_Strux * pfs, const gchar ** attributes)
{
// can only be used while loading the document
UT_return_val_if_fail (m_pts==PTS_Loading,false);
// Only a strux can be appended to an empty document
UT_return_val_if_fail (NULL != m_fragments.getFirst(), false);
if (!m_fragments.getFirst())
return false;
UT_return_val_if_fail ( pfs, false );
PT_AttrPropIndex currentAP = pfs->getIndexAP();
const PP_AttrProp * pOldAP;
if(!getAttrProp(currentAP,&pOldAP))
return false;
PP_AttrProp * pNewAP = pOldAP->cloneWithReplacements(attributes,NULL,true);
pNewAP->markReadOnly();
PT_AttrPropIndex indexAP;
if (!m_varset.addIfUniqueAP(pNewAP,&indexAP))
return false;
pfs->setIndexAP(indexAP);
return true;
}
/*!
retrieves AP associated with this layout, corretly processing any
revision information;
/return return value indicates whether the layout is hidden due to
current revision settings or not
*/
FPVisibility fl_ContainerLayout::getAP(const PP_AttrProp *& pAP)const
{
FL_DocLayout* pDL = getDocLayout();
UT_return_val_if_fail(pDL,FP_VISIBLE);
FV_View* pView = pDL->getView();
UT_return_val_if_fail(pView,FP_VISIBLE);
UT_uint32 iId = pView->getRevisionLevel();
bool bShow = pView->isShowRevisions();
bool bHiddenRevision = false;
getAttrProp(&pAP,NULL,bShow,iId,bHiddenRevision);
if(bHiddenRevision)
{
return FP_HIDDEN_REVISION;
}
else
{
return FP_VISIBLE;
}
}
/*!
Changes formating of the last strux of type pts
bSkipEmbededSections indicates whether when an end of an embeded section is
encountered, the entire section is to be skipped over, for example if the end of the
document looks like
<p><footnote><p></p></footnote>
when searching for <p> if bSkipEmbededSections == true the paragraph before <footnote>
will be modified
*/
bool pt_PieceTable::appendLastStruxFmt(PTStruxType pst, const gchar ** attributes, const gchar ** props,
bool bSkipEmbededSections)
{
// can only be used while loading the document
UT_return_val_if_fail (m_pts==PTS_Loading,false);
// Only a strux can be appended to an empty document
UT_return_val_if_fail (NULL != m_fragments.getFirst(), false);
if (!m_fragments.getFirst())
return false;
pf_Frag * pf = m_fragments.getLast();
UT_return_val_if_fail ( pf, false );
pf = _findLastStruxOfType(pf, pst, bSkipEmbededSections);
UT_return_val_if_fail( pf, false );
PT_AttrPropIndex currentAP = pf->getIndexAP();
const PP_AttrProp * pOldAP;
if(!getAttrProp(currentAP,&pOldAP))
return false;
PP_AttrProp * pNewAP = pOldAP->cloneWithReplacements(attributes,props,false);
pNewAP->markReadOnly();
PT_AttrPropIndex indexAP;
if (!m_varset.addIfUniqueAP(pNewAP,&indexAP))
return false;
pf->setIndexAP(indexAP);
return true;
}
/*!
A helper function which translates a revision attribute associated with fragment of type pts at
pos dpos into arrays of attributes and properties suitable for passing into formating and other funcitons.
Revisions -- an instance of an empty PP_RevisionsAttr (i.e., PP_RevisionsAttr(NULL);)
ppRevAttrib -- pointers to arrays of attributes and properties; the actual props and attribs are
ppRevProps found inside the Revisions variable, so the returned pointers are only valid
within the Revisions scope !!!.
ppAttrib -- pointers to any attributes/properties that are to be added to this revision, can be NULL
ppProps
*/
bool pt_PieceTable::_translateRevisionAttribute(PP_RevisionAttr & Revisions, PT_AttrPropIndex indexAP,
PP_RevisionType eType,
const gchar ** & ppRevAttrib,
const gchar ** & ppRevProps,
const gchar ** ppAttrib,
const gchar ** ppProps)
{
// foolproofing
ppRevAttrib = NULL;
ppRevProps = NULL;
UT_return_val_if_fail(m_pDocument->isMarkRevisions(),false );
const PP_AttrProp * pRevisedAP = NULL;
const PP_AttrProp * pAP = NULL;
getAttrProp(indexAP, &pAP);
const gchar name[] = "revision";
if(pAP)
{
const gchar * pRev = NULL;
if(pAP->getAttribute(name, pRev))
{
// OK, the previous strux had a revision attribute, which was copied into the new
// strux. This revision attribute can contain significant properties and attributes
// which need to be preserved (such as list ids). However, we want the revision
// attributes from the addition and fmt records to be transfered into the regular
// attrs and props
Revisions.setRevision(pRev);
Revisions.pruneForCumulativeResult(m_pDocument);
pRevisedAP = Revisions.getLastRevision();
// it is legal of pRevisedAP to be NULL here -- it simply means that the cumulative
// effect of the revisions attribute was nothing at all (i.e., the highest revision
// was a deletion)
if(pRevisedAP)
{
PP_RevisionAttr Revisions2(NULL);
// now add the revision attribute
Revisions2.addRevision(m_pDocument->getRevisionId(),eType,ppAttrib,ppProps);
const_cast<PP_AttrProp*>(pRevisedAP)->setAttribute(name, Revisions2.getXMLstring());
}
}
}
if(!pRevisedAP)
{
// there was either no pAP or no pRev, just add the current revision ...
// we need to create a rev. instance in Revisions
Revisions.addRevision(m_pDocument->getRevisionId(),eType,ppAttrib,ppProps);
pRevisedAP = Revisions.getLastRevision();
UT_return_val_if_fail( pRevisedAP, false );
// now set the revision attribute of the revision
const_cast<PP_AttrProp*>(pRevisedAP)->setAttribute(name, Revisions.getXMLstring());
}
ppRevAttrib = pRevisedAP->getAttributes();
ppRevProps = pRevisedAP->getProperties();
return true;
}
bool pt_PieceTable::_realInsertSpan(PT_DocPosition dpos,
const UT_UCSChar * p,
UT_uint32 length,
const gchar ** attributes,
const gchar ** properties,
fd_Field * pField,
bool bAddChangeRec)
{
// insert character data into the document at the given position.
UT_return_val_if_fail (m_pts==PTS_Editing, 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);
// append the text data to the end of the current buffer.
PT_BufIndex bi;
if (!m_varset.appendBuf(p,length,&bi))
return 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 (pfs,false);
if(pfs->getStruxType() == PTX_EndFrame)
{
bFoundStrux = _getStruxFromFragSkip((pf_Frag *) pfs,&pfs);
}
// we just did a getFragFromPosition() which gives us the
// the thing *starting* at that position. if we have a
// fragment boundary at that position, it's sort of arbitrary
// whether we treat this insert as a prepend to the one we just found
// or an append to the previous one (when it's a text frag).
// in the normal case, we want the Attr/Prop of a character
// insertion to take the AP of the thing to the immediate
// left (seems to be what MS-Word and MS-WordPad do). It's also
// useful when the user hits the BOLD button (without a)
// selection) and then starts typing -- ideally you'd like
// all of the text to have bold not just the first. therefore,
// we will see if we are on a text-text boundary and backup
// (and thus appending) to the previous.
bool bNeedGlob = false;
PT_AttrPropIndex indexAP = 0;
if ( (fragOffset==0) && (pf->getPrev()) )
{
bool bRightOfFmtMark = (pf->getPrev()->getType() == pf_Frag::PFT_FmtMark);
if (bRightOfFmtMark)
{
// if we're just to the right of a _FmtMark, we want to replace
// it with a _Text frag with the same attr/prop (we
// only used the _FmtMark to remember a toggle format
// before we had text for it).
pf_Frag_FmtMark * pfPrevFmtMark = static_cast<pf_Frag_FmtMark *>(pf->getPrev());
indexAP = pfPrevFmtMark->getIndexAP();
if (_lastUndoIsThisFmtMark(dpos))
{
// if the last thing in the undo history is the insertion of this
// _FmtMark, then let's remember the indexAP, do an undo, and then
// insert the text. this way the only thing remaining in the undo
// is the insertion of this text (with no globbing around it). then
// a user-undo will undo all of the coalesced text back to this point
// and leave the insertion point as if the original InsertFmtMark
// had never happened.
//
// we don't allow consecutive FmtMarks, but the undo may be a
// changeFmtMark and thus just re-change the mark frag rather
// than actually deleting it. so we loop here to get back to
// the original insertFmtMark (this is the case if the user hit
// BOLD then ITALIC then UNDERLINE then typed a character).
do { undoCmd(); } while (_lastUndoIsThisFmtMark(dpos));
}
else
{
// for some reason, something else has happened to the document
// since this _FmtMark was inserted (perhaps it was one that we
// inserted when we did a paragraph break and inserted several
// to remember the current inline formatting).
//
// here we have to do it the hard way and use a glob and an
// explicit deleteFmtMark. note that this messes up the undo
// coalescing. that is, if the user starts typing at this
// position and then hits UNDO, we will erase all of the typing
// except for the first character. the second UNDO, will erase
// the first character and restores the current FmtMark. if the
// user BACKSPACES instead of doing the second UNDO, both the
// first character and the FmtMark would be gone.
//
// TODO decide if we like this...
// NOTE this causes BUG#431.... :-)
bNeedGlob = true;
beginMultiStepGlob();
_deleteFmtMarkWithNotify(dpos,pfPrevFmtMark,pfs,&pf,&fragOffset);
}
// we now need to consider pf invalid, since the fragment list may have
// been coalesced as the FmtMarks were deleted. let's recompute them
// but with a few shortcuts.
bFound = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFound, false);
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);
xxx_UT_DEBUGMSG(("Got FragStrux at Pos %d \n",pfs->getPos()));
// with the FmtMark now gone, we make a minor adjustment so that we
// try to append text to the previous rather than prepend to the current.
// this makes us consistent with other places in the code.
if ( (fragOffset==0) && (pf->getPrev()) && (pf->getPrev()->getType() == pf_Frag::PFT_Text) && pf->getPrev()->getField()== NULL )
{
// append to the end of the previous frag rather than prepend to the current one.
pf = pf->getPrev();
fragOffset = pf->getLength();
}
}
else if (pf->getPrev()->getType() == pf_Frag::PFT_Text && pf->getPrev()->getField()==NULL)
{
pf_Frag_Text * pfPrevText = static_cast<pf_Frag_Text *>(pf->getPrev());
indexAP = pfPrevText->getIndexAP();
// append to the end of the previous frag rather than prepend to the current one.
pf = pf->getPrev();
fragOffset = pf->getLength();
}
else
{
indexAP = _chooseIndexAP(pf,fragOffset);
// PLAM: This is the list of field attrs that should not inherit
// PLAM: to the span following a field.
const gchar * pFieldAttrs[12];
pFieldAttrs[0] = "type"; pFieldAttrs[1] = NULL;
pFieldAttrs[2] = "param"; pFieldAttrs[3] = NULL;
pFieldAttrs[4] = "name"; pFieldAttrs[5] = NULL;
pFieldAttrs[6] = "endnote-id"; pFieldAttrs[7] = NULL;
pFieldAttrs[8] = NULL; pFieldAttrs[9] = NULL;
pFieldAttrs[10] = NULL; pFieldAttrs[11] = NULL;
const PP_AttrProp * pAP = NULL;
if (!getAttrProp(indexAP, &pAP))
return false;
if (pAP->areAnyOfTheseNamesPresent(pFieldAttrs, NULL))
{
// We do not want to inherit a char style from a field.
pFieldAttrs[8] = "style";
PP_AttrProp * pAPNew = pAP->cloneWithElimination(pFieldAttrs, NULL);
if (!pAPNew)
return false;
pAPNew->markReadOnly();
if (!m_varset.addIfUniqueAP(pAPNew, &indexAP))
return false;
}
}
}
else
{
// is existing fragment a field? If so do nothing
// Or should we display a message to the user?
if(pf->getField() != NULL)
{
return false;
}
indexAP = _chooseIndexAP(pf,fragOffset);
}
PT_BlockOffset blockOffset = _computeBlockOffset(pfs,pf) + fragOffset;
PX_ChangeRecord_Span * pcr = NULL;
if(attributes || properties)
{
// we need to add the attrs and props passed to us ...
PT_AttrPropIndex indexNewAP;
bool bMerged;
bMerged = m_varset.mergeAP(PTC_AddFmt,indexAP,attributes,properties,&indexNewAP,getDocument());
UT_ASSERT_HARMLESS( bMerged );
if(bMerged)
indexAP = indexNewAP;
}
if (!_insertSpan(pf,bi,fragOffset,length,indexAP,pField))
{
if (bNeedGlob)
endMultiStepGlob();
return false;
}
// note: because of coalescing, pf should be considered invalid at this point.
// create a change record, add it to the history, and notify
// anyone listening.
pcr = new PX_ChangeRecord_Span(PX_ChangeRecord::PXT_InsertSpan,
dpos,indexAP,bi,length,
blockOffset, pField);
UT_return_val_if_fail (pcr, false);
pcr->setDocument(m_pDocument);
bool canCoalesce = _canCoalesceInsertSpan(pcr);
if (!bAddChangeRec || (canCoalesce && !m_pDocument->isCoalescingMasked()))
{
if (canCoalesce)
m_history.coalesceHistory(pcr);
m_pDocument->notifyListeners(pfs,pcr);
delete pcr;
}
else
{
m_history.addChangeRecord(pcr);
m_pDocument->notifyListeners(pfs,pcr);
}
if (bNeedGlob)
endMultiStepGlob();
return true;
}