void CTable::Get(CLineVector & results)
{
results.clear();
results.reserve(m_rows.size() - 2);
for(CLineVector::iterator itr = m_rows.begin(); itr != m_rows.end();)
{
CLineVector::iterator this_itr = itr++;
if (this_itr != m_rows.begin() && itr != m_rows.end())
results.push_back(*this_itr);
}
}
void SetCharTypes(CLine & line, const CLineVector & lineVector)
{
int charPos = 0;
for(CLineVector::const_iterator itr = lineVector.begin(); itr != lineVector.end(); ++itr)
{
switch(itr->GetType())
{
case CLine::TYPE_DELETED:
case CLine::TYPE_SIMILAR:
case CLine::TYPE_MOVED:
line.SetCharType(charPos, CLine::TYPE_SIMILAR);
break;
}
charPos++;
}
}
void AppendTable(CLineVector & lineVector, const CTable & table, CLine::TYPE type)
{
for (size_t i = 1; i < table.size() - 1; ++i)
{
CLine line = table[i];
line.SetType(type);
lineVector.push_back(line);
}
}
void AppendBlankLines(CLineVector & lineVector, const CTable & otherTable, CLine::TYPE type)
{
for (size_t i = 1; i < otherTable.size() - 1; ++i)
{
CLine line;
if (!IsDummyLine(line))
{
line.SetType(otherTable[i].GetType() == CLine::TYPE_MOVED ? CLine::TYPE_MATCH : type);
lineVector.push_back(line);
}
}
}
void CAnchors::GetResults(CLineVector & baseResult, CLineVector & compResult)
{
for(size_t i = 1; i < m_baseTable.size() - 1; ++i)
{
CLine line = m_baseTable[i];
if (AnchorsBaseContains(i))
line.SetType(CLine::TYPE_MATCH);
else
line.SetType(CLine::TYPE_SIMILAR);
baseResult.push_back(line);
}
for(size_t i = 1; i < m_compTable.size() - 1; ++i)
{
CLine line = m_compTable[i];
if (AnchorsCompContains(i))
line.SetType(CLine::TYPE_MATCH);
else
line.SetType(CLine::TYPE_SIMILAR);
compResult.push_back(line);
}
}
void CDiffView::SetText(const std::_tstring &lhs, const std::_tstring &rhs)
{
CLineVector baseResult;
CLineVector compResult;
TextCompare(lhs, rhs, baseResult, compResult);
m_lhs.SetReadOnly(false);
m_lhs.ClearAll();
m_lhs.SetReadOnly(true);
m_lhs.SetProperty(_T("fold"), _T("0"));
m_lhs.SetMarginWidthN(2, 0);
//m_lhs.HideSelection(true);
m_lhs.IndicSetStyle(1, INDIC_SQUIGGLE);
m_lhs.IndicSetFore(1, 0x0000ff);
m_lhs.SetLineState(0, 0);
m_lhs.MarkerSetFore(MARKER_ADDED, 0x007f00);
m_lhs.MarkerSetFore(MARKER_MODIFIED, 0x7f0000);
m_lhs.MarkerSetFore(MARKER_DELETED, 0x00007f);
m_lhs.MarkerSetAlpha(MARKER_ADDED, 200);
m_lhs.MarkerSetAlpha(MARKER_MODIFIED, 200);
m_lhs.MarkerSetAlpha(MARKER_DELETED, 200);
m_rhs.SetReadOnly(false);
m_rhs.ClearAll();
m_rhs.SetReadOnly(true);
m_rhs.SetProperty(_T("fold"), _T("0"));
m_rhs.SetMarginWidthN(2, 0);
//m_rhs.HideSelection(true);
m_rhs.IndicSetStyle(1, INDIC_SQUIGGLE);
m_rhs.IndicSetFore(1, 0x0000ff);
m_rhs.SetLineState(0, 0);
m_rhs.MarkerSetFore(MARKER_ADDED, 0x007f00);
m_rhs.MarkerSetFore(MARKER_MODIFIED, 0x7f0000);
m_rhs.MarkerSetFore(MARKER_DELETED, 0x00007f);
m_rhs.MarkerSetAlpha(MARKER_ADDED, 200);
m_rhs.MarkerSetAlpha(MARKER_MODIFIED, 200);
m_rhs.MarkerSetAlpha(MARKER_DELETED, 200);
std::_tstring clhs;
for(CLineVector::iterator itr = baseResult.begin(); itr != baseResult.end(); ++itr)
{
//clhs += itr->ststus;
clhs += itr->GetText();
//clhs += _T("\n");
}
std::_tstring crhs;
for(CLineVector::iterator itr = compResult.begin(); itr != compResult.end(); ++itr)
{
//crhs += itr->ststus;
crhs += itr->GetText();
//crhs += _T("\n");
}
m_lhs.SetReadOnly(false);
m_lhs.SetText(clhs.c_str());
int line = 0;
ATLASSERT(baseResult.size() == compResult.size());
for(CLineVector::iterator itr = baseResult.begin(); itr != baseResult.end(); ++itr)
{
int startPos = m_lhs.PositionFromLine(line);
//int lineLen = m_lhs.PositionFromLine(line + 1) - startPos;
switch(itr->GetType())
{
case CLine::TYPE_ADDED:
m_lhs.SetLineState(line, SCE_ECL_ADDED);
break;
case CLine::TYPE_UNKNOWN:
break;
case CLine::TYPE_DELETED:
//m_lhs.SetLineState(line, SCE_ECL_DELETED);
m_lhs.MarkerAdd(line, MARKER_DELETED);
break;
case CLine::TYPE_MOVED:
//m_lhs.SetLineState(line, SCE_ECL_MOVED);
//m_rhs.SetLineState(line, 0);
break;
case CLine::TYPE_SIMILAR:
//m_lhs.SetLineState(line, SCE_ECL_CHANGED);
m_lhs.MarkerAdd(line, MARKER_MODIFIED);
for(int i = 0; i < itr->GetLength(); ++i)
{
if (itr->GetCharType(i) == CLine::TYPE_SIMILAR)
{
m_lhs.SetIndicatorCurrent(INDIC_SQUIGGLE);
m_lhs.IndicatorFillRange(startPos + i, 1);
}
}
break;
}
++line;
}
m_lhs.SetReadOnly(true);
m_rhs.SetReadOnly(false);
m_rhs.SetText(crhs.c_str());
line = 0;
for(CLineVector::iterator itr = compResult.begin(); itr != compResult.end(); ++itr)
{
int startPos = m_rhs.PositionFromLine(line);
switch(itr->GetType())
{
case CLine::TYPE_ADDED:
//m_rhs.SetLineState(line, SCE_ECL_ADDED);
m_rhs.MarkerAdd(line, MARKER_ADDED);
break;
case CLine::TYPE_UNKNOWN:
break;
case CLine::TYPE_DELETED:
m_rhs.SetLineState(line, SCE_ECL_DELETED);
break;
case CLine::TYPE_MOVED:
//m_rhs.SetLineState(line, SCE_ECL_MOVED);
//m_lhs.SetLineState(line, 0);
break;
case CLine::TYPE_SIMILAR:
//m_rhs.SetLineState(line, SCE_ECL_CHANGED);
m_rhs.MarkerAdd(line, MARKER_MODIFIED);
for(int i = 0; i < itr->GetLength(); ++i)
{
if (itr->GetCharType(i) == CLine::TYPE_SIMILAR)
{
m_rhs.SetIndicatorCurrent(1);
m_rhs.IndicatorFillRange(startPos + i, 1);
}
}
break;
}
++line;
}
m_rhs.SetReadOnly(true);
}
void CAnchors::GetPaddedResults(CLineVector & baseResult, CLineVector & compResult) const
{
unsigned int matchCount = GetMatchCount();
unsigned int gapCount = GetGapCount();
unsigned int matchPos = 0;
unsigned int gapPos = 0;
while(matchPos < matchCount)
{
{
CTable baseTable, compTable;
GetMatch(matchPos, baseTable, compTable);
for (size_t i = 1; i < baseTable.size() - 1; ++i)
{
CLine baseLine = baseTable[i];
CLine compLine = compTable[i];
CLine::TYPE type = baseLine.Equals(compLine, 0) ? CLine::TYPE_MATCH : CLine::TYPE_SIMILAR;
if (type == CLine::TYPE_SIMILAR)
{
CTable baseLineTable(baseLine.GetText(), true);
CTable compLineTable(compLine.GetText(), true);
CAnchors lineAnchors(baseLineTable, compLineTable, 0);
CLineVector baseLineVector, compLineVector;
lineAnchors.GetResults(baseLineVector, compLineVector);
SetCharTypes(baseLine, baseLineVector);
SetCharTypes(compLine, compLineVector);
}
baseLine.SetType(type);
compLine.SetType(type);
baseResult.push_back(baseLine);
compResult.push_back(compLine);
}
ATLASSERT(baseResult.size() == compResult.size());
++matchPos;
}
if (gapPos < gapCount)
{
CTable baseTable, compTable;
GetGap(gapPos, baseTable, compTable);
if (baseTable.size() <= 2) //Added lines
{
ATLASSERT(compTable.size() > 2);
AppendBlankLines(baseResult, compTable, CLine::TYPE_ADDED);
AppendTable(compResult, compTable, CLine::TYPE_ADDED);
}
else if (compTable.size() <= 2) //Deleted lines
{
ATLASSERT(baseTable.size() > 2);
AppendTable(baseResult, baseTable, CLine::TYPE_DELETED);
AppendBlankLines(compResult, baseTable, CLine::TYPE_DELETED);
}
else if (m_accuracy > 35) // Don't recurse too much.
{
AppendTable(baseResult, baseTable, CLine::TYPE_DELETED);
AppendBlankLines(compResult, baseTable, CLine::TYPE_DELETED);
AppendBlankLines(baseResult, compTable, CLine::TYPE_ADDED);
AppendTable(compResult, compTable, CLine::TYPE_ADDED);
}
else
{
CAnchors gapAnchors(baseTable, compTable, m_accuracy + 5);
gapAnchors.GetPaddedResults(baseResult, compResult);
}
ATLASSERT(baseResult.size() == compResult.size());
++gapPos;
}
}
}
