mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 01:52:24 +08:00
567 lines
17 KiB
C++
567 lines
17 KiB
C++
|
||
#include "ConvertDocx2Txt.h"
|
||
|
||
#include "Common/Encoding.h"
|
||
|
||
#include "TxtXmlEvent.h"
|
||
#include "TxtFormat/TxtFormat.h"
|
||
|
||
#include "../../../Common/DocxFormat/Source/DocxFormat/Docx.h"
|
||
#include "Common//ToString.h"
|
||
|
||
namespace Docx2Txt
|
||
{
|
||
static bool IsUnicodeSymbol( const wchar_t & symbol )
|
||
{
|
||
bool result = false;
|
||
|
||
if ( ( 0x0009 == symbol ) || ( 0x000A == symbol ) || ( 0x000D == symbol ) ||
|
||
( ( 0x0020 <= symbol ) && ( 0xD7FF >= symbol ) ) || ( ( 0xE000 <= symbol ) && ( symbol <= 0xFFFD ) ) ||
|
||
( ( 0x10000 <= symbol ) && symbol ) )
|
||
{
|
||
result = true;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
class Converter_Impl
|
||
{
|
||
public:
|
||
Converter_Impl();
|
||
~Converter_Impl();
|
||
|
||
void convert(TxtXml::ITxtXmlEvent& Event);
|
||
|
||
void writeUtf8 (const std::wstring& path) const;
|
||
void writeUnicode (const std::wstring& path) const;
|
||
void writeBigEndian (const std::wstring& path) const;
|
||
void writeAnsi (const std::wstring& path) const;
|
||
|
||
Txt::File m_outputFile;
|
||
OOX::CDocx m_inputFile;
|
||
|
||
private:
|
||
void convert(std::vector<OOX::WritingElement *> & items, std::list<std::wstring>& textOut, TxtXml::ITxtXmlEvent& Event, bool isFirstLevel,
|
||
OOX::CDocument *pDocument, OOX::CNumbering* pNumbering, OOX::CStyles *pStyles);
|
||
|
||
int m_lPercent;
|
||
int m_lAddition;
|
||
bool m_bCancelled;
|
||
int ListCount;
|
||
int* Lists;
|
||
|
||
std::wstring convert(OOX::Logic::CParagraph * pParagraph, TxtXml::ITxtXmlEvent& Event,
|
||
OOX::CDocument *pDocument, OOX::CNumbering* pNumbering, OOX::CStyles *pStyles);
|
||
|
||
size_t NoteCount;
|
||
std::list<std::wstring> Notes;
|
||
|
||
static std::wstring IntToLowerLetter (int number);
|
||
static std::wstring IntToUpperLetter (int number);
|
||
static std::wstring IntToLowerRoman (int number);
|
||
static std::wstring IntToUpperRoman (int number);
|
||
|
||
static const std::wstring m_letters;
|
||
};
|
||
|
||
Converter::Converter() : converter_(new Converter_Impl)
|
||
{}
|
||
|
||
Converter::~Converter()
|
||
{
|
||
delete converter_;
|
||
}
|
||
|
||
void Converter::convert(TxtXml::ITxtXmlEvent& Event)
|
||
{
|
||
return converter_->convert(Event);
|
||
}
|
||
|
||
void Converter::read(const std::wstring & path)
|
||
{
|
||
bool res = converter_->m_inputFile.Read(std_string2string(path));
|
||
return;
|
||
}
|
||
|
||
void Converter::write(const std::wstring & path)
|
||
{
|
||
return converter_->m_outputFile.write(path);
|
||
}
|
||
|
||
void Converter::writeUtf8(const std::wstring & path) const
|
||
{
|
||
return converter_->writeUtf8(path);
|
||
}
|
||
|
||
void Converter::writeUnicode(const std::wstring & path) const
|
||
{
|
||
return converter_->writeUnicode(path);
|
||
}
|
||
|
||
void Converter::writeBigEndian(const std::wstring & path) const
|
||
{
|
||
return converter_->writeBigEndian(path);
|
||
}
|
||
|
||
void Converter::writeAnsi(const std::wstring & path) const
|
||
{
|
||
return converter_->writeAnsi(path);
|
||
}
|
||
|
||
|
||
const std::wstring Converter_Impl::m_letters = _T("abcdefghijklmnopqrstuvwxyz");
|
||
|
||
Converter_Impl::Converter_Impl()
|
||
: m_lPercent(0), m_lAddition(0), m_bCancelled(false), ListCount(0), Lists(NULL), NoteCount(0)
|
||
{
|
||
}
|
||
|
||
|
||
Converter_Impl::~Converter_Impl()
|
||
{
|
||
if(Lists != NULL)
|
||
{
|
||
delete []Lists;
|
||
Lists = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
void Converter_Impl::convert(TxtXml::ITxtXmlEvent& Event)
|
||
{
|
||
OOX::CDocument *pDocument = NULL;
|
||
OOX::CStyles *pStyles = NULL;
|
||
OOX::CNumbering *pNumbering = NULL;
|
||
|
||
m_lPercent = 100000;
|
||
m_bCancelled = Event.Progress(0, m_lPercent);
|
||
if(m_bCancelled)
|
||
return;
|
||
|
||
smart_ptr<OOX::File> pFileD = m_inputFile.Find(OOX::FileTypes::Document);
|
||
if (pFileD.IsInit() && OOX::FileTypes::Document == pFileD->type())
|
||
pDocument = (OOX::CDocument*)pFileD.operator->();
|
||
|
||
smart_ptr<OOX::File> pFileS = pDocument->Find(OOX::FileTypes::Style);
|
||
if (pFileS.IsInit() && OOX::FileTypes::Style == pFileS->type())
|
||
pStyles = (OOX::CStyles*)pFileS.operator->();
|
||
|
||
smart_ptr<OOX::File> pFileN = pDocument->Find(OOX::FileTypes::Numbering);
|
||
if (pFileN.IsInit() && OOX::FileTypes::Numbering == pFileN->type())
|
||
{
|
||
pNumbering = (OOX::CNumbering*)pFileN.operator->();
|
||
|
||
ListCount = pNumbering->m_arrNum.size();
|
||
Lists = new int[9 * ListCount];
|
||
if(Lists == NULL)
|
||
return;
|
||
for(int i = 0; i < 9 * ListCount; i++)
|
||
Lists[i] = 0;
|
||
}
|
||
if(pDocument->m_arrItems.size() > 0)
|
||
{
|
||
m_lAddition = 800000;
|
||
Notes.clear();
|
||
|
||
convert(pDocument->m_arrItems, m_outputFile.m_listContent, Event, true, pDocument, pNumbering, pStyles);
|
||
|
||
if(NoteCount != 0)
|
||
{
|
||
m_outputFile.m_listContent.push_back(_T("---------------------------"));
|
||
for(std::list<std::wstring>::const_iterator iter = Notes.begin(); iter != Notes.end(); iter++)
|
||
{
|
||
m_outputFile.m_listContent.push_back(*iter);
|
||
}
|
||
}
|
||
}
|
||
if(Lists != NULL)
|
||
{
|
||
delete []Lists;
|
||
Lists = NULL;
|
||
}
|
||
Event.Progress(0, 900000);
|
||
}
|
||
|
||
|
||
void Converter_Impl::writeUtf8(const std::wstring& path) const
|
||
{
|
||
m_outputFile.writeUtf8(path);
|
||
}
|
||
|
||
|
||
void Converter_Impl::writeUnicode(const std::wstring& path) const
|
||
{
|
||
m_outputFile.writeUnicode(path);
|
||
}
|
||
|
||
|
||
void Converter_Impl::writeBigEndian(const std::wstring& path) const
|
||
{
|
||
m_outputFile.writeBigEndian(path);
|
||
}
|
||
|
||
|
||
void Converter_Impl::writeAnsi(const std::wstring& path) const
|
||
{
|
||
m_outputFile.writeAnsi(path);
|
||
}
|
||
|
||
|
||
void Converter_Impl::convert(std::vector<OOX::WritingElement *> & items, std::list<std::wstring>& textOut, TxtXml::ITxtXmlEvent& Event,
|
||
bool isFirstLevel, OOX::CDocument *pDocument, OOX::CNumbering* pNumbering, OOX::CStyles *pStyles)
|
||
{
|
||
if(items.size() > 0)
|
||
{
|
||
if(isFirstLevel)
|
||
m_lAddition = m_lAddition / items.size();
|
||
|
||
for (int i=0 ; i< items.size(); i++)
|
||
{
|
||
OOX::WritingElement * item = items[i];
|
||
|
||
if (item->getType() == OOX::et_w_p)
|
||
{
|
||
textOut.push_back(convert((dynamic_cast<OOX::Logic::CParagraph*>(item)), Event, pDocument, pNumbering, pStyles));
|
||
}
|
||
/*else if (item.is<OOX::Logic::List>())
|
||
{
|
||
BOOST_FOREACH(const OOX::Logic::ListItem& listItem, *item.as<OOX::Logic::List>().m_arrItems)
|
||
{
|
||
convert(listItem.m_arrItems);
|
||
}
|
||
}*/
|
||
//else if (item->getType() == OOX::et_w_tbl)
|
||
//{
|
||
// OOX::Logic::CTbl* tbl = dynamic_cast<OOX::Logic::CTbl*>(item);
|
||
// for (int r = 0 ; r < tbl->m_arrItems.size(); r++)
|
||
// {
|
||
// OOX::WritingElement * item = tbl->m_arrItems[r];
|
||
// if (item->getType() == OOX::et_w_tr)
|
||
// {
|
||
// OOX::Logic::CTr* tr = dynamic_cast<OOX::Logic::CTr*>(item);
|
||
// for (int c = 0 ; c < tr->m_arrItems.size(); c++)
|
||
// {
|
||
// OOX::WritingElement * item = tr->m_arrItems[c];
|
||
// if (item->getType() == OOX::et_w_tc)
|
||
// {
|
||
// OOX::Logic::CTc* tc = dynamic_cast<OOX::Logic::CTc*>(item);
|
||
// convert(tc->m_arrItems, Event, false, pDocument, pStyles);
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
// }
|
||
//}
|
||
//else if (item->getType() == OOX::et_w_sdt)
|
||
//{
|
||
// convert((dynamic_cast<OOX::Logic::CSdt*>(item))->m_arrItems, text, Event, false, pDocument, pNumbering, pStyles);
|
||
//}
|
||
else
|
||
{
|
||
//todoooo <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CSdt ... <20><> <20> Tbl <20><><EFBFBD>
|
||
OOX::WritingElementWithChilds<OOX::WritingElement> *item_with_items = dynamic_cast<OOX::WritingElementWithChilds<OOX::WritingElement>*>(item);
|
||
if (item_with_items)
|
||
{
|
||
convert(item_with_items->m_arrItems, textOut, Event, false, pDocument, pNumbering, pStyles);
|
||
}
|
||
}
|
||
|
||
if(isFirstLevel)
|
||
{
|
||
m_lPercent += m_lAddition;
|
||
m_bCancelled = Event.Progress(0, m_lPercent);
|
||
if(m_bCancelled)
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
std::wstring Converter_Impl::convert(OOX::Logic::CParagraph* pParagraph, TxtXml::ITxtXmlEvent& Event,
|
||
OOX::CDocument *pDocument, OOX::CNumbering* pNumbering, OOX::CStyles* pStyles)
|
||
{
|
||
if (pParagraph == NULL) return _T("");
|
||
|
||
std::wstring line = _T("");
|
||
|
||
int level = 0;
|
||
int listNum = 0;
|
||
|
||
if (pParagraph->m_oParagraphProperty)
|
||
{
|
||
if (pParagraph->m_oParagraphProperty->m_oNumPr.IsInit())
|
||
{
|
||
if (pParagraph->m_oParagraphProperty->m_oNumPr->m_oIlvl.IsInit())
|
||
{
|
||
level = pParagraph->m_oParagraphProperty->m_oNumPr->m_oIlvl->m_oVal.IsInit() ?
|
||
pParagraph->m_oParagraphProperty->m_oNumPr->m_oIlvl->m_oVal->GetValue() + 1 : 0;
|
||
}
|
||
if (pParagraph->m_oParagraphProperty->m_oNumPr->m_oNumID.IsInit())
|
||
{
|
||
listNum = pParagraph->m_oParagraphProperty->m_oNumPr->m_oNumID->m_oVal.IsInit() ?
|
||
pParagraph->m_oParagraphProperty->m_oNumPr->m_oNumID->m_oVal->GetValue() : 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if((listNum == 0) || (level == 0))
|
||
{
|
||
if(pParagraph->m_oParagraphProperty)
|
||
{
|
||
CString styleName;
|
||
if (pParagraph->m_oParagraphProperty->m_oPStyle.IsInit())
|
||
pParagraph->m_oParagraphProperty->m_oPStyle->m_sVal.IsInit() ? pParagraph->m_oParagraphProperty->m_oPStyle->m_sVal.get() : _T("");
|
||
|
||
if(styleName != _T("") && pStyles)
|
||
{
|
||
std::map<CString, int>::iterator pPair = pStyles->m_arrStyleNamesMap.find(styleName);
|
||
|
||
if (pPair != pStyles->m_arrStyleNamesMap.end())
|
||
{
|
||
OOX::CStyle* style = pStyles->m_arrStyle[pPair->second];
|
||
|
||
if((style) && (style->m_oParPr.IsInit()))
|
||
{
|
||
if((style->m_oParPr->m_oNumPr.IsInit()) && (style->m_oParPr->m_oNumPr->m_oIlvl.IsInit()))
|
||
{
|
||
listNum = style->m_oParPr->m_oNumPr->m_oIlvl->m_oVal.IsInit() ? style->m_oParPr->m_oNumPr->m_oIlvl->m_oVal->GetValue() + 1 : 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if((listNum > 0) && (level > 0) && pNumbering)
|
||
{
|
||
level--;
|
||
int start = (listNum - 1) * 9;
|
||
for(int i = level + 1; i < 9; i++)
|
||
{
|
||
Lists[start + i] = 0;
|
||
}
|
||
|
||
listNum--;
|
||
if ((pNumbering->m_arrNum[listNum]) && (pNumbering->m_arrNum[listNum]->m_oNumId.IsInit()))
|
||
{
|
||
int abstractNumId = 0;
|
||
if ((pNumbering->m_arrNum[listNum]) && (pNumbering->m_arrNum[listNum]->m_oAbstractNumId.IsInit()) &&
|
||
(pNumbering->m_arrNum[listNum]->m_oAbstractNumId->m_oVal.IsInit()))
|
||
abstractNumId = pNumbering->m_arrNum[listNum]->m_oAbstractNumId->m_oVal->GetValue();
|
||
|
||
OOX::Numbering::CAbstractNum* abstractNum = NULL;
|
||
if (abstractNumId < pNumbering->m_arrAbstractNum.size())
|
||
abstractNum = pNumbering->m_arrAbstractNum[abstractNumId];
|
||
|
||
if (abstractNum)
|
||
{
|
||
Lists[start + level]++;
|
||
|
||
int ind_level = -1;
|
||
for (long i=0; i< abstractNum->m_arrLvl.size(); i++)//??? <20><><EFBFBD><EFBFBD><EFBFBD> <20><>???
|
||
{
|
||
if ((abstractNum->m_arrLvl[i]) && (abstractNum->m_arrLvl[i]->m_oIlvl.IsInit()) && (abstractNum->m_arrLvl[i]->m_oIlvl->GetValue() == level))
|
||
{
|
||
ind_level = i;
|
||
break;
|
||
}
|
||
}
|
||
if (( ind_level >= 0 ) && ( abstractNum->m_arrLvl[ind_level] ))
|
||
{
|
||
if ((abstractNum->m_arrLvl[ind_level]->m_oNumFmt.IsInit()) && (abstractNum->m_arrLvl[ind_level]->m_oNumFmt->m_oVal.IsInit()))
|
||
{
|
||
std::wstring strLevelText;
|
||
if ((abstractNum->m_arrLvl[ind_level]->m_oLvlText.IsInit()) && (abstractNum->m_arrLvl[ind_level]->m_oLvlText->m_sVal.IsInit()))
|
||
{
|
||
strLevelText = string2std_string(abstractNum->m_arrLvl[ind_level]->m_oLvlText->m_sVal.get());
|
||
}
|
||
|
||
if (abstractNum->m_arrLvl[ind_level]->m_oNumFmt->m_oVal->GetValue() == SimpleTypes::numberformatBullet)
|
||
{
|
||
//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>-<2D><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if ((strLevelText.length() > 0) && (IsUnicodeSymbol(strLevelText[0]))) line += strLevelText + _T(" ");
|
||
else line += _T("* ");
|
||
}
|
||
else
|
||
{
|
||
std::wstring example = strLevelText;
|
||
for(int i = 0; i < 9; i++)
|
||
{
|
||
std::wstring num = _T("%") + ToWString(i + 1);
|
||
while(example.find(num) != example.npos)
|
||
{
|
||
switch(abstractNum->m_arrLvl[ind_level]->m_oNumFmt->m_oVal->GetValue())
|
||
{
|
||
case SimpleTypes::numberformatLowerLetter:
|
||
example.replace(example.find(num), 2, IntToLowerLetter(Lists[start + i]));
|
||
break;
|
||
case SimpleTypes::numberformatUpperLetter:
|
||
example.replace(example.find(num), 2, IntToUpperLetter(Lists[start + i]));
|
||
break;
|
||
case SimpleTypes::numberformatLowerRoman:
|
||
example.replace(example.find(num), 2, IntToLowerRoman(Lists[start + i]));
|
||
break;
|
||
case SimpleTypes::numberformatUpperRoman:
|
||
example.replace(example.find(num), 2, IntToUpperRoman(Lists[start + i]));
|
||
break;
|
||
default:
|
||
example.replace(example.find(num), 2, ToWString(Lists[start + i]));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
line += example + _T(" ");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool inField = false;
|
||
|
||
for (long i=0; i < pParagraph->m_arrItems.size(); i++)
|
||
{
|
||
if (pParagraph->m_arrItems[i]->getType() == OOX::et_w_r)
|
||
{
|
||
OOX::Logic::CRun *run = dynamic_cast<OOX::Logic::CRun*>(pParagraph->m_arrItems[i]);
|
||
for (long j = 0 ; j < run->m_arrItems.size();j++)
|
||
{
|
||
if (run->m_arrItems[j]->getType() == OOX::et_w_fldChar)
|
||
{
|
||
OOX::Logic::CFldChar *fldChar = dynamic_cast<OOX::Logic::CFldChar*>(run->m_arrItems[j]);
|
||
if ((fldChar) && (fldChar->m_oFldCharType.IsInit()))
|
||
{
|
||
if (fldChar->m_oFldCharType->GetValue() == SimpleTypes::fldchartypeBegin) inField = true;
|
||
else inField = false;
|
||
}
|
||
}
|
||
else if (inField == false)
|
||
{
|
||
bool caps = false;
|
||
|
||
if ((run->m_oRunProperty) && (run->m_oRunProperty->m_oCaps.Init()) && (run->m_oRunProperty->m_oCaps->m_oVal.ToBool())) caps = true;
|
||
|
||
std::wstring wstr;
|
||
if (run->m_arrItems[j]->getType() == OOX::et_w_tab)
|
||
{
|
||
wstr = L"\x09";
|
||
}
|
||
else if (run->m_arrItems[j]->getType() == OOX::et_w_t)
|
||
{
|
||
OOX::Logic::CText* text = dynamic_cast<OOX::Logic::CText*>(run->m_arrItems[j]);
|
||
wstr = string2std_string(text->m_sText);
|
||
if(caps)
|
||
{
|
||
//std::locale loc;
|
||
//str = Encoding::unicode2utf8(std::toupper(wstr,loc));
|
||
}
|
||
}
|
||
|
||
if (run->m_arrItems[j]->getType() == OOX::et_w_footnoteReference || run->m_arrItems[j]->getType() == OOX::et_w_endnoteReference)
|
||
{// todooo Ref ????
|
||
NoteCount++;
|
||
std::wstring s = _T("[") + ToWString(NoteCount) + _T("]");
|
||
Notes.push_back(s);
|
||
if(run->m_arrItems[j]->getType() == OOX::et_w_footnoteReference)
|
||
{
|
||
smart_ptr<OOX::File> pFile = pDocument->Find(OOX::FileTypes::FootNote);
|
||
if (pFile.IsInit())
|
||
{
|
||
OOX::CFootnotes *pFootnotes = (OOX::CFootnotes*)pFile.operator->();
|
||
for (long r =0 ;r < pFootnotes->m_arrFootnote.size(); r++)
|
||
convert(pFootnotes->m_arrFootnote[r]->m_arrItems, Notes, Event, false, pDocument, pNumbering, pStyles);
|
||
}
|
||
}
|
||
else if(run->m_arrItems[j]->getType() == OOX::et_w_endnoteReference)
|
||
{
|
||
smart_ptr<OOX::File> pFile = pDocument->Find(OOX::FileTypes::EndNote);
|
||
if (pFile.IsInit())
|
||
{
|
||
OOX::CEndnotes *pEndnotes = (OOX::CEndnotes*)pFile.operator->();
|
||
for (long r =0 ;r < pEndnotes->m_arrEndnote.size(); r++)
|
||
convert(pEndnotes->m_arrEndnote[r]->m_arrItems, Notes, Event, false, pDocument, pNumbering, pStyles);
|
||
}
|
||
}
|
||
|
||
wstr.replace(wstr.find(_T("_")), 1 , ToWString(NoteCount));
|
||
}
|
||
line += wstr;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> ..
|
||
//line += pItem.toTxt();
|
||
}
|
||
}
|
||
|
||
return line;
|
||
}
|
||
|
||
|
||
std::wstring Converter_Impl::IntToLowerLetter(int number)
|
||
{
|
||
std::wstring result(number / 26 + 1, m_letters[(number % 26) - 1]);
|
||
return result;
|
||
}
|
||
|
||
std::wstring Converter_Impl::IntToUpperLetter(int number)
|
||
{
|
||
//std::locale loc;
|
||
std::wstring result(number / 26 + 1, m_letters[(number % 26) - 1]);
|
||
//result = std::toupper(result,loc);
|
||
return result;
|
||
}
|
||
|
||
std::wstring Converter_Impl::IntToLowerRoman(int number)
|
||
{
|
||
std::wstring result;
|
||
|
||
const std::wstring ixcm = _T("ixcm");
|
||
const std::wstring vxlcdm = _T("vxlcdm");
|
||
const std::wstring vld = _T("vld");
|
||
|
||
std::wstring str_num = ToWString(number);
|
||
int len = str_num.size();
|
||
int digit;
|
||
for(int i = 0; i < len; i++)
|
||
{
|
||
digit = str_num[len - i - 1] - '0';
|
||
if(i > 2)
|
||
{
|
||
std::wstring m(digit + 10 * (i - 3), 'm');
|
||
result = m + result;
|
||
}
|
||
else
|
||
{
|
||
if(((digit + 1) % 5) == 0)
|
||
{
|
||
result.insert(0, 1, vxlcdm[i * 2 + (digit + 1) / 5 - 1]);
|
||
result.insert(0, 1, ixcm[i]);
|
||
//result = ixcm[i] + vxlcdm[i * 2 + (digit + 1) / 5 - 1] + result;
|
||
}
|
||
else
|
||
{
|
||
std::wstring m(digit % 5, ixcm[i]);
|
||
if(digit >= 5)
|
||
result = vld[i] + m + result;
|
||
else
|
||
result = m + result;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::wstring Converter_Impl::IntToUpperRoman(int number)
|
||
{
|
||
//std::locale loc;
|
||
std::wstring result = IntToLowerRoman(number);
|
||
//result = std::toupper(result,loc);
|
||
return result;
|
||
}
|
||
|
||
} // namespace Docx2Txt
|