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;
}
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;
}
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 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;
}