diff --git a/HtmlFile2/HTMLReader.cpp b/HtmlFile2/HTMLReader.cpp index 153192f8f0..2706d5b309 100644 --- a/HtmlFile2/HTMLReader.cpp +++ b/HtmlFile2/HTMLReader.cpp @@ -7,9 +7,13 @@ #include "../Common/3dParty/html/htmltoxhtml.h" #include "Common.h" -#include "Interpretators/OOXMLInterpretator.h" + +#include "Writers/OOXMLWriter.h" #include "Tags/OOXMLTags.h" +#include "Writers/MDWriter.h" +#include "Tags/MDTags.h" + #include "../../Common/3dParty/html/gumbo-parser/src/gumbo.h" #include "../src/StringFinder.h" @@ -165,32 +169,71 @@ inline bool UnreadableNode(const std::wstring& wsNodeName); inline bool TagIsUnprocessed(const std::wstring& wsTagName); CHTMLReader::CHTMLReader() - : m_pInterpretator(nullptr) + : m_pWriter(nullptr) { - COOXMLInterpretator *pInterpretator = new COOXMLInterpretator(); + // InitOOXMLTags(); + InitMDTags(); +} - if (nullptr == pInterpretator) +CHTMLReader::~CHTMLReader() +{ + if (nullptr != m_pWriter) + delete m_pWriter; +} + +HRESULT CHTMLReader::ConvertFromTo(const std::wstring& wsFrom, const std::wstring& wsTo) +{ + if (nullptr == m_pWriter || !HTML2XHTML(wsFrom) || !m_oLightReader.IsValid() || !IsHTML()) + return S_FALSE; + + m_pWriter->Begin(wsTo, nullptr); + + m_sSrc = NSSystemPath::GetDirectoryName(wsFrom); + // m_sDst = sDst; + + m_oLightReader.MoveToStart(); + m_oLightReader.ReadNextNode(); + ReadStyle(); + + // Переходим в начало + if(!m_oLightReader.MoveToStart()) + return S_FALSE; + + // if(oParams && oParams->m_bNeedPageBreakBefore) + // m_internal->PageBreakBefore(); + + ReadDocument(); + + m_pWriter->End(wsTo); + return S_OK; +} + +void CHTMLReader::InitOOXMLTags() +{ + COOXMLWriter *pWriter = new COOXMLWriter(); + + if (nullptr == pWriter) return; - pInterpretator->SetCSSCalculator(&m_oCSSCalculator); - m_pInterpretator = pInterpretator; + pWriter->SetCSSCalculator(&m_oCSSCalculator); + m_pWriter = pWriter; - m_mTags[HTML_TAG(A)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(ABBR)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(BR)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(DIV)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(IMG)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(FONT)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(INPUT)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(BASEFONT)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(BLOCKQUOTE)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(HR)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(UL)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(LI)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(CAPTION)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(TABLE)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(TR)] = std::make_shared>(pInterpretator); - m_mTags[HTML_TAG(TD)] = std::make_shared>(pInterpretator); + m_mTags[HTML_TAG(A)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(ABBR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(BR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(DIV)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(IMG)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(FONT)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(INPUT)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(BASEFONT)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(BLOCKQUOTE)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(HR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(UL)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(LI)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(CAPTION)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TABLE)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TD)] = std::make_shared>(pWriter); std::shared_ptr oIgnoredTag{std::make_shared()}; @@ -210,37 +253,49 @@ CHTMLReader::CHTMLReader() m_mTags[HTML_TAG(H1)] = oIgnoredTag; } -CHTMLReader::~CHTMLReader() +void CHTMLReader::InitMDTags() { - if (nullptr != m_pInterpretator) - delete m_pInterpretator; -} + CMDWriter *pWriter = new CMDWriter({}); -HRESULT CHTMLReader::ConvertFromTo(const std::wstring& wsFrom, const std::wstring& wsTo) -{ - if (nullptr == m_pInterpretator || !HTML2XHTML(wsFrom) || !m_oLightReader.IsValid() || !IsHTML()) - return S_FALSE; + if (nullptr == pWriter) + return; - m_pInterpretator->Begin(wsTo, nullptr); + m_pWriter = pWriter; - m_sSrc = NSSystemPath::GetDirectoryName(wsFrom); - // m_sDst = sDst; + m_mTags[HTML_TAG(A)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(B)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(BR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(I)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(S)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(U)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(Q)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(H1)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(IMG)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(HR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(BLOCKQUOTE)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TABLE)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TR)] = std::make_shared>(pWriter); + m_mTags[HTML_TAG(TD)] = std::make_shared>(pWriter); - m_oLightReader.MoveToStart(); - m_oLightReader.ReadNextNode(); - ReadStyle(); + std::shared_ptr oPreformatted{std::make_shared>(pWriter)}; - // Переходим в начало - if(!m_oLightReader.MoveToStart()) - return S_FALSE; + m_mTags[HTML_TAG(PRE)] = oPreformatted; + m_mTags[HTML_TAG(KBD)] = oPreformatted; - // if(oParams && oParams->m_bNeedPageBreakBefore) - // m_internal->PageBreakBefore(); + std::shared_ptr oIgnoredTag{std::make_shared()}; - ReadDocument(); - - m_pInterpretator->End(wsTo); - return S_OK; + m_mTags[HTML_TAG(ABBR)] = oIgnoredTag; + m_mTags[HTML_TAG(DIV)] = oIgnoredTag; + m_mTags[HTML_TAG(FONT)] = oIgnoredTag; + m_mTags[HTML_TAG(INPUT)] = oIgnoredTag; + m_mTags[HTML_TAG(BASEFONT)] = oIgnoredTag; + m_mTags[HTML_TAG(CENTER)] = oIgnoredTag; + m_mTags[HTML_TAG(MARK)] = oIgnoredTag; + m_mTags[HTML_TAG(SUP)] = oIgnoredTag; + m_mTags[HTML_TAG(DD)] = oIgnoredTag; + m_mTags[HTML_TAG(BDO)] = oIgnoredTag; + m_mTags[HTML_TAG(SPAN)] = oIgnoredTag; + m_mTags[HTML_TAG(CAPTION)] = oIgnoredTag; } bool CHTMLReader::IsHTML() @@ -455,7 +510,7 @@ bool CHTMLReader::ReadStream(std::vector& arSelectors, bool bInser if (!bInsertEmptyP) return false; - m_pInterpretator->WriteEmptyParagraph(); + m_pWriter->WriteEmptyParagraph(); return true; // WriteEmptyParagraph(sSelectors, oTS); @@ -479,7 +534,7 @@ bool CHTMLReader::ReadStream(std::vector& arSelectors, bool bInser } while(m_oLightReader.ReadNextSiblingNode2(nDeath)); if (!bResult && bInsertEmptyP) - m_pInterpretator->WriteEmptyParagraph(); + m_pWriter->WriteEmptyParagraph(); return bResult; } @@ -660,7 +715,7 @@ bool CHTMLReader::ReadInside(std::vector& arSelectors) } default: { - m_pInterpretator->BeginBlock(); + m_pWriter->BeginBlock(); switch(eHtmlTag) { @@ -773,7 +828,7 @@ bool CHTMLReader::ReadInside(std::vector& arSelectors) } } - m_pInterpretator->EndBlock(bResult); + m_pWriter->EndBlock(bResult); } } @@ -792,12 +847,12 @@ bool CHTMLReader::ReadInside(std::vector& arSelectors) bool CHTMLReader::ReadText(std::vector& arSelectors) { - if (nullptr == m_pInterpretator) + if (nullptr == m_pWriter) return false; GetSubClass(arSelectors); - const bool bResult{m_pInterpretator->WriteText(m_oLightReader.GetText(), arSelectors)}; + const bool bResult{m_pWriter->WriteText(m_oLightReader.GetText(), arSelectors)}; arSelectors.pop_back(); @@ -806,11 +861,11 @@ bool CHTMLReader::ReadText(std::vector& arSelectors) bool CHTMLReader::ReadAnchor(std::vector& arSelectors) { - if (!m_mTags[HTML_TAG(A)]->Open(arSelectors)) + if (nullptr == m_pWriter || !m_mTags[HTML_TAG(A)]->Open(arSelectors)) return false; if (!ReadStream(arSelectors)) - m_pInterpretator->WriteEmptyParagraph(true); + m_pWriter->WriteEmptyParagraph(true); m_mTags[HTML_TAG(A)]->Close(arSelectors); @@ -819,7 +874,7 @@ bool CHTMLReader::ReadAnchor(std::vector& arSelectors) bool CHTMLReader::ReadSVG(const std::vector& arSelectors) { - if (!m_mTags[HTML_TAG(IMAGE)]->Open(arSelectors, &m_oLightReader)) + if (!m_mTags[HTML_TAG(IMAGE)]->Open(arSelectors, m_oLightReader.GetOuterXml())) return false; m_mTags[HTML_TAG(IMAGE)]->Close(arSelectors); @@ -959,23 +1014,30 @@ bool CHTMLReader::ReadTable(std::vector& arSelectors) \ for (UINT unRow = 0; unRow < arRows.size(); ++unRow)\ {\ - if (!m_mTags[HTML_TAG(TR)]->Open(arSelectors, boost::tuple(*arRows[unRow], oTable)))\ - continue;\ - \ - const std::vector& arCells{arRows[unRow]->GetCells()};\ ERowPosition eRowPosition{ERowPosition::Middle};\ - \ + \ if (0 == unRow)\ eRowPosition = ERowPosition::First;\ else if (arRows.size() - 1 == unRow)\ eRowPosition = ERowPosition::Last;\ - \ + \ + if (!m_mTags[HTML_TAG(TR)]->Open(arSelectors, boost::tuple(arRows[unRow]->GetStyles(), oTable, parse_mode, eRowPosition)))\ + continue;\ + \ + const std::vector& arCells{arRows[unRow]->GetCells()};\ + \ for (UINT unCol = 0; unCol < arCells.size(); ++unCol)\ {\ m_mTags[HTML_TAG(TD)]->Open(arSelectors, boost::tuple(*arCells[unCol], oTable, unCol, parse_mode, eRowPosition));\ + \ + if (0 != arCells[unCol]->GetData()->GetCurSize())\ + WriteToStringBuilder(*(arCells[unCol]->GetData()), *(m_pWriter->GetCurrentDocument()));\ + else\ + m_pWriter->WriteEmptyParagraph();\ + \ m_mTags[HTML_TAG(TD)]->Close(arSelectors);\ }\ - \ + \ m_mTags[HTML_TAG(TR)]->Close(arSelectors);\ }} @@ -992,17 +1054,17 @@ bool CHTMLReader::ReadTable(std::vector& arSelectors) void CHTMLReader::ReadTableCaption(CStorageTable& oTable, std::vector& arSelectors) { - if (nullptr == m_pInterpretator) + if (nullptr == m_pWriter) return; GetSubClass(arSelectors); - m_pInterpretator->SetDataOutput(oTable.GetCaptionData()); + m_pWriter->SetDataOutput(oTable.GetCaptionData()); arSelectors.back().m_pCompiledStyle->m_oDisplay.SetVAlign(L"center", arSelectors.size()); ReadDefaultTag(HTML_TAG(CAPTION), arSelectors); - m_pInterpretator->RevertDataOutput(); + m_pWriter->RevertDataOutput(); arSelectors.pop_back(); } @@ -1036,6 +1098,9 @@ struct TRowspanElement void CHTMLReader::ReadTableRows(CStorageTable& oTable, std::vector& arSelectors, ERowParseMode eMode) { + if (nullptr == m_pWriter) + return; + std::vector arRowspanElements; std::vector arRows; @@ -1096,16 +1161,16 @@ void CHTMLReader::ReadTableRows(CStorageTable& oTable, std::vector arSelectors.back().m_pCompiledStyle->m_oFont.SetWeight(L"bold", arSelectors.size()); - m_pInterpretator->SetDataOutput(pCell->GetData()); + m_pWriter->SetDataOutput(pCell->GetData()); ReadStream(arSelectors, true); - m_pInterpretator->RevertDataOutput(); + m_pWriter->RevertDataOutput(); } // Читаем td. Ячейка таблицы else if(m_oLightReader.GetName() == L"td") { - m_pInterpretator->SetDataOutput(pCell->GetData()); + m_pWriter->SetDataOutput(pCell->GetData()); ReadStream(arSelectors, true); - m_pInterpretator->RevertDataOutput(); + m_pWriter->RevertDataOutput(); } if (pRow->GetIndex() == MAXCOLUMNSINTABLE - 1) @@ -1116,9 +1181,9 @@ void CHTMLReader::ReadTableRows(CStorageTable& oTable, std::vector continue; GetSubClass(arSelectors); - m_pInterpretator->SetDataOutput(pCell->GetData()); + m_pWriter->SetDataOutput(pCell->GetData()); ReadStream(arSelectors); - m_pInterpretator->RevertDataOutput(); + m_pWriter->RevertDataOutput(); arSelectors.pop_back(); } } diff --git a/HtmlFile2/HTMLReader.h b/HtmlFile2/HTMLReader.h index 8bacf599d0..7947360a2f 100644 --- a/HtmlFile2/HTMLReader.h +++ b/HtmlFile2/HTMLReader.h @@ -4,7 +4,7 @@ #include "../Common/3dParty/html/css/src/CCssCalculator.h" #include "../DesktopEditor/xml/include/xmlutils.h" -#include "Interpretators/HTMLInterpretator.h" +#include "Writers/IWriter.h" #include "Tags/HTMLTags.h" #include "Table.h" @@ -21,19 +21,20 @@ class CHTMLReader std::wstring m_sBase; // Полный базовый адрес std::wstring m_sCore; // Путь до корневого файла (используется для работы с Epub) - IHTMLInterpretator *m_pInterpretator; + IWriter *m_pWriter; std::unordered_map> m_mTags; public: CHTMLReader(); ~CHTMLReader(); - void SetInterpretator(IHTMLInterpretator* pInterpretator); - HRESULT ConvertFromTo(const std::wstring& wsFrom, const std::wstring& wsTo); NSCSS::CCssCalculator* GetCSSCalculator(); private: + void InitOOXMLTags(); + void InitMDTags(); + bool IsHTML(); bool HTML2XHTML(const std::wstring& wsFileName); diff --git a/HtmlFile2/HtmlFile2.pro b/HtmlFile2/HtmlFile2.pro index 8ff371f1dd..0c5f42e605 100644 --- a/HtmlFile2/HtmlFile2.pro +++ b/HtmlFile2/HtmlFile2.pro @@ -33,8 +33,10 @@ include($$CORE_ROOT_DIR/Common/3dParty/boost/boost.pri) ADD_DEPENDENCY(kernel, UnicodeConverter, graphics, kernel_network) SOURCES += htmlfile2.cpp \ - ./Interpretators/OOXMLInterpretator.cpp \ + ./Writers/OOXMLWriter.cpp \ HTMLReader.cpp \ + Tags/MDTags.cpp \ + Writers/MDWriter.cpp \ Table.cpp \ Tags/OOXMLTags.cpp @@ -42,10 +44,12 @@ HEADERS += htmlfile2.h \ ./src/StringFinder.h \ ./src/Languages.h \ Common.h \ - ./Interpretators/OOXMLInterpretator.h \ - ./Interpretators/HTMLInterpretator.h \ + ./Writers/OOXMLWriter.h \ + ./Writers/IWriter.h \ HTMLParams.h \ HTMLReader.h \ ./Tags/HTMLTags.h \ + Tags/MDTags.h \ + Writers/MDWriter.h \ Table.h \ Tags/OOXMLTags.h diff --git a/HtmlFile2/Table.cpp b/HtmlFile2/Table.cpp index 873660e47f..90ef6fea73 100644 --- a/HtmlFile2/Table.cpp +++ b/HtmlFile2/Table.cpp @@ -600,8 +600,15 @@ void CStorageTable::AddColgroup(CTableColgroup* pElement) void CStorageTable::RecalculateMaxColumns() { + for (const std::vector& arHeaders : m_arHeaders) + for (const CStorageTableRow* pHeader : arHeaders) + m_unMaxColumns = std::max(m_unMaxColumns, pHeader->GetIndex()); + for (const CStorageTableRow* pRow : m_arRows) m_unMaxColumns = std::max(m_unMaxColumns, pRow->GetIndex()); + + for (const CStorageTableRow* pFoother : m_arFoother) + m_unMaxColumns = std::max(m_unMaxColumns, pFoother->GetIndex()); } void CStorageTable::Shorten() diff --git a/HtmlFile2/Tags/HTMLTags.h b/HtmlFile2/Tags/HTMLTags.h index fe568d2e63..f0ee9c9e9f 100644 --- a/HtmlFile2/Tags/HTMLTags.h +++ b/HtmlFile2/Tags/HTMLTags.h @@ -29,10 +29,10 @@ template class CTag : public ITag { protected: - T* m_pInterpretator; + T* m_pWriter; public: - CTag(T* pInterpretator) - : m_pInterpretator(pInterpretator) + CTag(T* pWriter) + : m_pWriter(pWriter) {} virtual ~CTag() = default; virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) = 0; @@ -40,7 +40,7 @@ public: bool ValidInterpretator() const { - return nullptr != m_pInterpretator; + return nullptr != m_pWriter; } }; diff --git a/HtmlFile2/Tags/MDTags.cpp b/HtmlFile2/Tags/MDTags.cpp new file mode 100644 index 0000000000..3e7a47354a --- /dev/null +++ b/HtmlFile2/Tags/MDTags.cpp @@ -0,0 +1,388 @@ +#include "MDTags.h" + +#include "../Table.h" + +#include + +namespace HTML +{ +CAnchor::CAnchor(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CAnchor::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'['); + return true; +} + +void CAnchor::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + XmlString* pCurrentDocument{m_pWriter->GetCurrentDocument()}; + + pCurrentDocument->AddCharSafe(L']'); + + std::wstring wsHref, wsTitle; + + if (!arSelectors.back().GetAttributeValue(L"href", wsHref) || + !arSelectors.back().GetAttributeValue(L"title", wsTitle)) + return; + + pCurrentDocument->WriteString(L'(' + wsHref); + + if (!wsTitle.empty()) + pCurrentDocument->WriteString(L" \"" + wsTitle + L'"'); + + pCurrentDocument->AddCharSafe(L')'); +} + +CBold::CBold(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CBold::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->WriteString(L"**"); + + return true; +} + +void CBold::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->WriteString(L"**"); +} + +CBreak::CBreak(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CBreak::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->WriteString(m_pWriter->GetParametrs().m_wsLineBreak); + + return true; +} + +void CBreak::Close(const std::vector& arSelectors) +{} + +CItalic::CItalic(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CItalic::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'*'); + + return true; +} + +void CItalic::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'*'); +} + +CStrike::CStrike(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CStrike::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->WriteString(L"~~"); + + return true; +} + +void CStrike::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->WriteString(L"~~"); +} + +CUnderline::CUnderline(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CUnderline::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + if (m_pWriter->GetParametrs().m_bUseAlternativeHTMLTags) + m_pWriter->GetCurrentDocument()->WriteString(L""); + + return true; +} + +void CUnderline::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + if (m_pWriter->GetParametrs().m_bUseAlternativeHTMLTags) + m_pWriter->GetCurrentDocument()->WriteString(L""); +} + +CQuotation::CQuotation(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CQuotation::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'>'); + + return true; +} + +void CQuotation::Close(const std::vector& arSelectors) +{} + +CPreformatted::CPreformatted(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CPreformatted::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->WriteString(L"```" + m_pWriter->GetParametrs().m_wsLineBreak); + + return true; +} + +void CPreformatted::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->WriteString(m_pWriter->GetParametrs().m_wsLineBreak + L"```" + m_pWriter->GetParametrs().m_wsLineBreak); +} + +CHeader::CHeader(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CHeader::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + switch(arSelectors.back().m_wsName[1]) + { + case L'1' : m_pWriter->GetCurrentDocument()->WriteString(L"# "); break; + case L'2' : m_pWriter->GetCurrentDocument()->WriteString(L"## "); break; + case L'3' : m_pWriter->GetCurrentDocument()->WriteString(L"### "); break; + case L'4' : m_pWriter->GetCurrentDocument()->WriteString(L"#### "); break; + case L'5' : m_pWriter->GetCurrentDocument()->WriteString(L"##### "); break; + case L'6' : m_pWriter->GetCurrentDocument()->WriteString(L"###### "); break; + default: + return false; + } + + return true; +} + +void CHeader::Close(const std::vector& arSelectors) +{} + +CImage::CImage(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CImage::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + std::wstring wsAlt, wsSrc, wsTitle; + + if (!arSelectors.back().GetAttributeValue(L"src", wsSrc) && + !arSelectors.back().GetAttributeValue(L"alt", wsAlt)) + return false; + + arSelectors.back().GetAttributeValue(L"title", wsTitle); + + XmlString* pCurrentDocument{m_pWriter->GetCurrentDocument()}; + + pCurrentDocument->WriteString(L"![" + wsAlt + L"](" + wsSrc); + + if (!wsTitle.empty()) + pCurrentDocument->WriteString(L" \"" + wsTitle + L'"'); + + pCurrentDocument->AddCharSafe(L')'); + + return true; +} + +void CImage::Close(const std::vector& arSelectors) +{} + +CHorizontalRule::CHorizontalRule(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool HTML::CHorizontalRule::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + m_pWriter->GetCurrentDocument()->WriteString(L"\n\n---\n\n"); + + return true; +} + +void CHorizontalRule::Close(const std::vector& arSelectors) +{} + +CBlockquote::CBlockquote(CMDWriter* pWriter) + : CTag(pWriter), m_unIndex(0) +{} + +bool CBlockquote::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + ++m_unIndex; + + XmlString* pCurrentDocument{m_pWriter->GetCurrentDocument()}; + + pCurrentDocument->WriteString(m_pWriter->GetParametrs().m_wsLineBreak); + + for (UINT unIndex = 0; unIndex < m_unIndex; ++m_unIndex) + pCurrentDocument->WriteString(L"> "); + + return true; +} + +void CBlockquote::Close(const std::vector& arSelectors) +{ + --m_unIndex; +} + +CTable::CTable(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CTable::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + //В MD не поддерживаются вложенные таблицы + for (std::vector::const_iterator itElement = arSelectors.cbegin(); itElement < arSelectors.cend() - 1; ++itElement) + if (L"table" == itElement->m_wsName) + return false; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'\n'); + + return true; +} + +void CTable::Close(const std::vector& arSelectors) +{ + m_pWriter->GetCurrentDocument()->AddCharSafe(L'\n'); +} + +CTableRow::CTableRow(CMDWriter* pWriter) + : CTag(pWriter), m_unLastRowType(static_cast(ERowParseMode::Foother)) +{} + +bool CTableRow::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + using DataForRow = boost::tuple; + + if (!ValidInterpretator() || oExtraData.empty() || typeid(DataForRow) != oExtraData.type()) + return false; + + const DataForRow& oDataForRow(boost::any_cast(oExtraData)); + const CStorageTable& oStorageTable{boost::get<1>(oDataForRow)}; + XmlString* pCurrentDocument{m_pWriter->GetCurrentDocument()}; + + if (m_unLastRowType == static_cast(ERowParseMode::Header)) + { + for (UINT unIndex = 0; unIndex < oStorageTable.GetMaxColumns(); ++unIndex) + pCurrentDocument->WriteString(L"|-"); + + pCurrentDocument->WriteString(L"|\n"); + } + else if (ERowParseMode::Header != boost::get<2>(oDataForRow) && + ERowPosition::First == boost::get<3>(oDataForRow) && + m_unLastRowType == static_cast(ERowParseMode::Foother)) + { + for (UINT unIndex = 0; unIndex < oStorageTable.GetMaxColumns(); ++unIndex) + pCurrentDocument->WriteString(L"| "); + + pCurrentDocument->WriteString(L"|\n"); + + for (UINT unIndex = 0; unIndex < oStorageTable.GetMaxColumns(); ++unIndex) + pCurrentDocument->WriteString(L"|-"); + + pCurrentDocument->WriteString(L"|\n"); + } + + m_unLastRowType = static_cast(boost::get<2>(oDataForRow)); + + pCurrentDocument->WriteString(L"| "); + + return true; +} + +void CTableRow::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->AddCharSafe(L'\n'); +} + +CTableCell::CTableCell(CMDWriter* pWriter) + : CTag(pWriter) +{} + +bool CTableCell::Open(const std::vector& arSelectors, const boost::any& oExtraData) +{ + if (!ValidInterpretator()) + return false; + + return true; +} + +void CTableCell::Close(const std::vector& arSelectors) +{ + if (!ValidInterpretator()) + return; + + m_pWriter->GetCurrentDocument()->WriteString(L" | "); +} +} diff --git a/HtmlFile2/Tags/MDTags.h b/HtmlFile2/Tags/MDTags.h new file mode 100644 index 0000000000..6aca499b75 --- /dev/null +++ b/HtmlFile2/Tags/MDTags.h @@ -0,0 +1,147 @@ +#ifndef MDTAGS_H +#define MDTAGS_H + +#include "HTMLTags.h" +#include "../Writers/MDWriter.h" + +namespace HTML +{ +template<> +class CAnchor : public CTag +{ +public: + CAnchor(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CBold : public CTag +{ +public: + CBold(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CBreak : public CTag +{ +public: + CBreak(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CItalic : public CTag +{ +public: + CItalic(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CStrike : public CTag +{ +public: + CStrike(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CUnderline : public CTag +{ +public: + CUnderline(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CQuotation : public CTag +{ +public: + CQuotation(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CPreformatted : public CTag +{ +public: + CPreformatted(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CHeader : public CTag +{ +public: + CHeader(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CImage : public CTag +{ +public: + CImage(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CHorizontalRule : public CTag +{ +public: + CHorizontalRule(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CBlockquote : public CTag +{ + UINT m_unIndex; +public: + CBlockquote(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CTable : public CTag +{ +public: + CTable(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CTableRow : public CTag +{ + UINT m_unLastRowType; +public: + CTableRow(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; + +template<> +class CTableCell : public CTag +{ +public: + CTableCell(CMDWriter* pWriter); + virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; + virtual void Close(const std::vector& arSelectors) override; +}; +} + +#endif // MDTAGS_H diff --git a/HtmlFile2/Tags/OOXMLTags.cpp b/HtmlFile2/Tags/OOXMLTags.cpp index 4a2d527afd..355d1301a0 100644 --- a/HtmlFile2/Tags/OOXMLTags.cpp +++ b/HtmlFile2/Tags/OOXMLTags.cpp @@ -5,7 +5,6 @@ #include "../../Common/Network/FileTransporter/include/FileTransporter.h" -#include "../../DesktopEditor/xml/include/xmlutils.h" #include "../../DesktopEditor/raster/BgraFrame.h" #include "../../DesktopEditor/graphics/pro/Graphics.h" #include "../../DesktopEditor/common/Base64.h" @@ -34,11 +33,11 @@ bool UpdateImageData(const std::wstring& wsImagePath, TImageData& oImageData); const static double HTML_FONTS[7] = {7.5, 10, 12, 13.5, 18, 24, 36}; -CAnchor::CAnchor(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CAnchor::CAnchor(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CAnchor::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CAnchor::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -50,29 +49,29 @@ bool CAnchor::Open(const std::vector& arSelec bCross = true; if (arSelectors.back().GetAttributeValue(L"name", wsName)) - m_pInterpretator->WriteBookmark(wsName); + m_pWriter->WriteBookmark(wsName); arSelectors.back().GetAttributeValue(L"alt", wsAlt); - if (!m_pInterpretator->OpenP()) - m_pInterpretator->CloseR(); + if (!m_pWriter->OpenP()) + m_pWriter->CloseR(); else - m_pInterpretator->WritePPr(arSelectors); + m_pWriter->WritePPr(arSelectors); if (bCross) - m_pInterpretator->OpenCrossHyperlink(wsRef, arSelectors); + m_pWriter->OpenCrossHyperlink(wsRef, arSelectors); else { std::wstring wsTooltip(wsRef); arSelectors.back().GetAttributeValue(L"title", wsTooltip); - m_pInterpretator->OpenExternalHyperlink(wsRef, wsTooltip, arSelectors); + m_pWriter->OpenExternalHyperlink(wsRef, wsTooltip, arSelectors); } return true; } -void CAnchor::Close(const std::vector& arSelectors) +void CAnchor::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; @@ -101,17 +100,17 @@ void CAnchor::Close(const std::vector& arSele if (wsFootnote == L"href") wsFootnote = wsRef.substr(wsRef.find('#') + 1); - m_pInterpretator->CloseCrossHyperlink(arSelectors, wsFootnote, wsRef); + m_pWriter->CloseCrossHyperlink(arSelectors, wsFootnote, wsRef); } else - m_pInterpretator->CloseExternalHyperlink(); + m_pWriter->CloseExternalHyperlink(); } -CAbbr::CAbbr(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CAbbr::CAbbr(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CAbbr::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CAbbr::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -121,11 +120,11 @@ bool CAbbr::Open(const std::vector& arSelecto if (!arSelectors.back().GetAttributeValue(L"title", wsTitle)) return false; - m_pInterpretator->WritePPr(arSelectors); + m_pWriter->WritePPr(arSelectors); - XmlString* pCurrentDocument{&m_pInterpretator->GetCurrentDocument()}; + XmlString* pCurrentDocument{m_pWriter->GetCurrentDocument()}; - pCurrentDocument->WriteString(L"HYPERLINK \\l \"" + m_pInterpretator->AddLiteBookmark() + L"\" \\o \""); + pCurrentDocument->WriteString(L"HYPERLINK \\l \"" + m_pWriter->AddLiteBookmark() + L"\" \\o \""); pCurrentDocument->WriteEncodeXmlString(wsTitle); pCurrentDocument->WriteString(L"\""); pCurrentDocument->WriteString(L""); @@ -133,41 +132,41 @@ bool CAbbr::Open(const std::vector& arSelecto return true; } -void CAbbr::Close(const std::vector& arSelectors) +void CAbbr::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->GetCurrentDocument().WriteString(L""); + m_pWriter->GetCurrentDocument()->WriteString(L""); } -CBreak::CBreak(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CBreak::CBreak(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CBreak::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CBreak::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; - m_pInterpretator->Break(arSelectors); + m_pWriter->Break(arSelectors); return true; } -void CBreak::Close(const std::vector& arSelectors) +void CBreak::Close(const std::vector& arSelectors) {} -CDivision::CDivision(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CDivision::CDivision(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CDivision::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CDivision::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; - m_pInterpretator->UpdatePageStyle(arSelectors); + m_pWriter->UpdatePageStyle(arSelectors); UINT unMsoFootnote = 0; @@ -181,15 +180,15 @@ bool CDivision::Open(const std::vector& arSel if (!arSelectors.back().m_wsId.empty()) { - wsFootnoteID = m_pInterpretator->FindFootnote(arSelectors.back().m_wsId); + wsFootnoteID = m_pWriter->FindFootnote(arSelectors.back().m_wsId); if (!wsFootnoteID.empty()) ++unMsoFootnote; if (unMsoFootnote >= 2 && !wsFootnoteID.empty()) { - m_pInterpretator->OpenFootnote(wsFootnoteID); - m_pInterpretator->SetCurrentDocument(&m_pInterpretator->GetNotesXml()); + m_pWriter->OpenFootnote(wsFootnoteID); + m_pWriter->SetCurrentDocument(&m_pWriter->GetNotesXml()); } } @@ -198,50 +197,45 @@ bool CDivision::Open(const std::vector& arSel return true; } -void CDivision::Close(const std::vector& arSelectors) +void CDivision::Close(const std::vector& arSelectors) { if (!ValidInterpretator() || m_arFootnoteIDs.empty()) return; if (m_arFootnoteIDs.top() >= 2) { - m_pInterpretator->CloseFootnote(); - m_pInterpretator->RollBackState(); + m_pWriter->CloseFootnote(); + m_pWriter->RollBackState(); } m_arFootnoteIDs.pop(); } -CImage::CImage(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CImage::CImage(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CImage::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CImage::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; if (L"svg" == arSelectors.back().m_wsName) { - if (oExtraData.empty() || typeid(XmlUtils::CXmlLiteReader*) != oExtraData.type()) + if (oExtraData.empty() || typeid(const std::wstring&) != oExtraData.type()) return false; - XmlUtils::CXmlLiteReader *pXmlReader{boost::any_cast(oExtraData)}; + const std::wstring wsImagePath{m_pWriter->GetMediaDir() + L'i' + std::to_wstring(m_arrImages.size()) + L".png"}; - if (nullptr == pXmlReader) - return false; - - const std::wstring wsImagePath{m_pInterpretator->GetMediaDir() + L'i' + std::to_wstring(m_arrImages.size()) + L".png"}; - - if (!ReadSVG(pXmlReader->GetOuterXml(), m_pInterpretator->GetFonts(), m_pInterpretator->GetTempDir(), wsImagePath)) + if (!ReadSVG(boost::any_cast(oExtraData), m_pWriter->GetFonts(), m_pWriter->GetTempDir(), wsImagePath)) return false; TImageData oNewImageData; if (!UpdateImageData(wsImagePath, oNewImageData)) return false; - m_pInterpretator->WritePPr(arSelectors); - m_pInterpretator->WriteImage(oNewImageData, std::to_wstring(m_arrImages.size())); + m_pWriter->WritePPr(arSelectors); + m_pWriter->WriteImage(oNewImageData, std::to_wstring(m_arrImages.size())); return true; } @@ -292,17 +286,17 @@ bool CImage::Open(const std::vector& arSelect if (wsSrc.empty()) { - m_pInterpretator->WriteAlternativeImage(wsAlt, wsSrc, oImageData); + m_pWriter->WriteAlternativeImage(wsAlt, wsSrc, oImageData); return true; } bool bRes = false; std::wstring wsExtention; - const std::wstring wsImagePath{m_pInterpretator->GetMediaDir() + L'i' + std::to_wstring(m_arrImages.size())}; + const std::wstring wsImagePath{m_pWriter->GetMediaDir() + L'i' + std::to_wstring(m_arrImages.size())}; // Предполагаем картинку в Base64 if (wsSrc.length() > 4 && wsSrc.substr(0, 4) == L"data" && wsSrc.find(L"/", 4) != std::wstring::npos) - bRes = ReadBase64(wsSrc, wsImagePath, m_pInterpretator->GetFonts(), m_pInterpretator->GetTempDir(), wsExtention); + bRes = ReadBase64(wsSrc, wsImagePath, m_pWriter->GetFonts(), m_pWriter->GetTempDir(), wsExtention); const bool bIsAllowExternalLocalFiles = GetStatusUsingExternalLocalFiles(); @@ -310,9 +304,9 @@ bool CImage::Open(const std::vector& arSelect { wsSrc = NSSystemPath::ShortenPath(wsSrc); - if (!CanUseThisPath(wsSrc, m_pInterpretator->GetSrcPath(), m_pInterpretator->GetCorePath(), bIsAllowExternalLocalFiles)) + if (!CanUseThisPath(wsSrc, m_pWriter->GetSrcPath(), m_pWriter->GetCorePath(), bIsAllowExternalLocalFiles)) { - m_pInterpretator->WriteAlternativeImage(wsAlt, wsSrc, oImageData); + m_pWriter->WriteAlternativeImage(wsAlt, wsSrc, oImageData); return true; } } @@ -329,7 +323,7 @@ bool CImage::Open(const std::vector& arSelect wsExtention.erase(itFound, wsExtention.cend()); } - const std::wstring wsBasePath{m_pInterpretator->GetBasePath()}; + const std::wstring wsBasePath{m_pWriter->GetBasePath()}; // Предполагаем картинку в сети if (!bRes && @@ -339,13 +333,13 @@ bool CImage::Open(const std::vector& arSelect const std::wstring wsDst = wsImagePath + L'.' + ((!wsExtention.empty()) ? wsExtention : L"png"); // Проверка gc_allowNetworkRequest предполагается в kernel_network - NSNetwork::NSFileTransport::CFileDownloader oDownloadImg(m_pInterpretator->GetBasePath() + wsSrc, false); + NSNetwork::NSFileTransport::CFileDownloader oDownloadImg(m_pWriter->GetBasePath() + wsSrc, false); oDownloadImg.SetFilePath(wsDst); bRes = oDownloadImg.DownloadSync(); if (!bRes) { - m_pInterpretator->WriteAlternativeImage(wsAlt, wsSrc, oImageData); + m_pWriter->WriteAlternativeImage(wsAlt, wsSrc, oImageData); return true; } @@ -354,7 +348,7 @@ bool CImage::Open(const std::vector& arSelect std::wstring wsFileData; if (!NSFile::CFileBinary::ReadAllTextUtf8(wsDst, wsFileData) || - !ReadSVG(wsFileData, m_pInterpretator->GetFonts(), m_pInterpretator->GetTempDir(), wsImagePath)) + !ReadSVG(wsFileData, m_pWriter->GetFonts(), m_pWriter->GetTempDir(), wsImagePath)) bRes = false; NSFile::CFileBinary::Remove(wsDst); @@ -373,7 +367,7 @@ bool CImage::Open(const std::vector& arSelect { if (NotValidExtension(wsExtention)) { - m_pInterpretator->WriteAlternativeImage(wsAlt, wsSrc, oImageData); + m_pWriter->WriteAlternativeImage(wsAlt, wsSrc, oImageData); return true; } @@ -391,40 +385,40 @@ bool CImage::Open(const std::vector& arSelect { const std::wstring wsDst = wsImagePath + L'.' + wsExtention; - if (!m_pInterpretator->GetBasePath().empty()) + if (!m_pWriter->GetBasePath().empty()) { if (!bRes) - bRes = CopyImage(NSSystemPath::Combine(m_pInterpretator->GetBasePath(), wsSrc), m_pInterpretator->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); + bRes = CopyImage(NSSystemPath::Combine(m_pWriter->GetBasePath(), wsSrc), m_pWriter->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); if (!bRes) - bRes = CopyImage(NSSystemPath::Combine(m_pInterpretator->GetSrcPath(), NSSystemPath::Combine(m_pInterpretator->GetBasePath(), wsSrc)), m_pInterpretator->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); + bRes = CopyImage(NSSystemPath::Combine(m_pWriter->GetSrcPath(), NSSystemPath::Combine(m_pWriter->GetBasePath(), wsSrc)), m_pWriter->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); } if (!bRes) - bRes = CopyImage(NSSystemPath::Combine(m_pInterpretator->GetSrcPath(), wsSrc), m_pInterpretator->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); + bRes = CopyImage(NSSystemPath::Combine(m_pWriter->GetSrcPath(), wsSrc), m_pWriter->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); if (!bRes) - bRes = CopyImage(m_pInterpretator->GetSrcPath() + L"/" + NSFile::GetFileName(wsSrc), m_pInterpretator->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); + bRes = CopyImage(m_pWriter->GetSrcPath() + L"/" + NSFile::GetFileName(wsSrc), m_pWriter->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); if (!bRes) - bRes = CopyImage(wsSrc, m_pInterpretator->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); + bRes = CopyImage(wsSrc, m_pWriter->GetSrcPath(), wsDst, bIsAllowExternalLocalFiles); } if (!bRes) - m_pInterpretator->WriteAlternativeImage(wsAlt, wsSrc, oImageData); + m_pWriter->WriteAlternativeImage(wsAlt, wsSrc, oImageData); else { m_arrImages.push_back(wsSrc); - m_pInterpretator->WritePPr(arSelectors); + m_pWriter->WritePPr(arSelectors); const std::wstring wsImageID{std::to_wstring(m_arrImages.size())}; if (nImageId < 0) { - m_pInterpretator->WriteImageRels(wsImageID, wsImageID + L'.' + wsExtention); + m_pWriter->WriteImageRels(wsImageID, wsImageID + L'.' + wsExtention); m_arrImages.push_back(wsSrc); } if (!oImageData.ZeroSize()) { - m_pInterpretator->WriteImage(oImageData, wsImageID); + m_pWriter->WriteImage(oImageData, wsImageID); return true; } @@ -432,20 +426,20 @@ bool CImage::Open(const std::vector& arSelect if (!UpdateImageData(wsImagePath + L'.' + wsExtention, oNewImageData)) return false; - m_pInterpretator->WriteImage(oNewImageData, wsImageID); + m_pWriter->WriteImage(oNewImageData, wsImageID); } return true; } -void CImage::Close(const std::vector& arSelectors) +void CImage::Close(const std::vector& arSelectors) {} -CFont::CFont(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CFont::CFont(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CFont::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CFont::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -480,14 +474,14 @@ bool CFont::Open(const std::vector& arSelecto return true; } -void CFont::Close(const std::vector& arSelectors) +void CFont::Close(const std::vector& arSelectors) {} -CInput::CInput(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CInput::CInput(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CInput::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CInput::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -504,26 +498,26 @@ bool CInput::Open(const std::vector& arSelect if(!wsValue.empty()) { - m_pInterpretator->WritePPr(arSelectors); - m_pInterpretator->OpenR(); - m_pInterpretator->WriteRPr(m_pInterpretator->GetCurrentDocument(), arSelectors); - m_pInterpretator->OpenT(); - m_pInterpretator->GetCurrentDocument().WriteEncodeXmlString(wsValue + L' '); - m_pInterpretator->CloseT(); - m_pInterpretator->CloseR(); + m_pWriter->WritePPr(arSelectors); + m_pWriter->OpenR(); + m_pWriter->WriteRPr(*(m_pWriter->GetCurrentDocument()), arSelectors); + m_pWriter->OpenT(); + m_pWriter->GetCurrentDocument()->WriteEncodeXmlString(wsValue + L' '); + m_pWriter->CloseT(); + m_pWriter->CloseR(); } return true; } -void CInput::Close(const std::vector& arSelectors) +void CInput::Close(const std::vector& arSelectors) {} -CBaseFont::CBaseFont(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CBaseFont::CBaseFont(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CBaseFont::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CBaseFont::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -556,19 +550,19 @@ bool CBaseFont::Open(const std::vector& arSel if (wsFontStyles.empty()) return false; - m_pInterpretator->SetBaseFont(L"*{" + wsFontStyles + L'}'); + m_pWriter->SetBaseFont(L"*{" + wsFontStyles + L'}'); return true; } -void CBaseFont::Close(const std::vector& arSelectors) +void CBaseFont::Close(const std::vector& arSelectors) {} -CBlockquote::CBlockquote(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CBlockquote::CBlockquote(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CBlockquote::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CBlockquote::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -579,13 +573,13 @@ bool CBlockquote::Open(const std::vector& arS if (m_mDivs.end() != itFound) { - m_pInterpretator->SetDivId(std::to_wstring(itFound->second)); + m_pWriter->SetDivId(std::to_wstring(itFound->second)); return true; } const std::wstring wsId{std::to_wstring(m_mDivs.size() + 1)}; - XmlString &oWebSettings{m_pInterpretator->GetWebSettingsXml()}; + XmlString &oWebSettings{m_pWriter->GetWebSettingsXml()}; if (m_mDivs.empty()) oWebSettings.WriteString(L""); @@ -599,7 +593,7 @@ bool CBlockquote::Open(const std::vector& arS INT nMarTop = (!bInTable) ? 100 : 0; INT nMarBottom = (!bInTable) ? 100 : 0; - const NSCSS::NSProperties::CPage *pPageData{m_pInterpretator->GetPageData()}; + const NSCSS::NSProperties::CPage *pPageData{m_pWriter->GetPageData()}; if (!pStyle->m_oMargin.GetLeft().Empty() && !pStyle->m_oMargin.GetLeft().Zero()) nMarLeft = pStyle->m_oMargin.GetLeft().ToInt(NSCSS::Twips, pPageData->GetWidth().ToInt(NSCSS::Twips)); @@ -632,24 +626,24 @@ bool CBlockquote::Open(const std::vector& arS m_mDivs.insert(std::make_pair(wsKeyWord, m_mDivs.size() + 1)); - m_pInterpretator->SetDivId(wsId); + m_pWriter->SetDivId(wsId); return true; } -void CBlockquote::Close(const std::vector& arSelectors) +void CBlockquote::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->RollBackDivId(); + m_pWriter->RollBackDivId(); } -CHorizontalRule::CHorizontalRule(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator), m_unShapeId(1) +CHorizontalRule::CHorizontalRule(COOXMLWriter* pWriter) + : CTag(pWriter), m_unShapeId(1) {} -bool CHorizontalRule::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CHorizontalRule::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; @@ -688,13 +682,13 @@ bool CHorizontalRule::Open(const std::vector& if (arSelectors.back().GetAttributeValue(L"width", wsValue)) oWidth.SetValue(wsValue); - XmlString& oCurrentDocument{m_pInterpretator->GetCurrentDocument()}; + XmlString& oCurrentDocument{*m_pWriter->GetCurrentDocument()}; - m_pInterpretator->OpenP(); + m_pWriter->OpenP(); oCurrentDocument.WriteString(L""); - m_pInterpretator->OpenR(); + m_pWriter->OpenR(); - const NSCSS::NSProperties::CPage *pPageData{m_pInterpretator->GetPageData()}; + const NSCSS::NSProperties::CPage *pPageData{m_pWriter->GetPageData()}; const unsigned int unPageWidth{static_cast((pPageData->GetWidth().ToDouble(NSCSS::Inch) - pPageData->GetMargin().GetLeft().ToDouble(NSCSS::Inch) - pPageData->GetMargin().GetRight().ToDouble(NSCSS::Inch)) * 914400.)}; @@ -738,33 +732,33 @@ bool CHorizontalRule::Open(const std::vector& oCurrentDocument.WriteString(L""); - m_pInterpretator->CloseP(); + m_pWriter->CloseP(); ++m_unShapeId; return true; } -void CHorizontalRule::Close(const std::vector& arSelectors) +void CHorizontalRule::Close(const std::vector& arSelectors) {} -CList::CList(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator), m_unNumberingId(1) +CList::CList(COOXMLWriter* pWriter) + : CTag(pWriter), m_unNumberingId(1) {} -bool CList::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CList::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; - m_pInterpretator->CloseP(); + m_pWriter->CloseP(); //Нумерованный список if (L"ol" == arSelectors.back().m_wsName) { const int nStart{NSStringFinder::ToInt(arSelectors.back().GetAttributeValue(L"start"), 1)}; - XmlString& oNumberXml{m_pInterpretator->GetNumberingXml()}; + XmlString& oNumberXml{m_pWriter->GetNumberingXml()}; const std::wstring wsStart(std::to_wstring(nStart)); oNumberXml.WriteString(L"::Open(const std::vector& arSelecto return true; } -void CList::Close(const std::vector& arSelectors) +void CList::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->CloseP(); + m_pWriter->CloseP(); } -CListElement::CListElement(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CListElement::CListElement(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CListElement::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CListElement::Open(const std::vector& arSelectors, const boost::any& oExtraData) { return ValidInterpretator(); } -void CListElement::Close(const std::vector& arSelectors) +void CListElement::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->CloseP(); + m_pWriter->CloseP(); } inline bool ElementInTable(const std::vector& arSelectors) @@ -1068,26 +1062,26 @@ bool UpdateImageData(const std::wstring& wsImagePath, TImageData& oImageData) return true; } -CCaption::CCaption(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CCaption::CCaption(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CCaption::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CCaption::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator()) return false; - m_pInterpretator->WritePPr(arSelectors); + m_pWriter->WritePPr(arSelectors); return true; } -void CCaption::Close(const std::vector& arSelectors) +void CCaption::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->CloseP(); + m_pWriter->CloseP(); } std::wstring CreateBorders(const NSCSS::NSProperties::CBorder& oBorder, const NSCSS::NSProperties::CIndent* pPadding = NULL, bool bAddIntermediateLines = false, TTableStyles::ETableRules enTableRule = TTableStyles::ETableRules::None) @@ -1156,11 +1150,11 @@ std::wstring CreateDefaultBorder(std::wstring wsSideName) return L""; } -CTable::CTable(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CTable::CTable(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CTable::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CTable::Open(const std::vector& arSelectors, const boost::any& oExtraData) { if (!ValidInterpretator() || oExtraData.empty() || typeid(CStorageTable*) != oExtraData.type()) return false; @@ -1170,7 +1164,7 @@ bool CTable::Open(const std::vector& arSelect if (pStorageTable->Empty()) return false; - XmlString& oCurrentDocument{m_pInterpretator->GetCurrentDocument()}; + XmlString& oCurrentDocument{*m_pWriter->GetCurrentDocument()}; oCurrentDocument.WriteNodeBegin(L"w:tbl"); oCurrentDocument.WriteNodeBegin(L"w:tblPr"); @@ -1252,37 +1246,32 @@ bool CTable::Open(const std::vector& arSelect return true; } -void CTable::Close(const std::vector& arSelectors) +void CTable::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->GetCurrentDocument().WriteNodeEnd(L"w:tbl"); + m_pWriter->GetCurrentDocument()->WriteNodeEnd(L"w:tbl"); } -CTableRow::CTableRow(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CTableRow::CTableRow(COOXMLWriter* pWriter) + : CTag(pWriter) {} -bool CTableRow::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CTableRow::Open(const std::vector& arSelectors, const boost::any& oExtraData) { - using DataForRow = boost::tuple; + using DataForRow = boost::tuple; if (!ValidInterpretator() || oExtraData.empty() || typeid(DataForRow) != oExtraData.type()) return false; const DataForRow& oDataForRow(boost::any_cast(oExtraData)); - CStorageTableRow& oStorageTableRow{boost::get<0>(oDataForRow)}; - - if (oStorageTableRow.Empty()) - return false; - - XmlString& oCurrentDocument{m_pInterpretator->GetCurrentDocument()}; + XmlString& oCurrentDocument{*m_pWriter->GetCurrentDocument()}; oCurrentDocument.WriteNodeBegin(L"w:tr"); const TTableStyles& oTableStyles{boost::get<1>(oDataForRow).GetTableStyles()}; - const TTableRowStyle oTableRowStyles{oStorageTableRow.GetStyles()}; + const TTableRowStyle oTableRowStyles{boost::get<0>(oDataForRow)}; if (!oTableRowStyles.Empty() || 0 < oTableStyles.m_nCellSpacing) { @@ -1303,16 +1292,16 @@ bool CTableRow::Open(const std::vector& arSel return true; } -void HTML::CTableRow::Close(const std::vector& arSelectors) +void HTML::CTableRow::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->GetCurrentDocument().WriteNodeEnd(L"w:tr"); + m_pWriter->GetCurrentDocument()->WriteNodeEnd(L"w:tr"); } -CTableCell::CTableCell(COOXMLInterpretator* pInterpretator) - : CTag(pInterpretator) +CTableCell::CTableCell(COOXMLWriter* pWriter) + : CTag(pWriter) {} std::wstring CalculateSidesToClean(UINT unColumnNumber, const std::vector& arColgroups, UINT unMaxColumns) @@ -1341,7 +1330,7 @@ std::wstring CalculateSidesToClean(UINT unColumnNumber, const std::vector::Open(const std::vector& arSelectors, const boost::any& oExtraData) +bool CTableCell::Open(const std::vector& arSelectors, const boost::any& oExtraData) { using DataForCell = boost::tuple; @@ -1351,7 +1340,7 @@ bool CTableCell::Open(const std::vector& arSe const DataForCell& oDataForCell{boost::any_cast(oExtraData)}; CStorageTableCell& oStorageTableCell{boost::get<0>(oDataForCell)}; - XmlString& oCurrentDocument{m_pInterpretator->GetCurrentDocument()}; + XmlString& oCurrentDocument{*m_pWriter->GetCurrentDocument()}; oCurrentDocument.WriteNodeBegin(L"w:tc"); oCurrentDocument.WriteNodeBegin(L"w:tcPr"); @@ -1456,19 +1445,14 @@ bool CTableCell::Open(const std::vector& arSe oCurrentDocument += L""; oCurrentDocument.WriteNodeEnd(L"w:tcPr"); - if (0 != oStorageTableCell.GetData()->GetCurSize()) - WriteToStringBuilder(*oStorageTableCell.GetData(), oCurrentDocument); - else - m_pInterpretator->WriteEmptyParagraph(); - return true; } - void HTML::CTableCell::Close(const std::vector& arSelectors) + void HTML::CTableCell::Close(const std::vector& arSelectors) { if (!ValidInterpretator()) return; - m_pInterpretator->GetCurrentDocument().WriteNodeEnd(L"w:tc"); + m_pWriter->GetCurrentDocument()->WriteNodeEnd(L"w:tc"); } } diff --git a/HtmlFile2/Tags/OOXMLTags.h b/HtmlFile2/Tags/OOXMLTags.h index 72f5c9c026..e0e80c61f3 100644 --- a/HtmlFile2/Tags/OOXMLTags.h +++ b/HtmlFile2/Tags/OOXMLTags.h @@ -2,156 +2,155 @@ #define OOXMLTAGS_H #include "HTMLTags.h" -#include "../Interpretators/OOXMLInterpretator.h" -#include +#include "../Writers/OOXMLWriter.h" namespace HTML { template<> -class CAnchor : public CTag +class CAnchor : public CTag { public: - CAnchor(COOXMLInterpretator* pInterpretator); + CAnchor(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CAbbr : public CTag +class CAbbr : public CTag { public: - CAbbr(COOXMLInterpretator* pInterpretator); + CAbbr(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CBreak : public CTag +class CBreak : public CTag { public: - CBreak(COOXMLInterpretator* pInterpretator); + CBreak(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CDivision : public CTag +class CDivision : public CTag { std::stack m_arFootnoteIDs; public: - CDivision(COOXMLInterpretator* pInterpretator); + CDivision(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CImage : public CTag +class CImage : public CTag { std::vector m_arrImages; public: - CImage(COOXMLInterpretator* pInterpretator); + CImage(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CFont : public CTag +class CFont : public CTag { public: - CFont(COOXMLInterpretator* pInterpretator); + CFont(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CInput : public CTag +class CInput : public CTag { public: - CInput(COOXMLInterpretator* pInterpretator); + CInput(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CBaseFont : public CTag +class CBaseFont : public CTag { public: - CBaseFont(COOXMLInterpretator* pInterpretator); + CBaseFont(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CBlockquote : public CTag +class CBlockquote : public CTag { std::map m_mDivs; public: - CBlockquote(COOXMLInterpretator* pInterpretator); + CBlockquote(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CHorizontalRule : public CTag +class CHorizontalRule : public CTag { UINT m_unShapeId; public: - CHorizontalRule(COOXMLInterpretator* pInterpretator); + CHorizontalRule(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CList : public CTag +class CList : public CTag { UINT m_unNumberingId; public: - CList(COOXMLInterpretator* pInterpretator); + CList(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CListElement : public CTag +class CListElement : public CTag { public: - CListElement(COOXMLInterpretator* pInterpretator); + CListElement(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CCaption : public CTag +class CCaption : public CTag { public: - CCaption(COOXMLInterpretator* pInterpretator); + CCaption(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CTable : public CTag +class CTable : public CTag { public: - CTable(COOXMLInterpretator* pInterpretator); + CTable(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CTableRow : public CTag +class CTableRow : public CTag { public: - CTableRow(COOXMLInterpretator* pInterpretator); + CTableRow(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; template<> -class CTableCell : public CTag +class CTableCell : public CTag { public: - CTableCell(COOXMLInterpretator* pInterpretator); + CTableCell(COOXMLWriter* pInterpretator); virtual bool Open(const std::vector& arSelectors, const boost::any& oExtraData = boost::any()) override; virtual void Close(const std::vector& arSelectors) override; }; diff --git a/HtmlFile2/Interpretators/HTMLInterpretator.h b/HtmlFile2/Writers/IWriter.h similarity index 76% rename from HtmlFile2/Interpretators/HTMLInterpretator.h rename to HtmlFile2/Writers/IWriter.h index dfbd3e7067..8597478ecd 100644 --- a/HtmlFile2/Interpretators/HTMLInterpretator.h +++ b/HtmlFile2/Writers/IWriter.h @@ -1,5 +1,5 @@ -#ifndef HTMLINTERPRETATOR_H -#define HTMLINTERPRETATOR_H +#ifndef IWRITER_H +#define IWRITER_H #include "../../Common/3dParty/html/css/src/CNode.h" #include "HTMLParams.h" @@ -7,11 +7,11 @@ namespace HTML { -class IHTMLInterpretator +class IWriter { public: - IHTMLInterpretator() = default; - virtual ~IHTMLInterpretator() = default; + IWriter() = default; + virtual ~IWriter() = default; virtual void Begin(const std::wstring& wsDst, const THtmlParams* pParams) = 0; virtual void End(const std::wstring& wsDst) = 0; @@ -26,10 +26,8 @@ public: virtual void SetDataOutput(XmlString* pOutputData) = 0; // Задаем место вывода для интерпретатора virtual void RevertDataOutput() = 0; // Возвращаем место вывода к исходному - #ifdef _DEBUG - virtual void PrintData() = 0; - #endif + virtual XmlString* GetCurrentDocument() const = 0; }; } -#endif // HTMLINTERPRETATOR_H +#endif // IWRITER_H diff --git a/HtmlFile2/Writers/MDWriter.cpp b/HtmlFile2/Writers/MDWriter.cpp new file mode 100644 index 0000000000..480031de38 --- /dev/null +++ b/HtmlFile2/Writers/MDWriter.cpp @@ -0,0 +1,74 @@ +#include "MDWriter.h" + +namespace HTML +{ +CMDWriter::CMDWriter(const TMDParametrs& oMDParametrs) + : m_oMDParametrs(oMDParametrs) +{ + m_arStates.push(TState{}); + m_arStates.top().m_pCurrentDocument = &m_oDocument; +} + +void CMDWriter::Begin(const std::wstring& wsDst, const THtmlParams* pParams) +{ + +} + +void CMDWriter::End(const std::wstring& wsDst) +{ +} + +bool CMDWriter::WriteText(const std::wstring& wsText, const std::vector& arSelectors) +{ + GetCurrentDocument()->WriteString(wsText); + return true; +} + +void CMDWriter::WriteEmptyParagraph(bool bVahish, bool bInP) +{ + +} + +void CMDWriter::BeginBlock() +{ + +} + +void CMDWriter::EndBlock(bool bAddBlock) +{ + GetCurrentDocument()->WriteString(m_oMDParametrs.m_wsLineBreak); +} + +void CMDWriter::SetDataOutput(XmlString* pOutputData) +{ + SaveState(); + m_arStates.top().m_pCurrentDocument = pOutputData; +} + +void CMDWriter::RevertDataOutput() +{ + + RollBackState(); +} + +TMDParametrs CMDWriter::GetParametrs() const +{ + return m_oMDParametrs;; +} + +XmlString* CMDWriter::GetCurrentDocument() const +{ + return m_arStates.top().m_pCurrentDocument; +} + +void CMDWriter::SaveState() +{ + m_arStates.push(m_arStates.top()); +} + +void CMDWriter::RollBackState() +{ + if (m_arStates.size() > 1) + m_arStates.pop(); +} +} diff --git a/HtmlFile2/Writers/MDWriter.h b/HtmlFile2/Writers/MDWriter.h new file mode 100644 index 0000000000..1a51d7da79 --- /dev/null +++ b/HtmlFile2/Writers/MDWriter.h @@ -0,0 +1,50 @@ +#ifndef MDWRITER_H +#define MDWRITER_H + +#include "IWriter.h" +#include + +namespace HTML +{ +struct TMDParametrs +{ + bool m_bUseAlternativeHTMLTags = false; //Использовать html теги там, где нет стандартной реализации в md(например для подчеркиваний) + std::wstring m_wsLineBreak = L" "; // По умолчанию для переноса строки используем двойной пробел +}; + +class CMDWriter : public IWriter +{ + XmlString m_oDocument; + + struct TState + { + XmlString *m_pCurrentDocument; + }; + + std::stack m_arStates; + TMDParametrs m_oMDParametrs; +public: + CMDWriter(const TMDParametrs& oMDParametrs); + + void Begin(const std::wstring& wsDst, const THtmlParams* pParams) override; + void End(const std::wstring& wsDst) override; + + bool WriteText(const std::wstring& wsText, const std::vector& arSelectors) override; + + void WriteEmptyParagraph(bool bVahish = false, bool bInP = false) override; + + void BeginBlock() override; + void EndBlock(bool bAddBlock) override; + + void SetDataOutput(XmlString* pOutputData) override; + void RevertDataOutput() override; + + TMDParametrs GetParametrs() const; + XmlString* GetCurrentDocument() const override; +private: + void SaveState(); + void RollBackState(); +}; +} + +#endif // MDWRITER_H diff --git a/HtmlFile2/Interpretators/OOXMLInterpretator.cpp b/HtmlFile2/Writers/OOXMLWriter.cpp similarity index 94% rename from HtmlFile2/Interpretators/OOXMLInterpretator.cpp rename to HtmlFile2/Writers/OOXMLWriter.cpp index 49292db5ab..f083f70203 100644 --- a/HtmlFile2/Interpretators/OOXMLInterpretator.cpp +++ b/HtmlFile2/Writers/OOXMLWriter.cpp @@ -1,4 +1,4 @@ -#include "OOXMLInterpretator.h" +#include "OOXMLWriter.h" #include @@ -43,7 +43,7 @@ inline UINT GetFontSizeLevel(UINT unFontSize); inline UINT GetFontSizeByLevel(UINT unLevel); inline void ReplaceSpaces(std::wstring& wsValue); -COOXMLInterpretator::COOXMLInterpretator() +COOXMLWriter::COOXMLWriter() : m_nFootnoteId(1), m_nHyperlinkId(1), m_nNumberingId(1), m_nId(1), m_nShapeId(1), m_bWasDivs(false), m_pFonts(nullptr) { m_oPageData.SetWidth (DEFAULT_PAGE_WIDTH, NSCSS::UnitMeasure::Twips, 0, true); @@ -56,12 +56,12 @@ COOXMLInterpretator::COOXMLInterpretator() m_arStates.top().m_pCurrentDocument = &m_oDocXml; } -void COOXMLInterpretator::SetCSSCalculator(NSCSS::CCssCalculator* pCSSCalculator) +void COOXMLWriter::SetCSSCalculator(NSCSS::CCssCalculator* pCSSCalculator) { m_pStylesCalculator = pCSSCalculator; } -void COOXMLInterpretator::Begin(const std::wstring& wsDst, const THtmlParams* pParams) +void COOXMLWriter::Begin(const std::wstring& wsDst, const THtmlParams* pParams) { // Создаем пустые папки NSDirectory::CreateDirectory(wsDst + L"/_rels"); @@ -258,7 +258,7 @@ void COOXMLInterpretator::Begin(const std::wstring& wsDst, const THtmlParams* pP m_oStylesXml += L""; } -void COOXMLInterpretator::End(const std::wstring& wsDst) +void COOXMLWriter::End(const std::wstring& wsDst) { m_oDocXmlRels.WriteString(L""); NSFile::CFileBinary oRelsWriter; @@ -355,7 +355,7 @@ void COOXMLInterpretator::End(const std::wstring& wsDst) } } -bool COOXMLInterpretator::OpenP() +bool COOXMLWriter::OpenP() { if (m_arStates.top().m_bInP) return false; @@ -367,7 +367,7 @@ bool COOXMLInterpretator::OpenP() return true; } -bool COOXMLInterpretator::OpenR() +bool COOXMLWriter::OpenR() { if (m_arStates.top().m_bInR) return false; @@ -377,7 +377,7 @@ bool COOXMLInterpretator::OpenR() return true; } -bool COOXMLInterpretator::OpenT() +bool COOXMLWriter::OpenT() { if (m_arStates.top().m_bInT) return false; @@ -387,7 +387,7 @@ bool COOXMLInterpretator::OpenT() return true; } -void COOXMLInterpretator::CloseP() +void COOXMLWriter::CloseP() { m_arStates.top().m_bWasSpace = true; @@ -401,7 +401,7 @@ void COOXMLInterpretator::CloseP() m_arStates.top().m_bInP = false; } -void COOXMLInterpretator::CloseR() +void COOXMLWriter::CloseR() { if (!m_arStates.top().m_bInR) return; @@ -410,7 +410,7 @@ void COOXMLInterpretator::CloseR() m_arStates.top().m_bInR = false; } -void COOXMLInterpretator::CloseT() +void COOXMLWriter::CloseT() { if (!m_arStates.top().m_bInT) return; @@ -419,7 +419,7 @@ void COOXMLInterpretator::CloseT() m_arStates.top().m_bInT = false; } -void COOXMLInterpretator::BeginBlock() +void COOXMLWriter::BeginBlock() { SaveState(); m_arStates.top().CreateNewCurrentDocument(); @@ -427,7 +427,7 @@ void COOXMLInterpretator::BeginBlock() CloseP(); } -void COOXMLInterpretator::EndBlock(bool bAddBlock) +void COOXMLWriter::EndBlock(bool bAddBlock) { if (m_arStates.top().m_pCurrentDocument == &m_oDocXml) return; @@ -444,31 +444,31 @@ void COOXMLInterpretator::EndBlock(bool bAddBlock) RollBackState(); } -void COOXMLInterpretator::SetDataOutput(XmlString* pOutputData) +void COOXMLWriter::SetDataOutput(XmlString* pOutputData) { SaveState(); m_arStates.top().m_pCurrentDocument = pOutputData; m_arStates.top().m_bRemoveCurrentDocument = false; } -void COOXMLInterpretator::RevertDataOutput() +void COOXMLWriter::RevertDataOutput() { CloseP(); RollBackState(); } -void COOXMLInterpretator::SaveState() +void COOXMLWriter::SaveState() { m_arStates.push(m_arStates.top()); } -void COOXMLInterpretator::RollBackState() +void COOXMLWriter::RollBackState() { if(m_arStates.size() > 1) m_arStates.pop(); } -void COOXMLInterpretator::SetCurrentDocument(XmlString* pNewDocument) +void COOXMLWriter::SetCurrentDocument(XmlString* pNewDocument) { SaveState(); @@ -476,7 +476,7 @@ void COOXMLInterpretator::SetCurrentDocument(XmlString* pNewDocument) m_arStates.top().m_bRemoveCurrentDocument = false; } -void COOXMLInterpretator::Break(const std::vector& arSelectors) +void COOXMLWriter::Break(const std::vector& arSelectors) { if (m_arStates.top().m_bInP) { @@ -492,7 +492,7 @@ void COOXMLInterpretator::Break(const std::vector& arSelectors) m_arStates.top().m_bWasSpace = true; } -void COOXMLInterpretator::OpenCrossHyperlink(const std::wstring& wsRef, const std::vector& arSelectors) +void COOXMLWriter::OpenCrossHyperlink(const std::wstring& wsRef, const std::vector& arSelectors) { m_arStates.top().m_pCurrentDocument->WriteString(L"WriteString(L"\">"); } -void COOXMLInterpretator::OpenExternalHyperlink(const std::wstring& wsRef, const std::wstring& wsTooltip, const std::vector& arSelectors) +void COOXMLWriter::OpenExternalHyperlink(const std::wstring& wsRef, const std::wstring& wsTooltip, const std::vector& arSelectors) { XmlString& oRelationshipXml(m_oDocXmlRels); @@ -532,7 +532,7 @@ void COOXMLInterpretator::OpenExternalHyperlink(const std::wstring& wsRef, const m_arStates.top().m_pCurrentDocument->WriteString(L"\">"); } -void COOXMLInterpretator::CloseCrossHyperlink(const std::vector& arSelectors, std::wstring wsFootnote, const std::wstring& wsRef) +void COOXMLWriter::CloseCrossHyperlink(const std::vector& arSelectors, std::wstring wsFootnote, const std::wstring& wsRef) { if (!m_arStates.top().m_bInP) return; @@ -571,7 +571,7 @@ void COOXMLInterpretator::CloseCrossHyperlink(const std::vector& a } } -void COOXMLInterpretator::CloseExternalHyperlink() +void COOXMLWriter::CloseExternalHyperlink() { if (!m_arStates.top().m_bInP && !m_arStates.top().m_bInHyperlink) return; @@ -582,7 +582,7 @@ void COOXMLInterpretator::CloseExternalHyperlink() m_arStates.top().m_bInHyperlink = false; } -std::wstring COOXMLInterpretator::WritePPr(const std::vector& arSelectors) +std::wstring COOXMLWriter::WritePPr(const std::vector& arSelectors) { OpenP(); @@ -638,7 +638,7 @@ std::wstring COOXMLInterpretator::WritePPr(const std::vector& arSe return sPStyle; } -std::wstring COOXMLInterpretator::WriteRPr(XmlString& oXml, const std::vector& arSelectors) +std::wstring COOXMLWriter::WriteRPr(XmlString& oXml, const std::vector& arSelectors) { if (!m_arStates.top().m_bInP) return L""; @@ -697,7 +697,7 @@ std::wstring COOXMLInterpretator::WriteRPr(XmlString& oXml, const std::vector& arSelectors) +bool COOXMLWriter::WriteText(const std::wstring& wsText, const std::vector& arSelectors) { if (wsText.empty()) return false; @@ -844,7 +844,7 @@ bool COOXMLInterpretator::WriteText(const std::wstring& wsText, const std::vecto return true; } -void COOXMLInterpretator::WriteEmptyParagraph(bool bVahish, bool bInP) +void COOXMLWriter::WriteEmptyParagraph(bool bVahish, bool bInP) { if (!bInP) m_arStates.top().m_pCurrentDocument->WriteString(L""); @@ -860,7 +860,7 @@ void COOXMLInterpretator::WriteEmptyParagraph(bool bVahish, bool bInP) m_arStates.top().m_pCurrentDocument->WriteString(L""); } -void COOXMLInterpretator::WriteSpace() +void COOXMLWriter::WriteSpace() { OpenR(); m_arStates.top().m_pCurrentDocument->WriteString(L" "); @@ -868,7 +868,7 @@ void COOXMLInterpretator::WriteSpace() m_arStates.top().m_bWasSpace = true; } -void COOXMLInterpretator::WriteEmptyBookmark(const std::wstring& wsId) +void COOXMLWriter::WriteEmptyBookmark(const std::wstring& wsId) { const std::wstring wsCrossId{WriteBookmark(wsId)}; @@ -880,12 +880,12 @@ void COOXMLInterpretator::WriteEmptyBookmark(const std::wstring& wsId) m_arStates.top().m_pCurrentDocument->WriteString(L"\"/>"); } -std::wstring COOXMLInterpretator::AddLiteBookmark() +std::wstring COOXMLWriter::AddLiteBookmark() { return m_mBookmarks.insert(std::make_pair(L"Bookmark" + std::to_wstring(m_mBookmarks.size() + 1), m_mBookmarks.size() + 1)).first->first; } -std::wstring COOXMLInterpretator::WriteBookmark(const std::wstring& wsId) +std::wstring COOXMLWriter::WriteBookmark(const std::wstring& wsId) { const std::wstring sCrossId = std::to_wstring(m_mBookmarks.size() + 1); std::wstring sName; @@ -913,7 +913,7 @@ std::wstring COOXMLInterpretator::WriteBookmark(const std::wstring& wsId) return sCrossId; } -std::wstring COOXMLInterpretator::AddAnchor(const std::wstring& wsAnchorValue) +std::wstring COOXMLWriter::AddAnchor(const std::wstring& wsAnchorValue) { const anchors_map::iterator itFound = m_mAnchors.find(wsAnchorValue); @@ -926,7 +926,7 @@ std::wstring COOXMLInterpretator::AddAnchor(const std::wstring& wsAnchorValue) return wsAnchorId; } -void COOXMLInterpretator::WriteImage(const TImageData& oImageData, const std::wstring& wsId) +void COOXMLWriter::WriteImage(const TImageData& oImageData, const std::wstring& wsId) { OpenR(); @@ -978,7 +978,7 @@ void COOXMLInterpretator::WriteImage(const TImageData& oImageData, const std::ws CloseR(); } -void COOXMLInterpretator::WriteAlternativeImage(const std::wstring& wsAlt, const std::wstring& wsSrc, const TImageData& oImageData) +void COOXMLWriter::WriteAlternativeImage(const std::wstring& wsAlt, const std::wstring& wsSrc, const TImageData& oImageData) { m_oDocXmlRels.WriteString(L""); } -std::wstring COOXMLInterpretator::GetStyle(const NSCSS::CCompiledStyle& oStyle, bool bParagraphStyle) +std::wstring COOXMLWriter::GetStyle(const NSCSS::CCompiledStyle& oStyle, bool bParagraphStyle) { if ((bParagraphStyle && !m_oXmlStyle.WritePStyle(oStyle)) || (!bParagraphStyle && !m_oXmlStyle.WriteRStyle(oStyle))) return L""; @@ -1039,94 +1039,94 @@ std::wstring COOXMLInterpretator::GetStyle(const NSCSS::CCompiledStyle& oStyle, return m_oXmlStyle.GetIdAndClear(); } -void COOXMLInterpretator::UpdatePageStyle(const std::vector& arSelectors) +void COOXMLWriter::UpdatePageStyle(const std::vector& arSelectors) { if (nullptr != m_pStylesCalculator) m_pStylesCalculator->CalculatePageStyle(m_oPageData, arSelectors); } -void COOXMLInterpretator::SetBaseFont(const std::wstring& wsFontStyles) +void COOXMLWriter::SetBaseFont(const std::wstring& wsFontStyles) { if (nullptr != m_pStylesCalculator) m_pStylesCalculator->AddStyles(wsFontStyles); } -void COOXMLInterpretator::SetDivId(const std::wstring& wsDivId) +void COOXMLWriter::SetDivId(const std::wstring& wsDivId) { m_arDivId.push(wsDivId); m_bWasDivs = true; } -void COOXMLInterpretator::RollBackDivId() +void COOXMLWriter::RollBackDivId() { if (!m_arDivId.empty()) m_arDivId.pop(); } -std::wstring COOXMLInterpretator::FindFootnote(const std::wstring& wsId) +std::wstring COOXMLWriter::FindFootnote(const std::wstring& wsId) { const std::map::const_iterator itFound{m_mFootnotes.find(wsId)}; return (itFound != m_mFootnotes.cend()) ? itFound->second : std::wstring(); } -void COOXMLInterpretator::OpenFootnote(const std::wstring& wsFootnoteID) +void COOXMLWriter::OpenFootnote(const std::wstring& wsFootnoteID) { m_oNoteXml.WriteString(L""); } -void COOXMLInterpretator::CloseFootnote() +void COOXMLWriter::CloseFootnote() { m_oNoteXml.WriteString(L""); } -XmlString& COOXMLInterpretator::GetStylesXml() +XmlString& COOXMLWriter::GetStylesXml() { return m_oStylesXml; } -XmlString& COOXMLInterpretator::GetDocRelsXml() +XmlString& COOXMLWriter::GetDocRelsXml() { return m_oDocXmlRels; } -XmlString& COOXMLInterpretator::GetNotesRelsXml() +XmlString& COOXMLWriter::GetNotesRelsXml() { return m_oNoteXmlRels; } -XmlString& COOXMLInterpretator::GetDocumentXml() +XmlString& COOXMLWriter::GetDocumentXml() { return m_oDocXml; } -XmlString& COOXMLInterpretator::GetNotesXml() +XmlString& COOXMLWriter::GetNotesXml() { return m_oNoteXml; } -XmlString& COOXMLInterpretator::GetNumberingXml() +XmlString& COOXMLWriter::GetNumberingXml() { return m_oNumberXml; } -XmlString& COOXMLInterpretator::GetWebSettingsXml() +XmlString& COOXMLWriter::GetWebSettingsXml() { return m_oWebSettings; } -XmlString& COOXMLInterpretator::GetCurrentDocument() +XmlString* COOXMLWriter::GetCurrentDocument() const { - return *m_arStates.top().m_pCurrentDocument; + return m_arStates.top().m_pCurrentDocument; } -const NSCSS::NSProperties::CPage* COOXMLInterpretator::GetPageData() const +const NSCSS::NSProperties::CPage* COOXMLWriter::GetPageData() const { return &m_oPageData; } -NSFonts::IApplicationFonts* COOXMLInterpretator::GetFonts() +NSFonts::IApplicationFonts* COOXMLWriter::GetFonts() { if (nullptr == m_pFonts) { @@ -1139,36 +1139,31 @@ NSFonts::IApplicationFonts* COOXMLInterpretator::GetFonts() return m_pFonts; } -std::wstring COOXMLInterpretator::GetMediaDir() const +std::wstring COOXMLWriter::GetMediaDir() const { return m_wsDstPath + L"/word/media/"; } -std::wstring COOXMLInterpretator::GetTempDir() const +std::wstring COOXMLWriter::GetTempDir() const { return m_wsTempDir; } -std::wstring COOXMLInterpretator::GetSrcPath() const +std::wstring COOXMLWriter::GetSrcPath() const { return m_wsSrcPath; } -std::wstring COOXMLInterpretator::GetBasePath() const +std::wstring COOXMLWriter::GetBasePath() const { return m_wsBasePath; } -std::wstring COOXMLInterpretator::GetCorePath() const +std::wstring COOXMLWriter::GetCorePath() const { return m_wsCorePath; } -void COOXMLInterpretator::PrintData() -{ - std::wcout << m_oDocXml.GetData() << std::endl; -} - inline bool ElementInTable(const std::vector& arSelectors) { return arSelectors.crend() != std::find_if(arSelectors.crbegin(), arSelectors.crend(), [](const NSCSS::CNode& oNode) { return L"table" == oNode.m_wsName; }); diff --git a/HtmlFile2/Interpretators/OOXMLInterpretator.h b/HtmlFile2/Writers/OOXMLWriter.h similarity index 95% rename from HtmlFile2/Interpretators/OOXMLInterpretator.h rename to HtmlFile2/Writers/OOXMLWriter.h index fd5987cb3e..34170a33b5 100644 --- a/HtmlFile2/Interpretators/OOXMLInterpretator.h +++ b/HtmlFile2/Writers/OOXMLWriter.h @@ -1,11 +1,11 @@ -#ifndef OOXMLINTERPRETATOR_H -#define OOXMLINTERPRETATOR_H +#ifndef OOXMLWRITER_H +#define OOXMLWRITER_H // #include "HTMLInterpretator.h" #include "../../Common/3dParty/html/css/src/xhtml/CDocumentStyle.h" #include "../../Common/3dParty/html/css/src/CCssCalculator.h" -#include "HTMLInterpretator.h" +#include "IWriter.h" #include namespace NSFonts { class IApplicationFonts; } @@ -37,7 +37,7 @@ struct TImageData } }; -class COOXMLInterpretator : public IHTMLInterpretator +class COOXMLWriter : public IWriter { std::wstring m_wsDstPath; // Директория назначения std::wstring m_wsTempDir; // Temp папка @@ -114,7 +114,7 @@ class COOXMLInterpretator : public IHTMLInterpretator NSFonts::IApplicationFonts* m_pFonts; // Необходимо для оптимизации работы со шрифтами public: - COOXMLInterpretator(); + COOXMLWriter(); void SetCSSCalculator(NSCSS::CCssCalculator* pCSSCalculator); @@ -182,7 +182,7 @@ public: XmlString& GetNotesXml(); XmlString& GetNumberingXml(); XmlString& GetWebSettingsXml(); - XmlString& GetCurrentDocument(); + XmlString* GetCurrentDocument() const override; const NSCSS::NSProperties::CPage* GetPageData() const; NSFonts::IApplicationFonts* GetFonts(); @@ -192,11 +192,7 @@ public: std::wstring GetSrcPath() const; std::wstring GetBasePath() const; std::wstring GetCorePath() const; - - #ifdef _DEBUG - virtual void PrintData() override; - #endif }; } -#endif // OOXMLINTERPRETATOR_H +#endif // OOXMLWRITER_H