WideString CPDF_FileSpec::GetFileName() const {
WideString csFileName;
if (const CPDF_Dictionary* pDict = m_pObj->AsDictionary()) {
csFileName = pDict->GetUnicodeTextFor("UF");
if (csFileName.IsEmpty()) {
csFileName = WideString::FromDefANSI(
pDict->GetStringFor(pdfium::stream::kF).AsStringView());
}
if (pDict->GetStringFor("FS") == "URL")
return csFileName;
if (csFileName.IsEmpty()) {
constexpr const char* keys[] = {"DOS", "Mac", "Unix"};
for (const auto* key : keys) {
if (pDict->KeyExist(key)) {
csFileName =
WideString::FromDefANSI(pDict->GetStringFor(key).AsStringView());
break;
}
}
}
} else if (m_pObj->IsString()) {
csFileName = WideString::FromDefANSI(m_pObj->GetString().AsStringView());
}
return DecodeFileName(csFileName);
}
WideString CPDF_TextPage::GetTextByPredicate(
const std::function<bool(const PAGECHAR_INFO&)>& predicate) const {
if (!m_bIsParsed)
return WideString();
float posy = 0;
bool IsContainPreChar = false;
bool IsAddLineFeed = false;
WideString strText;
for (const auto& charinfo : m_CharList) {
if (predicate(charinfo)) {
if (fabs(posy - charinfo.m_Origin.y) > 0 && !IsContainPreChar &&
IsAddLineFeed) {
posy = charinfo.m_Origin.y;
if (!strText.IsEmpty())
strText += L"\r\n";
}
IsContainPreChar = true;
IsAddLineFeed = false;
if (charinfo.m_Unicode)
strText += charinfo.m_Unicode;
} else if (charinfo.m_Unicode == L' ') {
if (IsContainPreChar) {
strText += L' ';
IsContainPreChar = false;
IsAddLineFeed = false;
}
} else {
IsContainPreChar = false;
IsAddLineFeed = true;
}
}
return strText;
}
WideString CPDF_CIDFont::UnicodeFromCharCode(uint32_t charcode) const {
WideString str = CPDF_Font::UnicodeFromCharCode(charcode);
if (!str.IsEmpty())
return str;
wchar_t ret = GetUnicodeFromCharCode(charcode);
return ret ? ret : WideString();
}
FPDFText_MarkedContent CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
CPDF_TextObject* pTextObj = Obj.m_pTextObj.Get();
size_t nContentMarks = pTextObj->m_ContentMarks.CountItems();
if (nContentMarks == 0)
return FPDFText_MarkedContent::Pass;
WideString actText;
bool bExist = false;
const CPDF_Dictionary* pDict = nullptr;
for (size_t i = 0; i < nContentMarks; ++i) {
const CPDF_ContentMarkItem* item = pTextObj->m_ContentMarks.GetItem(i);
pDict = item->GetParam();
if (!pDict)
continue;
const CPDF_String* temp = ToString(pDict->GetObjectFor("ActualText"));
if (temp) {
bExist = true;
actText = temp->GetUnicodeText();
}
}
if (!bExist)
return FPDFText_MarkedContent::Pass;
if (m_pPreTextObj) {
const CPDF_ContentMarks& marks = m_pPreTextObj->m_ContentMarks;
if (marks.CountItems() == nContentMarks &&
marks.GetItem(nContentMarks - 1)->GetParam() == pDict) {
return FPDFText_MarkedContent::Done;
}
}
if (actText.IsEmpty())
return FPDFText_MarkedContent::Pass;
CPDF_Font* pFont = pTextObj->GetFont();
bExist = false;
for (size_t i = 0; i < actText.GetLength(); ++i) {
if (pFont->CharCodeFromUnicode(actText[i]) != CPDF_Font::kInvalidCharCode) {
bExist = true;
break;
}
}
if (!bExist)
return FPDFText_MarkedContent::Pass;
bExist = false;
for (size_t i = 0; i < actText.GetLength(); ++i) {
wchar_t wChar = actText[i];
if ((wChar > 0x80 && wChar < 0xFFFD) || (wChar <= 0x80 && isprint(wChar))) {
bExist = true;
break;
}
}
if (!bExist)
return FPDFText_MarkedContent::Done;
return FPDFText_MarkedContent::Delay;
}
void CJX_Field::defaultValue(CFXJSE_Value* pValue,
bool bSetting,
XFA_Attribute eAttribute) {
CXFA_Node* xfaNode = GetXFANode();
if (!xfaNode->IsWidgetReady())
return;
if (bSetting) {
if (pValue) {
xfaNode->SetPreNull(xfaNode->IsNull());
xfaNode->SetIsNull(pValue->IsNull());
}
WideString wsNewText;
if (pValue && !(pValue->IsNull() || pValue->IsUndefined()))
wsNewText = pValue->ToWideString();
if (xfaNode->GetUIChildNode()->GetElementType() == XFA_Element::NumericEdit)
wsNewText = xfaNode->NumericLimit(wsNewText);
CXFA_Node* pContainerNode = xfaNode->GetContainerNode();
WideString wsFormatText(wsNewText);
if (pContainerNode)
wsFormatText = pContainerNode->GetFormatDataValue(wsNewText);
SetContent(wsNewText, wsFormatText, true, true, true);
return;
}
WideString content = GetContent(true);
if (content.IsEmpty()) {
pValue->SetNull();
return;
}
CXFA_Node* formValue = xfaNode->GetFormValueIfExists();
CXFA_Node* pNode = formValue ? formValue->GetFirstChild() : nullptr;
if (pNode && pNode->GetElementType() == XFA_Element::Decimal) {
if (xfaNode->GetUIChildNode()->GetElementType() ==
XFA_Element::NumericEdit &&
(pNode->JSObject()->GetInteger(XFA_Attribute::FracDigits) == -1)) {
pValue->SetString(content.ToUTF8().AsStringView());
} else {
CFX_Decimal decimal(content.AsStringView());
pValue->SetFloat((float)(double)decimal);
}
} else if (pNode && pNode->GetElementType() == XFA_Element::Integer) {
pValue->SetInteger(FXSYS_wtoi(content.c_str()));
} else if (pNode && pNode->GetElementType() == XFA_Element::Boolean) {
pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? false : true);
} else if (pNode && pNode->GetElementType() == XFA_Element::Float) {
CFX_Decimal decimal(content.AsStringView());
pValue->SetFloat((float)(double)decimal);
} else {
pValue->SetString(content.ToUTF8().AsStringView());
}
}
WideString CFX_XMLElement::GetNamespaceURI() const {
WideString attr(L"xmlns");
WideString wsPrefix = GetNamespacePrefix();
if (!wsPrefix.IsEmpty()) {
attr += L":";
attr += wsPrefix;
}
const CFX_XMLNode* pNode = this;
while (pNode) {
if (pNode->GetType() != FX_XMLNODE_Element)
break;
auto* pElement = static_cast<const CFX_XMLElement*>(pNode);
if (!pElement->HasAttribute(attr)) {
pNode = pNode->GetParent();
continue;
}
return pElement->GetAttribute(attr);
}
return WideString();
}
void CPDF_TextPage::ProcessMarkedContent(PDFTEXT_Obj Obj) {
CPDF_TextObject* pTextObj = Obj.m_pTextObj.Get();
size_t nContentMarks = pTextObj->m_ContentMarks.CountItems();
if (nContentMarks == 0)
return;
WideString actText;
for (size_t n = 0; n < nContentMarks; ++n) {
const CPDF_ContentMarkItem* item = pTextObj->m_ContentMarks.GetItem(n);
const CPDF_Dictionary* pDict = item->GetParam();
if (pDict)
actText = pDict->GetUnicodeTextFor("ActualText");
}
if (actText.IsEmpty())
return;
CPDF_Font* pFont = pTextObj->GetFont();
CFX_Matrix matrix = pTextObj->GetTextMatrix() * Obj.m_formMatrix;
for (size_t k = 0; k < actText.GetLength(); ++k) {
wchar_t wChar = actText[k];
if (wChar <= 0x80 && !isprint(wChar))
wChar = 0x20;
if (wChar >= 0xFFFD)
continue;
PAGECHAR_INFO charinfo;
charinfo.m_Origin = pTextObj->GetPos();
charinfo.m_Index = m_TextBuf.GetLength();
charinfo.m_Unicode = wChar;
charinfo.m_CharCode = pFont->CharCodeFromUnicode(wChar);
charinfo.m_Flag = FPDFTEXT_CHAR_PIECE;
charinfo.m_pTextObj = pTextObj;
charinfo.m_CharBox = pTextObj->GetRect();
charinfo.m_Matrix = matrix;
m_TempTextBuf.AppendChar(wChar);
m_TempCharList.push_back(charinfo);
}
}
void CJX_Draw::defaultValue(CFXJSE_Value* pValue,
bool bSetting,
XFA_Attribute eAttribute) {
if (!bSetting) {
WideString content = GetContent(true);
if (content.IsEmpty())
pValue->SetNull();
else
pValue->SetString(content.ToUTF8().AsStringView());
return;
}
if (!pValue || !pValue->IsString())
return;
ASSERT(GetXFANode()->IsWidgetReady());
if (GetXFANode()->GetFFWidgetType() != XFA_FFWidgetType::kText)
return;
WideString wsNewValue = pValue->ToWideString();
SetContent(wsNewValue, wsNewValue, true, true, true);
}
void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj) {
CPDF_TextObject* pTextObj = Obj.m_pTextObj.Get();
if (fabs(pTextObj->GetRect().Width()) < kSizeEpsilon)
return;
CFX_Matrix formMatrix = Obj.m_formMatrix;
CPDF_Font* pFont = pTextObj->GetFont();
CFX_Matrix matrix = pTextObj->GetTextMatrix() * formMatrix;
FPDFText_MarkedContent ePreMKC = PreMarkedContent(Obj);
if (ePreMKC == FPDFText_MarkedContent::Done) {
m_pPreTextObj = pTextObj;
m_perMatrix = formMatrix;
return;
}
GenerateCharacter result = GenerateCharacter::None;
if (m_pPreTextObj) {
result = ProcessInsertObject(pTextObj, formMatrix);
if (result == GenerateCharacter::LineBreak)
m_CurlineRect = Obj.m_pTextObj->GetRect();
else
m_CurlineRect.Union(Obj.m_pTextObj->GetRect());
switch (result) {
case GenerateCharacter::None:
break;
case GenerateCharacter::Space: {
Optional<PAGECHAR_INFO> pGenerateChar =
GenerateCharInfo(TEXT_SPACE_CHAR);
if (pGenerateChar) {
if (!formMatrix.IsIdentity())
pGenerateChar->m_Matrix = formMatrix;
m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
m_TempCharList.push_back(*pGenerateChar);
}
break;
}
case GenerateCharacter::LineBreak:
CloseTempLine();
if (m_TextBuf.GetSize()) {
AppendGeneratedCharacter(TEXT_RETURN_CHAR, formMatrix);
AppendGeneratedCharacter(TEXT_LINEFEED_CHAR, formMatrix);
}
break;
case GenerateCharacter::Hyphen:
if (pTextObj->CountChars() == 1) {
CPDF_TextObjectItem item;
pTextObj->GetCharInfo(0, &item);
WideString wstrItem =
pTextObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
if (wstrItem.IsEmpty())
wstrItem += (wchar_t)item.m_CharCode;
wchar_t curChar = wstrItem[0];
if (IsHyphenCode(curChar))
return;
}
while (m_TempTextBuf.GetSize() > 0 &&
m_TempTextBuf.AsStringView()[m_TempTextBuf.GetLength() - 1] ==
0x20) {
m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
m_TempCharList.pop_back();
}
PAGECHAR_INFO* charinfo = &m_TempCharList.back();
m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
charinfo->m_Unicode = 0x2;
charinfo->m_Flag = FPDFTEXT_CHAR_HYPHEN;
m_TempTextBuf.AppendChar(0xfffe);
break;
}
} else {
m_CurlineRect = Obj.m_pTextObj->GetRect();
}
if (ePreMKC == FPDFText_MarkedContent::Delay) {
ProcessMarkedContent(Obj);
m_pPreTextObj = pTextObj;
m_perMatrix = formMatrix;
return;
}
m_pPreTextObj = pTextObj;
m_perMatrix = formMatrix;
float baseSpace = CalculateBaseSpace(pTextObj, matrix);
const bool bR2L = IsRightToLeft(*pTextObj, *pFont);
const bool bIsBidiAndMirrorInverse =
bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
int32_t iBufStartAppend = m_TempTextBuf.GetLength();
int32_t iCharListStartAppend =
pdfium::CollectionSize<int32_t>(m_TempCharList);
float spacing = 0;
const size_t nItems = pTextObj->CountItems();
for (size_t i = 0; i < nItems; ++i) {
CPDF_TextObjectItem item;
PAGECHAR_INFO charinfo;
pTextObj->GetItemInfo(i, &item);
if (item.m_CharCode == static_cast<uint32_t>(-1)) {
WideString str = m_TempTextBuf.MakeString();
if (str.IsEmpty())
str = m_TextBuf.AsStringView();
if (str.IsEmpty() || str[str.GetLength() - 1] == TEXT_SPACE_CHAR)
continue;
float fontsize_h = pTextObj->m_TextState.GetFontSizeH();
spacing = -fontsize_h * item.m_Origin.x / 1000;
continue;
}
float charSpace = pTextObj->m_TextState.GetCharSpace();
if (charSpace > 0.001)
spacing += matrix.TransformDistance(charSpace);
else if (charSpace < -0.001)
spacing -= matrix.TransformDistance(fabs(charSpace));
spacing -= baseSpace;
if (spacing && i > 0) {
float fontsize_h = pTextObj->m_TextState.GetFontSizeH();
uint32_t space_charcode = pFont->CharCodeFromUnicode(' ');
float threshold = 0;
if (space_charcode != CPDF_Font::kInvalidCharCode)
threshold = fontsize_h * pFont->GetCharWidthF(space_charcode) / 1000;
if (threshold > fontsize_h / 3)
threshold = 0;
else
threshold /= 2;
if (threshold == 0) {
threshold = static_cast<float>(GetCharWidth(item.m_CharCode, pFont));
threshold = NormalizeThreshold(threshold, 300, 500, 700);
threshold = fontsize_h * threshold / 1000;
}
if (threshold && (spacing && spacing >= threshold)) {
charinfo.m_Unicode = TEXT_SPACE_CHAR;
charinfo.m_Flag = FPDFTEXT_CHAR_GENERATED;
charinfo.m_pTextObj = pTextObj;
charinfo.m_Index = m_TextBuf.GetLength();
m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
charinfo.m_CharCode = CPDF_Font::kInvalidCharCode;
charinfo.m_Matrix = formMatrix;
charinfo.m_Origin = matrix.Transform(item.m_Origin);
charinfo.m_CharBox =
CFX_FloatRect(charinfo.m_Origin.x, charinfo.m_Origin.y,
charinfo.m_Origin.x, charinfo.m_Origin.y);
m_TempCharList.push_back(charinfo);
}
if (item.m_CharCode == CPDF_Font::kInvalidCharCode)
continue;
}
spacing = 0;
WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
bool bNoUnicode = false;
if (wstrItem.IsEmpty() && item.m_CharCode) {
wstrItem += static_cast<wchar_t>(item.m_CharCode);
bNoUnicode = true;
}
charinfo.m_Index = -1;
charinfo.m_CharCode = item.m_CharCode;
charinfo.m_Flag =
bNoUnicode ? FPDFTEXT_CHAR_UNUNICODE : FPDFTEXT_CHAR_NORMAL;
charinfo.m_pTextObj = pTextObj;
charinfo.m_Origin = matrix.Transform(item.m_Origin);
const FX_RECT rect =
charinfo.m_pTextObj->GetFont()->GetCharBBox(charinfo.m_CharCode);
const float fFontSize = pTextObj->GetFontSize() / 1000;
charinfo.m_CharBox.top = rect.top * fFontSize + item.m_Origin.y;
charinfo.m_CharBox.left = rect.left * fFontSize + item.m_Origin.x;
charinfo.m_CharBox.right = rect.right * fFontSize + item.m_Origin.x;
charinfo.m_CharBox.bottom = rect.bottom * fFontSize + item.m_Origin.y;
if (fabsf(charinfo.m_CharBox.top - charinfo.m_CharBox.bottom) <
kSizeEpsilon) {
charinfo.m_CharBox.top =
charinfo.m_CharBox.bottom + pTextObj->GetFontSize();
}
if (fabsf(charinfo.m_CharBox.right - charinfo.m_CharBox.left) <
kSizeEpsilon) {
charinfo.m_CharBox.right =
charinfo.m_CharBox.left + pTextObj->GetCharWidth(charinfo.m_CharCode);
}
charinfo.m_CharBox = matrix.TransformRect(charinfo.m_CharBox);
charinfo.m_Matrix = matrix;
if (wstrItem.IsEmpty()) {
charinfo.m_Unicode = 0;
m_TempCharList.push_back(charinfo);
m_TempTextBuf.AppendChar(0xfffe);
continue;
}
int nTotal = wstrItem.GetLength();
bool bDel = false;
const int count = std::min(pdfium::CollectionSize<int>(m_TempCharList), 7);
float threshold = charinfo.m_Matrix.TransformXDistance(
static_cast<float>(TEXT_CHARRATIO_GAPDELTA) * pTextObj->GetFontSize());
for (int n = pdfium::CollectionSize<int>(m_TempCharList);
n > pdfium::CollectionSize<int>(m_TempCharList) - count; --n) {
const PAGECHAR_INFO& charinfo1 = m_TempCharList[n - 1];
CFX_PointF diff = charinfo1.m_Origin - charinfo.m_Origin;
if (charinfo1.m_CharCode == charinfo.m_CharCode &&
charinfo1.m_pTextObj->GetFont() == charinfo.m_pTextObj->GetFont() &&
fabs(diff.x) < threshold && fabs(diff.y) < threshold) {
bDel = true;
break;
}
}
if (!bDel) {
for (int nIndex = 0; nIndex < nTotal; ++nIndex) {
charinfo.m_Unicode = wstrItem[nIndex];
if (charinfo.m_Unicode) {
charinfo.m_Index = m_TextBuf.GetLength();
m_TempTextBuf.AppendChar(charinfo.m_Unicode);
} else {
m_TempTextBuf.AppendChar(0xfffe);
}
m_TempCharList.push_back(charinfo);
}
} else if (i == 0) {
WideString str = m_TempTextBuf.MakeString();
if (!str.IsEmpty() && str[str.GetLength() - 1] == TEXT_SPACE_CHAR) {
m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
m_TempCharList.pop_back();
}
}
}
if (bIsBidiAndMirrorInverse)
SwapTempTextBuf(iCharListStartAppend, iBufStartAppend);
}
CPDF_TextPage::GenerateCharacter CPDF_TextPage::ProcessInsertObject(
const CPDF_TextObject* pObj,
const CFX_Matrix& formMatrix) {
FindPreviousTextObject();
TextOrientation WritingMode = GetTextObjectWritingMode(pObj);
if (WritingMode == TextOrientation::Unknown)
WritingMode = GetTextObjectWritingMode(m_pPreTextObj.Get());
size_t nItem = m_pPreTextObj->CountItems();
if (nItem == 0)
return GenerateCharacter::None;
CPDF_TextObjectItem PrevItem;
m_pPreTextObj->GetItemInfo(nItem - 1, &PrevItem);
CPDF_TextObjectItem item;
pObj->GetItemInfo(0, &item);
const CFX_FloatRect& this_rect = pObj->GetRect();
const CFX_FloatRect& prev_rect = m_pPreTextObj->GetRect();
WideString wstrItem = pObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
if (wstrItem.IsEmpty())
wstrItem += static_cast<wchar_t>(item.m_CharCode);
wchar_t curChar = wstrItem[0];
if (WritingMode == TextOrientation::Horizontal) {
if (EndHorizontalLine(this_rect, prev_rect)) {
return IsHyphen(curChar) ? GenerateCharacter::Hyphen
: GenerateCharacter::LineBreak;
}
} else if (WritingMode == TextOrientation::Vertical) {
if (EndVerticalLine(this_rect, prev_rect, m_CurlineRect,
pObj->GetFontSize(), m_pPreTextObj->GetFontSize())) {
return IsHyphen(curChar) ? GenerateCharacter::Hyphen
: GenerateCharacter::LineBreak;
}
}
float last_pos = PrevItem.m_Origin.x;
uint32_t nLastWidth =
GetCharWidth(PrevItem.m_CharCode, m_pPreTextObj->GetFont());
float last_width = nLastWidth * m_pPreTextObj->GetFontSize() / 1000;
last_width = fabs(last_width);
uint32_t nThisWidth = GetCharWidth(item.m_CharCode, pObj->GetFont());
float this_width = fabs(nThisWidth * pObj->GetFontSize() / 1000);
float threshold = std::max(last_width, this_width) / 4;
CFX_Matrix prev_matrix = m_pPreTextObj->GetTextMatrix() * m_perMatrix;
CFX_Matrix prev_reverse = prev_matrix.GetInverse();
CFX_PointF pos = prev_reverse.Transform(formMatrix.Transform(pObj->GetPos()));
if (last_width < this_width)
threshold = prev_reverse.TransformDistance(threshold);
bool bNewline = false;
if (WritingMode == TextOrientation::Horizontal) {
CFX_FloatRect rect = m_pPreTextObj->GetRect();
float rect_height = rect.Height();
rect.Normalize();
if ((rect.IsEmpty() && rect_height > 5) ||
((pos.y > threshold * 2 || pos.y < threshold * -3) &&
(fabs(pos.y) >= 1 || fabs(pos.y) > fabs(pos.x)))) {
bNewline = true;
if (nItem > 1) {
CPDF_TextObjectItem tempItem;
m_pPreTextObj->GetItemInfo(0, &tempItem);
CFX_Matrix m = m_pPreTextObj->GetTextMatrix();
if (PrevItem.m_Origin.x > tempItem.m_Origin.x &&
m_DisplayMatrix.a > 0.9 && m_DisplayMatrix.b < 0.1 &&
m_DisplayMatrix.c < 0.1 && m_DisplayMatrix.d < -0.9 && m.b < 0.1 &&
m.c < 0.1) {
CFX_FloatRect re(0, m_pPreTextObj->GetRect().bottom, 1000,
m_pPreTextObj->GetRect().top);
if (re.Contains(pObj->GetPos())) {
bNewline = false;
} else {
if (CFX_FloatRect(0, pObj->GetRect().bottom, 1000,
pObj->GetRect().top)
.Contains(m_pPreTextObj->GetPos())) {
bNewline = false;
}
}
}
}
}
}
if (bNewline) {
return IsHyphen(curChar) ? GenerateCharacter::Hyphen
: GenerateCharacter::LineBreak;
}
if (pObj->CountChars() == 1 && IsHyphenCode(curChar) && IsHyphen(curChar))
return GenerateCharacter::Hyphen;
if (curChar == L' ')
return GenerateCharacter::None;
WideString PrevStr =
m_pPreTextObj->GetFont()->UnicodeFromCharCode(PrevItem.m_CharCode);
wchar_t preChar = PrevStr.Last();
if (preChar == L' ')
return GenerateCharacter::None;
CFX_Matrix matrix = pObj->GetTextMatrix() * formMatrix;
float threshold2 = static_cast<float>(std::max(nLastWidth, nThisWidth));
threshold2 = NormalizeThreshold(threshold2, 400, 700, 800);
if (nLastWidth >= nThisWidth) {
threshold2 *= fabs(m_pPreTextObj->GetFontSize());
} else {
threshold2 *= fabs(pObj->GetFontSize());
threshold2 = matrix.TransformDistance(threshold2);
threshold2 = prev_reverse.TransformDistance(threshold2);
}
threshold2 /= 1000;
if ((threshold2 < 1.4881 && threshold2 > 1.4879) ||
(threshold2 < 1.39001 && threshold2 > 1.38999)) {
threshold2 *= 1.5;
}
return GenerateSpace(pos, last_pos, this_width, last_width, threshold2)
? GenerateCharacter::Space
: GenerateCharacter::None;
}
WideString MNotation::Export(const WideStringObserver &wsoIndent) const {
WideString wsRet;
Vector<std::pair<const MNotationNode *, const ChildNode *>> vecPackageStack;
vecPackageStack.Push(this, x_mapChildren.GetFirst<1>());
WideString wsIndent;
for(;;){
auto &vTop = vecPackageStack.GetEnd()[-1];
jNextChild:
if(vTop.second){
const auto &wsName = vTop.second->Get().first;
const auto &vNode = vTop.second->Get().second;
vTop.second = vTop.second->GetNext<1>();
wsRet += wsIndent;
if(!wsName.IsEmpty()){
Escape(wsRet, wsName);
wsRet += L' ';
}
if(vNode.x_mapChildren.GetSize() == 1){
const auto pNode = vNode.x_mapChildren.GetFirst<0>();
if(pNode->Get().second.x_mapChildren.IsEmpty()){
wsRet += L'=';
wsRet += L' ';
Escape(wsRet, pNode->Get().first);
wsRet += L'\n';
goto jNextChild;
}
}
wsRet += L'{';
wsRet += L'\n';
wsIndent += wsoIndent;
vecPackageStack.Push(&vNode, vNode.x_mapChildren.GetFirst<1>());
continue;
}
/* if(vTop.second){
wsRet += wsIndent;
if(!wsName.IsEmpty()){
Escape(wsRet, wsName);
wsRet += L' ';
}
wsRet += L'{';
wsRet += L'\n';
wsIndent += wsoIndent;
vecPackageStack.Push(&(vTop.second->Get().second), vTop.second->Get().second.x_mapChildren.GetFirst<1>());
continue;
}*/
/*
for(auto pNode = vTop.first->x_mapValues.GetFirst<1>(); pNode; pNode = pNode->GetNext<1>()){
wsRet += wsIndent;
if(!pNode->first.IsEmpty()){
Escape(wsRet, pNode->first);
wsRet += L' ';
}
}
*/
vecPackageStack.Pop();
if(vecPackageStack.IsEmpty()){
break;
}
wsIndent.Truncate(wsoIndent.GetLength());
wsRet += wsIndent;
wsRet += L'}';
wsRet += L'\n';
}
ASSERT(wsIndent.IsEmpty());
return wsRet;
}
