void px_ChangeHistory::_printHistory(UT_sint32 iPrev) const
{
UT_sint32 i = 0;
UT_sint32 iStop = 0;
UT_sint32 iStart = 0;
if(iPrev>0)
{
iStop =m_undoPosition-1 - iPrev;
iStart = m_undoPosition-1;
}
else
{
iStart = m_vecChangeRecords.getItemCount() -1;
iStop = iStart + iPrev;
}
if(iStop <0)
iStop =0;
for(i=iStart; i>= iStop;i--)
{
PX_ChangeRecord * pcr = m_vecChangeRecords.getNthItem(i);
if(i != (m_undoPosition-m_iAdjustOffset-1))
{
UT_DEBUGMSG((" loc %d pos %d type %d isLocal %d \n",i,pcr->getPosition(),pcr->getType(),pcr->isFromThisDoc()));
}
else
{
UT_DEBUGMSG((" loc %d pos %d type %d isLocal %d <- Current undo record \n",i,pcr->getPosition(),pcr->getType(),pcr->isFromThisDoc()));
}
}
}
bool pt_PieceTable::_lastUndoIsThisFmtMark(PT_DocPosition dpos)
{
// look backwards thru the undo from this point and see
// if we have <InsertFmtMark>[<ChangeFmtMark>*]
PX_ChangeRecord * pcr;
UT_uint32 undoNdx = 0;
while (1)
{
bool bHaveUndo = m_history.getNthUndo(&pcr,undoNdx);
if (!bHaveUndo)
return false;
if (!pcr)
return false;
if (pcr->getPosition() != dpos)
return false;
switch (pcr->getType())
{
default:
return false;
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
case PX_ChangeRecord::PXT_ChangeFmtMark:
undoNdx++;
break;
}
}
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return false;
}
bool px_ChangeHistory::didRedo(void)
{
xxx_UT_DEBUGMSG((" Doing didRedo void in PT undopos %d savePos pos %d iAdjustOffset %d \n",m_undoPosition,m_savePosition,m_iAdjustOffset));
if (m_bOverlap)
{
clearHistory();
return false;
}
if ((m_undoPosition - m_iAdjustOffset) >= m_vecChangeRecords.getItemCount())
return false;
PX_ChangeRecord * pcr = m_vecChangeRecords.getNthItem(m_undoPosition - m_iAdjustOffset);
// leave records from external documents in place so we can correct
if (pcr && !pcr->isFromThisDoc() && (m_iAdjustOffset == 0))
return false;
if (m_iAdjustOffset > 0)
{
m_iAdjustOffset--;
xxx_UT_DEBUGMSG(("AdjustOffset decremented -3 redo %d ", m_iAdjustOffset));
}
else
{
xxx_UT_DEBUGMSG(("Undo Position incremented in redo \n"));
m_undoPosition++;
}
if (pcr && !pcr->getPersistance())
m_savePosition++;
return true;
}
bool px_ChangeHistory::didUndo(void)
{
xxx_UT_DEBUGMSG((" Doing Undo void in PT undopos %d savePos pos %d \n",m_undoPosition,m_savePosition));
if (m_bOverlap)
{
clearHistory();
return false;
}
UT_return_val_if_fail(m_undoPosition > 0, false);
UT_return_val_if_fail(m_undoPosition - m_iAdjustOffset > m_iMinUndo, false);
PX_ChangeRecord * pcr = m_vecChangeRecords.getNthItem(m_undoPosition-m_iAdjustOffset-1);
UT_return_val_if_fail(pcr && pcr->isFromThisDoc(), false);
if (m_iAdjustOffset == 0)
m_undoPosition--;
pcr = m_vecChangeRecords.getNthItem(m_undoPosition-m_iAdjustOffset);
if (pcr && !pcr->getPersistance())
{
UT_return_val_if_fail(m_savePosition > 0,false);
m_savePosition--;
}
return true;
}
/*!
Create reverse change record of this one
\return Reverse change record
*/
PX_ChangeRecord * PX_ChangeRecord::reverse(void) const
{
PX_ChangeRecord * pcr = new PX_ChangeRecord(getRevType(),
m_position,
m_indexAP,
m_iXID);
UT_ASSERT_HARMLESS(pcr);
pcr->setAdjustment( m_iAdjust);
return pcr;
}
/*!
Dump information in the change history
\param fp File descripter used for output
*/
void
px_ChangeHistory::__dump(FILE * fp) const
{
// dump the change record history
fprintf(fp," ChangeHistory: undo pos %d\n",(int)m_undoPosition);
fprintf(fp," ChangeHistory: save pos %d\n",(int)m_savePosition);
fprintf(fp," ChangeHistory: Change records:\n");
UT_uint32 kLimit = m_vecChangeRecords.getItemCount();
UT_uint32 k;
for (k = 0; k < kLimit; k++)
{
PX_ChangeRecord* pcrTemp =
(PX_ChangeRecord *) m_vecChangeRecords.getNthItem(k);
pcrTemp->__dump(fp);
}
}
bool pt_PieceTable::redoCmd(void)
{
// do a user-atomic redo.
// return false if we can't.
m_history.setScanningUndoGLOB(false);
PX_ChangeRecord * pcr;
if (!m_history.getRedo(&pcr))
return false;
UT_return_val_if_fail (pcr,false);
// the first undo record tells us whether it is
// a simple change or a glob. there are two kinds
// of globs: a multi-step change (display atomic)
// like deleting a selection that spans a paragraph
// break; and a user-atomic glob like doing a search
// and replace over the whole document.
//
// for a simple change, we just do it and return.
// for a glob, we loop until we do the
// corresponding other end.
UT_Byte flagsRevFirst = GETREVGLOBFLAGS(pcr);
if(m_fragments.areFragsDirty())
{
m_fragments.cleanFrags();
}
while (m_history.getRedo(&pcr))
{
pcr->setCRNumber(); // update the CRNumber
if (!_doTheDo(pcr, false))
return false;
if (flagsRevFirst == GETGLOBFLAGS(pcr)) // stop when we have a matching end
break;
}
m_history.setScanningUndoGLOB(false);
return true;
}
void px_ChangeHistory::coalesceHistory(const PX_ChangeRecord * pcr)
{
// coalesce this record with the current undo record.
UT_sint32 iAdj = m_iAdjustOffset;
PX_ChangeRecord * pcrUndo = m_vecChangeRecords.getNthItem(m_undoPosition-1);
UT_return_if_fail (pcrUndo);
UT_return_if_fail (pcr->getType() == pcrUndo->getType());
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
case PX_ChangeRecord::PXT_DeleteSpan:
{
const PX_ChangeRecord_Span * pcrSpan = static_cast<const PX_ChangeRecord_Span *>(pcr);
PX_ChangeRecord_Span * pcrSpanUndo = static_cast<PX_ChangeRecord_Span *>(pcrUndo);
if(pcr->isFromThisDoc())
{
_invalidateRedo();
m_iAdjustOffset = 0;
}
else if(iAdj > 0)
{
m_iAdjustOffset = iAdj - 1;
xxx_UT_DEBUGMSG(("AdjustOffset decremented - 3 %d ", m_iAdjustOffset));
}
pcrSpanUndo->coalesce(pcrSpan);
}
return;
default:
UT_ASSERT_HARMLESS(0);
return;
}
}
bool pt_PieceTable::_canCoalesceInsertSpan(PX_ChangeRecord_Span * pcrSpan) const
{
// see if this record can be coalesced with the most recent undo record.
UT_return_val_if_fail (pcrSpan->getType() == PX_ChangeRecord::PXT_InsertSpan, false);
PX_ChangeRecord * pcrUndo;
if (!m_history.getUndo(&pcrUndo,true))
return false;
if (pcrSpan->getType() != pcrUndo->getType())
return false;
if (pcrSpan->getIndexAP() != pcrUndo->getIndexAP())
return false;
PX_ChangeRecord_Span * pcrUndoSpan = static_cast<PX_ChangeRecord_Span *>(pcrUndo);
if((pcrUndoSpan->isFromThisDoc() != pcrSpan->isFromThisDoc()))
return false;
UT_uint32 lengthUndo = pcrUndoSpan->getLength();
if ((pcrUndo->getPosition() + lengthUndo) != pcrSpan->getPosition())
return false;
PT_BufIndex biUndo = pcrUndoSpan->getBufIndex();
PT_BufIndex biSpan = pcrSpan->getBufIndex();
if (m_varset.getBufIndex(biUndo,lengthUndo) != biSpan)
return false;
// "Coalescing not allowed across a save." - PL
// So, if we're clean, make us dirty.
if (!m_history.isDirty())
return false;
return true;
}
void px_ChangeHistory::_invalidateRedo(void)
{
UT_sint32 kLimit = m_vecChangeRecords.getItemCount();
UT_return_if_fail (m_undoPosition <= kLimit);
UT_sint32 i = m_undoPosition - m_iAdjustOffset;
for (UT_sint32 k = m_undoPosition - m_iAdjustOffset; k < kLimit; k++)
{
PX_ChangeRecord * pcrTemp = m_vecChangeRecords.getNthItem(i);
if (!pcrTemp)
break;
if (pcrTemp->isFromThisDoc())
{
delete pcrTemp;
m_vecChangeRecords.deleteNthItem(i);
}
else
i++;
}
m_undoPosition = m_vecChangeRecords.getItemCount();
if (m_savePosition > m_undoPosition)
m_savePosition = -1;
m_iAdjustOffset = 0;
}
/*!
* This method returns the nth element off the undo stack.
* 0 returns the top element
* 1 returns the next element
* etc
* The result is not adjusted for undo's in the presence of remote
* changerecords and no attempt is made to see if an undo is legal
* (ie doesn't overlap with a later remote CR) or not.
*/
bool px_ChangeHistory::getNthUndo(PX_ChangeRecord ** ppcr, UT_uint32 undoNdx) const
{
UT_sint32 iAdjust = static_cast<UT_sint32>(m_undoPosition) - m_iAdjustOffset;
UT_sint32 iAdjIdx = static_cast<UT_sint32>(undoNdx);
bool bGotOne = false;
while(!bGotOne)
{
if (static_cast<UT_sint32>(iAdjust - iAdjIdx -1) <= static_cast<UT_sint32>(m_iMinUndo))
return false;
PX_ChangeRecord * pcr = m_vecChangeRecords.getNthItem(iAdjust-iAdjIdx-1);
UT_return_val_if_fail(pcr, false);
if(pcr->isFromThisDoc())
{
*ppcr = pcr;
return true;
}
else
{
iAdjust--;
}
}
return false;
}
bool pt_PieceTable::undoCmd(void)
{
// do a user-atomic undo.
// return false if we can't.
PX_ChangeRecord * pcr;
if (!m_history.getUndo(&pcr))
return false;
UT_return_val_if_fail (pcr,false);
// the first undo record tells us whether it is
// a simple change or a glob. there are two kinds
// of globs: a multi-step change (display atomic)
// like deleting a selection that spans a paragraph
// break; and a user-atomic glob like doing a search
// and replace over the whole document.
//
// for a simple change, we just do it and return.
// for a glob, we loop until we do the
// corresponding other end.
m_history.setScanningUndoGLOB(false);
UT_Byte flagsFirst = GETGLOBFLAGS(pcr);
if(m_fragments.areFragsDirty())
{
m_fragments.cleanFrags();
}
do
{
PX_ChangeRecord * pcrRev = pcr->reverse(); // we must delete this.
pcrRev->setAdjustment(pcr->getAdjustment());
pcrRev->setDocument(getDocument());
pcrRev->setCRNumber();
UT_return_val_if_fail (pcrRev,false);
UT_Byte flagsRev = GETGLOBFLAGS(pcrRev);
bool bResult = _doTheDo(pcrRev, true);
delete pcrRev;
if (!bResult)
return false;
if (flagsRev == flagsFirst) // stop when we have a matching end
break;
} while (m_history.getUndo(&pcr));
m_history.setScanningUndoGLOB(false);
m_pDocument->updateFields();
return true;
}
bool px_ChangeHistory::getRedo(PX_ChangeRecord ** ppcr) const
{
if ((m_iAdjustOffset == 0) && (m_undoPosition >= m_vecChangeRecords.getItemCount()))
return false;
if (m_bOverlap)
return false;
UT_sint32 iRedoPos = m_undoPosition-m_iAdjustOffset;
if(iRedoPos <0)
return false;
PX_ChangeRecord * pcr = m_vecChangeRecords.getNthItem(iRedoPos);
UT_return_val_if_fail(pcr, false);
// leave records from external documents in place so we can correct
bool bIncrementAdjust = false;
if (pcr->isFromThisDoc())
{
*ppcr = pcr;
if (m_iAdjustOffset == 0)
{
return true;
}
else
{
bIncrementAdjust = true;
m_iAdjustOffset--;
}
}
while (pcr && !pcr->isFromThisDoc() && (m_iAdjustOffset > 0))
{
pcr = m_vecChangeRecords.getNthItem(iRedoPos);
m_iAdjustOffset--;
iRedoPos++;
bIncrementAdjust = true;
xxx_UT_DEBUGMSG(("AdjustOffset decremented -1 %d ", m_iAdjustOffset));
}
if (pcr && bIncrementAdjust)
{
PX_ChangeRecord * pcrOrig = pcr;
pcr->setAdjustment(0);
PT_DocPosition low,high;
getCRRange(pcr,low,high);
PT_DocPosition pos = pcr->getPosition();
UT_sint32 iAdj = 0;
for (UT_sint32 i = m_iAdjustOffset; i >= 1;i--)
{
pcr = m_vecChangeRecords.getNthItem(m_undoPosition-i);
if (!pcr->isFromThisDoc())
{
UT_sint32 iCur = getDoc()->getAdjustmentForCR(pcr);
if (pcr->getPosition() <= static_cast<PT_DocPosition>(static_cast<UT_sint32>(pos) + iAdj + iCur))
{
iAdj += iCur;
low += iCur;
high += iCur;
}
PT_DocPosition p1,p2;
getCRRange(pcr,p1,p2);
bool bZero = (p1 == p2);
if(bZero)
m_bOverlap = doesOverlap(pcr,low+1,high);
else
m_bOverlap = doesOverlap(pcr,low,high);
if (m_bOverlap)
{
*ppcr = NULL;
return false;
}
}
}
pcr = pcrOrig;
pcr->setAdjustment(iAdj);
xxx_UT_DEBUGMSG(("Redo Adjustment set to %d \n",iAdj));
}
if (pcr && pcr->isFromThisDoc())
{
*ppcr = pcr;
if(bIncrementAdjust)
{
m_iAdjustOffset += 1; // for didRedo
xxx_UT_DEBUGMSG(("AdjustOffset incremented -2 %d \n", m_iAdjustOffset));
}
return true;
}
*ppcr = NULL;
return false;
}
bool px_ChangeHistory::getUndo(PX_ChangeRecord ** ppcr, bool bStatic) const
{
if (m_bOverlap)
{
*ppcr = NULL;
return false;
}
UT_sint32 iGLOB = 0;
bool bGotOne = false;
PX_ChangeRecord * pcr = NULL;
PX_ChangeRecord * pcrFirst = NULL;
bool bCorrect = false;
UT_sint32 iAdjust = m_iAdjustOffset;
UT_sint32 iLoop = 0;
// _printHistory(50);
while (!bGotOne)
{
if ((m_undoPosition - m_iAdjustOffset -iLoop) <= m_iMinUndo)
{
if (bStatic)
m_iAdjustOffset = iAdjust;
return false;
}
pcr = m_vecChangeRecords.getNthItem(m_undoPosition-m_iAdjustOffset-1-iLoop);
UT_return_val_if_fail(pcr, false); // just bail out, everything seems wrong
//
// Do Adjustments for blocks of remote CR's. Scan through local globs
// to check for remote CR's which overlap it.
//
if((iGLOB== 0) && !pcr->isFromThisDoc())
{
bCorrect = true;
m_iAdjustOffset++;
UT_DEBUGMSG(("Doing undo iAdjust incremented to %d \n",m_iAdjustOffset));
}
else if ((iGLOB==0) && (pcr->getType() == PX_ChangeRecord::PXT_GlobMarker) && pcr->isFromThisDoc() && !isScanningUndoGLOB() && (m_iAdjustOffset > 0))
{
iGLOB++;
pcrFirst = pcr;
iLoop++;
setScanningUndoGLOB(true);
}
else if((iGLOB>0) && (pcr->getType() == PX_ChangeRecord::PXT_GlobMarker) && pcr->isFromThisDoc())
{
if(isScanningUndoGLOB())
pcr = pcrFirst;
bGotOne = true;
}
else if(iGLOB == 0)
{
bGotOne = true;
if(m_iAdjustOffset > 0)
bCorrect = true;
}
//
// we're here if we've started scanning through a glob in the local
// document to see if it overlaps a later remote change.
//
else
{
PT_DocPosition low, high;
PT_DocPosition lowWork = 0;
PT_DocPosition highWork;
UT_sint32 iAccumOffset = 0;
getCRRange(pcr, low, high);
for (UT_sint32 i = 0; i<m_iAdjustOffset;i++)
{
PX_ChangeRecord *pcrTmp = m_vecChangeRecords.getNthItem(m_undoPosition-i-1);
if (!pcrTmp->isFromThisDoc())
{
UT_sint32 iCur = getDoc()->getAdjustmentForCR(pcrTmp);
if(pcrTmp->getPosition() <= lowWork+iCur)
{
iAccumOffset += iCur;
}
lowWork = low + iAccumOffset;
highWork = high + iAccumOffset;
PT_DocPosition p1,p2;
getCRRange(pcrTmp,p1,p2);
bool bZero = (p1 == p2);
if(bZero)
lowWork++;
if (doesOverlap(pcrTmp,lowWork,highWork))
{
*ppcr = NULL;
//
// OK now we have to invalidate the undo stack
// to just before the first pcr we pulled off.
//
if(m_undoPosition-iAdjust > 0)
{
m_iMinUndo = m_undoPosition-iAdjust-1;
}
else
{
m_iMinUndo = 0;
}
m_iAdjustOffset = iAdjust;
m_iAdjustOffset++;
return false;
}
}
}
iLoop++;
}
}
PX_ChangeRecord * pcrOrig = pcr;
if (bCorrect)
{
pcr->setAdjustment(0);
PT_DocPosition pos = pcr->getPosition();
UT_sint32 iAdj = 0;
UT_sint32 iCurrAdj = 0;
PT_DocPosition low, high;
getCRRange(pcr, low, high);
for (UT_sint32 i = m_iAdjustOffset-1; i>=0;i--)
{
pcr = m_vecChangeRecords.getNthItem(m_undoPosition-i-1);
if (!pcr->isFromThisDoc())
{
iCurrAdj = getDoc()->getAdjustmentForCR(pcr);
if(pcr->getPosition() <= static_cast<PT_DocPosition>(static_cast<UT_sint32>(pos) + iAdj + iCurrAdj))
{
iAdj += iCurrAdj;
low += iCurrAdj;
high += iCurrAdj;
}
PT_DocPosition p1,p2;
getCRRange(pcr,p1,p2);
bool bZero = (p1 == p2);
PT_DocPosition low1 = low;
if(bZero)
low1++;
if (doesOverlap(pcr,low1,high))
{
UT_DEBUGMSG(("CR Type %d adj pos %d Overlaps found with CR pos %d \n",pcrOrig->getType(),pcrOrig->getPosition()+iAdj,pcr->getPosition()));
UT_DEBUGMSG((" Orig Adj low %d high %d \n",low,high));
*ppcr = NULL;
m_iMinUndo = m_undoPosition-m_iAdjustOffset-1;
return false;
}
}
}
pcrOrig->setAdjustment(iAdj);
m_iAdjustOffset++;
}
UT_ASSERT(pcrOrig->isFromThisDoc());
*ppcr = pcrOrig;
if(bStatic)
m_iAdjustOffset = iAdjust;
return true;
}