bool pp_TableAttrProp::createAP(UT_sint32 * pSubscript)
{
PP_AttrProp * pNew = new PP_AttrProp();
if (!pNew)
return false;
UT_sint32 u;
if (m_vecTable.addItem(pNew,&u) != 0)
{
delete pNew;
return false;
}
pNew->setIndex(u); //$HACK
if (pSubscript)
{
*pSubscript = u;
}
else
{
// create default empty AP
pNew->markReadOnly();
m_vecTableSorted.addItem(pNew, NULL);
}
return true;
}
/*! 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;
}
bool pp_TableAttrProp::createAP(const UT_GenericVector<const gchar*> * pVector,
UT_sint32 * pSubscript)
{
UT_sint32 subscript;
if (!createAP(&subscript))
return false;
PP_AttrProp * pAP = m_vecTable.getNthItem(subscript);
UT_return_val_if_fail (pAP, false);
if (!pAP->setAttributes(pVector))
return false;
pAP->markReadOnly();
m_vecTableSorted.addItemSorted(pAP,compareAP);
*pSubscript = subscript;
return true;
}
/*!
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;
}
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;
}