Skip to content

O
onlyoffice_core
Commit a8fd05d1 authored by Elen.Subbotina's avatar Elen.Subbotina Committed by Alexander Trofimov
Browse files
Options

удаление перенесеного 

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@65728 954022d7-b5bf-4e40-9824-e11837661b57
parent b8e32028
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 3989 deletions
ASCPresentationEditor/PPTXWriter/Converter.cpp deleted 100644 → 0
View file @ b8e32028
#pragma once
#include "../OfficeDrawing/Document.h"
#include "../../Common/DocxFormat/Source/SystemUtility/File.h"
#include "../../Common/DocxFormat/Source/SystemUtility/FileSystem/Directory.h"
#include "../../ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfo.h"
#include "ShapeWriter.h"
#include "StylesWriter.h"
#include "../../Common/DocxFormat/Source/SystemUtility/SystemUtility.h"
#include "../../ASCOfficePPTXFile/Editor/DefaultNotesMaster.h"
#include "../../ASCOfficePPTXFile/Editor/DefaultNotesTheme.h"
#include "Converter.h"
namespace NSPresentationEditor
{
namespace NSPPTXWriterConst
{
static CString g_string_rels_presentation = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
<Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties\" Target=\"docProps/core.xml\"/>\
<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"ppt/presentation.xml\"/>\
<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties\" Target=\"docProps/app.xml\"/>\
</Relationships>");
static CString g_string_core = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<cp:coreProperties xmlns:cp=\"http://schemas.openxmlformats.org/package/2006/metadata/core-properties\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:dcmitype=\"http://purl.org/dc/dcmitype/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\
<dc:title>Slide 1</dc:title>\
<dc:creator>OnlyOffice</dc:creator>\
<cp:lastModifiedBy>OnlyOffice</cp:lastModifiedBy>\
<cp:revision>1</cp:revision>\
</cp:coreProperties>");
}
};
NSPresentationEditor::CPPTXWriter::CPPTXWriter()
{
m_strTempDirectory = FileSystem::Directory::GetTempPath() + FILE_SEPARATOR_STR + _T("TempPPTX");
m_strDstFileName = FileSystem::Directory::GetTempPath() + FILE_SEPARATOR_STR + _T("Test.pptx");
m_pDocument = NULL;
m_pUserInfo = NULL;
m_pShapeWriter = new CShapeWriter();
}
NSPresentationEditor::CPPTXWriter::~CPPTXWriter()
{
RELEASEOBJECT(m_pShapeWriter);
}
void NSPresentationEditor::CPPTXWriter::CreateFile(CPPTUserInfo* pUserInfo )
{
m_pUserInfo = pUserInfo;
m_pDocument = dynamic_cast<CDocument*>(pUserInfo);
m_pDocument->m_oInfo.m_lUnitsHor = 36000 * m_pDocument->m_oInfo.m_lMillimetresHor;
m_pDocument->m_oInfo.m_lUnitsVer = 36000 * m_pDocument->m_oInfo.m_lMillimetresVer;
m_oManager.Clear();
m_oManager.SetDstMedia(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("media") + FILE_SEPARATOR_STR);
m_pShapeWriter->InitNextId();
FileSystem::Directory::CreateDirectory(m_strTempDirectory);
CFile oFile;
CString strMemory = _T("");
// _rels
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("_rels"));
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + _T(".rels"));
strMemory = NSPPTXWriterConst::g_string_rels_presentation;
oFile.WriteStringUTF8(strMemory);
oFile.CloseFile();
// docProps
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps"));
// core
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps") + FILE_SEPARATOR_STR + _T("core.xml"));
strMemory = NSPPTXWriterConst::g_string_core;
oFile.WriteStringUTF8(strMemory);
oFile.CloseFile();
// app
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps") + FILE_SEPARATOR_STR + _T("app.xml"));
WriteApp(oFile);
oFile.CloseFile();
// content types
WriteContentTypes();
// ppt
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt"));
WritePresInfo();
WriteAll();
}
void NSPresentationEditor::CPPTXWriter::CreateFile(CDocument* pDocument)
{
m_pDocument = pDocument;
m_oManager.Clear();
m_oManager.SetDstMedia(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("media") + FILE_SEPARATOR_STR);
m_pShapeWriter->InitNextId();
FileSystem::Directory::CreateDirectory(m_strTempDirectory);
CFile oFile;
CString strMemory = _T("");
// _rels
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("_rels"));
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + _T(".rels"));
strMemory = NSPPTXWriterConst::g_string_rels_presentation;
oFile.WriteStringUTF8(strMemory);
oFile.CloseFile();
// docProps
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps"));
// core
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps") + FILE_SEPARATOR_STR + _T("core.xml"));
strMemory = NSPPTXWriterConst::g_string_core;
oFile.WriteStringUTF8(strMemory);
oFile.CloseFile();
// app
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("docProps") + FILE_SEPARATOR_STR + _T("app.xml"));
WriteApp(oFile);
oFile.CloseFile();
// content types
WriteContentTypes();
// ppt
FileSystem::Directory::CreateDirectory(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt"));
WritePresInfo();
WriteAll();
}
void NSPresentationEditor::CPPTXWriter::CloseFile()
{
m_oManager.Clear();
}
void NSPresentationEditor::CPPTXWriter::WriteContentTypes()
{
CString strContentTypes = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\
<Default Extension=\"bmp\" ContentType=\"image/bmp\" />\
<Default Extension=\"png\" ContentType=\"image/png\" />\
<Default Extension=\"jpeg\" ContentType=\"image/jpeg\" />\
<Default Extension=\"wmf\" ContentType=\"image/x-wmf\" />\
<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\" />\
<Default Extension=\"xml\" ContentType=\"application/xml\" />\
<Default Extension=\"gif\" ContentType=\"image/gif\"/>\
<Default Extension=\"emf\" ContentType=\"image/x-emf\"/>\
<Default Extension=\"bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\" />\
<Default Extension=\"jpg\" ContentType=\"application/octet-stream\"/>");
strContentTypes += _T("<Override PartName=\"/ppt/presentation.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml\" />\
<Override PartName=\"/ppt/presProps.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.presProps+xml\" />\
<Override PartName=\"/ppt/viewProps.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml\" />\
<Override PartName=\"/ppt/tableStyles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml\"/>\
<Override PartName=\"/docProps/core.xml\" ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\" />\
<Override PartName=\"/docProps/app.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\" />");
int nThemes = (int)m_pDocument->m_arThemes.size();
int nIndexLayout = 0;
for (int nT = 0; nT < nThemes; ++nT)
{
CString strTheme = _T("");
strTheme.Format(_T("<Override PartName=\"/ppt/theme/theme%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\" />\
<Override PartName=\"/ppt/slideMasters/slideMaster%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml\" />"),
nT + 1, nT + 1);
strContentTypes += strTheme;
int nCountL = (int)m_pDocument->m_arThemes[nT].m_arLayouts.size();
for (int nL = 0; nL < nCountL; ++nL, ++nIndexLayout)
{
CString strL = _T("");
strL.Format(_T("<Override PartName=\"/ppt/slideLayouts/slideLayout%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml\" />"), nIndexLayout + 1);
strContentTypes += strL;
}
}
CString strNotesTheme = _T("");
strNotesTheme.Format(_T("<Override PartName=\"/ppt/theme/theme%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\" />"),
nThemes + 1);
strContentTypes += strNotesTheme;
strContentTypes += _T("<Override PartName=\"/ppt/notesMasters/notesMaster1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml\"/>");
int nCountS = (int)m_pDocument->m_arSlides.size();
for (int nS = 0; nS < nCountS; ++nS)
{
CString strS = _T("");
strS.Format(_T("<Override PartName=\"/ppt/slides/slide%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\" />"), nS + 1);
strContentTypes += strS;
CString strN = _T("");
strN.Format(_T("<Override PartName=\"/ppt/notesSlides/notesSlide%d.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml\"/>"), nS + 1);
strContentTypes += strN;
}
strContentTypes += _T("</Types>");
CFile oFile;
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("[Content_Types].xml"));
oFile.WriteStringUTF8(strContentTypes);
oFile.CloseFile();
}
void NSPresentationEditor::CPPTXWriter::WriteApp(CFile& oFile)
{
CString str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\" xmlns:vt=\"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes\">\
<TotalTime>0</TotalTime>\
<Words>0</Words>\
<Application>OnlyOffice</Application>\
<PresentationFormat>On-screen Show (4:3)</PresentationFormat>\
<Paragraphs>0</Paragraphs>");
oFile.WriteStringUTF8(str1);
CString str2 = _T("");
str2.Format(_T("<Slides>%d</Slides>"), (int)m_pDocument->m_arSlides.size());
oFile.WriteStringUTF8(str2);
CString str3 = _T("<Notes>0</Notes>\
<HiddenSlides>0</HiddenSlides>\
<MMClips>2</MMClips>\
<ScaleCrop>false</ScaleCrop>\
<HeadingPairs>\
<vt:vector size=\"4\" baseType=\"variant\">");
oFile.WriteStringUTF8(str3);
int nCountThemes = (int)m_pDocument->m_arThemes.size();
int nCountSlides = (int)m_pDocument->m_arSlides.size();
CString strThemes = _T("");
strThemes.Format(_T("<vt:variant><vt:lpstr>Theme</vt:lpstr></vt:variant><vt:variant><vt:i4>%d</vt:i4></vt:variant>"), nCountThemes);
CString strSlides = _T("");
strSlides.Format(_T("<vt:variant><vt:lpstr>Slide Titles</vt:lpstr></vt:variant><vt:variant><vt:i4>%d</vt:i4></vt:variant></vt:vector></HeadingPairs>"), nCountSlides);
CString str4 = _T("");
str4.Format(_T("<TitlesOfParts><vt:vector size=\"%d\" baseType=\"lpstr\">"), nCountSlides + nCountThemes);
str4 = strThemes + strSlides + str4;
oFile.WriteStringUTF8(str4);
CString strMemory = _T("");
for (int i = 1; i <= nCountThemes; ++i)
{
CString strMem = _T("");
strMem.Format(_T("<vt:lpstr>Theme %d</vt:lpstr>"), i);
strMemory += strMem;
}
for (int i = 1; i <= nCountSlides; ++i)
{
CString strMem = _T("");
strMem.Format(_T("<vt:lpstr>Slide %d</vt:lpstr>"), i);
strMemory += strMem;
}
CString str5 = _T("</vt:vector>\
</TitlesOfParts>\
<Company></Company>\
<LinksUpToDate>false</LinksUpToDate>\
<SharedDoc>false</SharedDoc>\
<HyperlinksChanged>false</HyperlinksChanged>\
<AppVersion>1.0000</AppVersion>\
</Properties>");
strMemory += str5;
oFile.WriteStringUTF8(strMemory);
}
void NSPresentationEditor::CPPTXWriter::WritePresInfo()
{
CFile oFile;
// tableStyles.xml
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("tableStyles.xml"));
CString str = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<a:tblStyleLst xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" def=\"{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}\" />");
oFile.WriteStringUTF8(str);
oFile.CloseFile();
// presProps.xml
str = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<p:presentationPr xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
<p:extLst><p:ext uri=\"{E76CE94A-603C-4142-B9EB-6D1370010A27}\">\
<p14:discardImageEditData xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"0\" /></p:ext>\
<p:ext uri=\"{D31A062A-798A-4329-ABDD-BBA856620510}\">\
<p14:defaultImageDpi xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"220\" />\
</p:ext></p:extLst></p:presentationPr>");
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("presProps.xml"));
oFile.WriteStringUTF8(str);
oFile.CloseFile();
// viewProps.xml
str = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<p:viewPr xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
<p:normalViewPr><p:restoredLeft sz=\"15620\"/><p:restoredTop sz=\"94660\"/></p:normalViewPr><p:slideViewPr><p:cSldViewPr><p:cViewPr varScale=\"1\">\
<p:scale><a:sx n=\"104\" d=\"100\"/><a:sy n=\"104\" d=\"100\"/></p:scale><p:origin x=\"-1236\" y=\"-90\"/></p:cViewPr><p:guideLst>\
<p:guide orient=\"horz\" pos=\"2160\"/><p:guide pos=\"2880\"/></p:guideLst></p:cSldViewPr></p:slideViewPr><p:notesTextViewPr><p:cViewPr><p:scale>\
<a:sx n=\"1\" d=\"1\"/><a:sy n=\"1\" d=\"1\"/></p:scale><p:origin x=\"0\" y=\"0\"/></p:cViewPr></p:notesTextViewPr><p:gridSpacing cx=\"72008\" cy=\"72008\"/></p:viewPr>");
oFile.CreateFile(m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("viewProps.xml"));
oFile.WriteStringUTF8(str);
oFile.CloseFile();
// presentation.xml + _rels/presentation.xml.rels
CString strPresRels;
CString strPresMasters = _T("");
CString strPresSlides = _T("");
size_t nCountLayouts = 0;
size_t nCountThemes = m_pDocument->m_arThemes.size();
for (size_t nIndexTheme = 0; nIndexTheme < nCountThemes; ++nIndexTheme)
{
CString strRels = _T("");
strRels.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster\" Target=\"slideMasters/slideMaster%d.xml\" />"), 2 * nIndexTheme + 1, nIndexTheme + 1);
strPresRels += strRels;
strRels = _T("");
strRels.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"theme/theme%d.xml\" />"), 2 * nIndexTheme + 2, nIndexTheme + 1);
strPresRels += strRels;
strRels = _T("");
strRels.Format(_T("<p:sldMasterId id=\"%u\" r:id=\"rId%d\" />"), 0x80000000 + nCountLayouts, 2 * nIndexTheme + 1);
nCountLayouts += m_pDocument->m_arThemes[nIndexTheme].m_arLayouts.size();
nCountLayouts += 1;
strPresMasters += strRels;
}
int nCurrentRels = (int)(2 * nCountThemes + 1);
size_t nCountSlides = m_pDocument->m_arSlides.size();
for (size_t nIndexSlide = 0; nIndexSlide < nCountSlides; ++nIndexSlide, ++nCurrentRels)
{
CString strRels = _T("");
strRels.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"slides/slide%d.xml\" />"), nCurrentRels, nIndexSlide + 1);
strPresRels += strRels;
strRels = _T("");
strRels.Format(_T("<p:sldId id=\"%d\" r:id=\"rId%d\" />"), 256 + nIndexSlide, nCurrentRels);
strPresSlides += strRels;
}
CString strNotesIDs = _T("");
strNotesIDs.Format(_T("<p:notesMasterIdLst><p:notesMasterId r:id=\"rId%d\"/></p:notesMasterIdLst>"), nCurrentRels);
CString strRels0 = _T("");
strRels0.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"notesMasters/notesMaster1.xml\"/>"), nCurrentRels);
++nCurrentRels;
CString strRels1 = _T("");
strRels1.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps\" Target=\"presProps.xml\" />"), nCurrentRels++);
CString strRels2 = _T("");
strRels2.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles\" Target=\"tableStyles.xml\" />"), nCurrentRels++);
CString strRels3 = _T("");
strRels3.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps\" Target=\"viewProps.xml\" />"), nCurrentRels++);
strPresRels = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">") + strPresRels + strRels0 + strRels1 + strRels2 + strRels3 + _T("</Relationships>");
CString strPptRels = m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("_rels");
FileSystem::Directory::CreateDirectory(strPptRels);
oFile.CreateFile(strPptRels + FILE_SEPARATOR_STR + _T("presentation.xml.rels"));
oFile.WriteStringUTF8(strPresRels);
oFile.CloseFile();
CString strSizePres = _T("");
strSizePres.Format(_T("<p:sldSz cx=\"%d\" cy=\"%d\" type=\"screen4x3\" /><p:notesSz cx=\"%d\" cy=\"%d\" />"),
m_pDocument->m_oInfo.m_lUnitsHor, m_pDocument->m_oInfo.m_lUnitsVer, m_pDocument->m_oInfo.m_lUnitsVer, m_pDocument->m_oInfo.m_lUnitsHor);
CString strDefaultTextStyle = _T("<p:defaultTextStyle>");
if (m_pDocument->m_arThemes.size()>0)
{
strDefaultTextStyle += CStylesWriter::ConvertStyles(m_pDocument->m_arThemes[0].m_pStyles[0], m_pDocument->m_oInfo, 9);
}
strDefaultTextStyle += _T("</p:defaultTextStyle>");
CString strPres = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>");
strPres += _T("<p:presentation xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\" saveSubsetFonts=\"1\"");
if ((m_pUserInfo) && (m_pUserInfo->m_bRtl))
{
strPres += _T(" rtl=\"1\"");
}
strPres += _T(">");
strPres += _T("<p:sldMasterIdLst>") + strPresMasters + _T("</p:sldMasterIdLst>");
strPres += strNotesIDs ;
strPres +=_T("<p:sldIdLst>") + strPresSlides + _T("</p:sldIdLst>");
strPres += strSizePres;
strPres += strDefaultTextStyle;
strPres +=_T("</p:presentation>");
oFile.CreateFile(m_strTempDirectory+ FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("presentation.xml"));
oFile.WriteStringUTF8(strPres);
oFile.CloseFile();
}
void NSPresentationEditor::CPPTXWriter::WriteAll()
{
CString strPptDirectory = m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR ;
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("media"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("theme"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slideMasters"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + _T("_rels"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slideLayouts"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slideLayouts") + FILE_SEPARATOR_STR + _T("_rels"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slides"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("slides") + FILE_SEPARATOR_STR + _T("_rels"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("notesMasters"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR + _T("_rels"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("notesSlides"));
FileSystem::Directory::CreateDirectory(strPptDirectory + _T("notesSlides") + FILE_SEPARATOR_STR + _T("_rels"));
CString strNotesTheme = _T("");
strNotesTheme.Format(_T("theme%d.xml"), (int)m_pDocument->m_arThemes.size() + 1);
strNotesTheme = strPptDirectory + _T("theme") + FILE_SEPARATOR_STR + strNotesTheme;
Writers::DefaultNotesThemeWriter writerNotesTheme;
writerNotesTheme.Write( strNotesTheme);
CString strNotesMaster = strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR + _T("notesMaster1.xml");
Writers::DefaultNotesMasterWriter writerNotesMaster;
writerNotesMaster.Write(strNotesMaster);
CString strNotesMasterRels = strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR +_T("_rels");
FileSystem::Directory::CreateDirectory(strNotesMasterRels);
CString strThemeNotesNum = _T("");
strThemeNotesNum.Format(_T("%d"), (int)m_pDocument->m_arThemes.size() + 1);
CString strVal = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"../theme/theme") + strThemeNotesNum + _T(".xml\"/></Relationships>");
CString strNotesMasterRelsFile = strNotesMasterRels+ FILE_SEPARATOR_STR + _T("notesMaster1.xml.rels");
CFile oFileRels;
oFileRels.CreateFile(strNotesMasterRelsFile);
oFileRels.WriteStringUTF8(strVal);
oFileRels.CloseFile();
// -----------------------------------------------------
WriteThemes();
WriteSlides();
}
void NSPresentationEditor::CPPTXWriter::WriteThemes()
{
CString strPptDirectory = m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR ;
int nCount = (int)m_pDocument->m_arThemes.size();
int nStartLayout = 0;
for (int nIndexTheme = 0; nIndexTheme < nCount; ++nIndexTheme)
{
CTheme* pTheme = &m_pDocument->m_arThemes[nIndexTheme];
CString strThemeFile;
strThemeFile.Format(_T("theme%d.xml"), nIndexTheme + 1);
strThemeFile = strPptDirectory + _T("theme") + FILE_SEPARATOR_STR + strThemeFile;
CFile oFile;
oFile.CreateFile(strThemeFile);
NSPresentationEditor::CStringWriter oStringWriter;
oStringWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><a:theme xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" name=\""));
oStringWriter.WriteStringXML(pTheme->m_sThemeName);
oStringWriter.WriteString(std::wstring(L"\"><a:themeElements>"));
WriteColorScheme(oStringWriter, L"Default", pTheme->m_arColorScheme);
oStringWriter.WriteString(std::wstring(L"<a:fontScheme name=\"default\"><a:majorFont><a:latin typeface=\""));
oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:majorFont>"));
oStringWriter.WriteString(std::wstring(L"<a:minorFont><a:latin typeface=\""));
if (pTheme->m_arFonts.size() >1 ) oStringWriter.WriteString(pTheme->m_arFonts[1].Name);
else oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:minorFont>"));
oStringWriter.WriteString(std::wstring(L"</a:fontScheme>"));
oStringWriter.WriteString(std::wstring(L"<a:fmtScheme name=\"Default\">\
<a:fillStyleLst><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\">\
<a:tint val=\"50000\"/><a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"35000\"><a:schemeClr val=\"phClr\"><a:tint val=\"37000\"/>\
<a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:tint val=\"15000\"/><a:satMod val=\"350000\"/>\
</a:schemeClr></a:gs></a:gsLst><a:lin ang=\"16200000\" scaled=\"1\"/></a:gradFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\">\
<a:schemeClr val=\"phClr\"><a:shade val=\"51000\"/><a:satMod val=\"130000\"/></a:schemeClr></a:gs><a:gs pos=\"80000\"><a:schemeClr val=\"phClr\">\
<a:shade val=\"93000\"/><a:satMod val=\"130000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:shade val=\"94000\"/>\
<a:satMod val=\"135000\"/></a:schemeClr></a:gs></a:gsLst><a:lin ang=\"16200000\" scaled=\"0\"/></a:gradFill></a:fillStyleLst><a:lnStyleLst>\
<a:ln w=\"9525\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\"><a:solidFill><a:schemeClr val=\"phClr\"><a:shade val=\"95000\"/><a:satMod val=\"105000\"/>\
</a:schemeClr></a:solidFill><a:prstDash val=\"solid\"/></a:ln><a:ln w=\"25400\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\"><a:solidFill>\
<a:schemeClr val=\"phClr\"/></a:solidFill><a:prstDash val=\"solid\"/></a:ln><a:ln w=\"38100\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\">\
<a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:prstDash val=\"solid\"/></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst>\
<a:outerShdw blurRad=\"40000\" dist=\"20000\" dir=\"5400000\" rotWithShape=\"0\"><a:srgbClr val=\"000000\"><a:alpha val=\"38000\"/></a:srgbClr>\
</a:outerShdw></a:effectLst></a:effectStyle><a:effectStyle><a:effectLst><a:outerShdw blurRad=\"40000\" dist=\"23000\" dir=\"5400000\" rotWithShape=\"0\">\
<a:srgbClr val=\"000000\"><a:alpha val=\"35000\"/></a:srgbClr></a:outerShdw></a:effectLst></a:effectStyle><a:effectStyle><a:effectLst>\
<a:outerShdw blurRad=\"40000\" dist=\"23000\" dir=\"5400000\" rotWithShape=\"0\"><a:srgbClr val=\"000000\"><a:alpha val=\"35000\"/></a:srgbClr>\
</a:outerShdw></a:effectLst><a:scene3d><a:camera prst=\"orthographicFront\"><a:rot lat=\"0\" lon=\"0\" rev=\"0\"/></a:camera>\
<a:lightRig rig=\"threePt\" dir=\"t\"><a:rot lat=\"0\" lon=\"0\" rev=\"1200000\"/></a:lightRig></a:scene3d><a:sp3d><a:bevelT w=\"63500\" h=\"25400\"/>\
</a:sp3d></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:gradFill rotWithShape=\"1\">\
<a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\"><a:tint val=\"40000\"/><a:satMod val=\"350000\"/></a:schemeClr></a:gs><a:gs pos=\"40000\">\
<a:schemeClr val=\"phClr\"><a:tint val=\"45000\"/><a:shade val=\"99000\"/><a:satMod val=\"350000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\">\
<a:schemeClr val=\"phClr\"><a:shade val=\"20000\"/><a:satMod val=\"255000\"/></a:schemeClr></a:gs></a:gsLst><a:path path=\"circle\">\
<a:fillToRect l=\"50000\" t=\"-80000\" r=\"50000\" b=\"180000\"/></a:path></a:gradFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\">\
<a:schemeClr val=\"phClr\"><a:tint val=\"80000\"/><a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\">\
<a:shade val=\"30000\"/><a:satMod val=\"200000\"/></a:schemeClr></a:gs></a:gsLst><a:path path=\"circle\">\
<a:fillToRect l=\"50000\" t=\"50000\" r=\"50000\" b=\"50000\"/></a:path></a:gradFill></a:bgFillStyleLst></a:fmtScheme>"));
oStringWriter.WriteString(std::wstring(L"</a:themeElements><a:objectDefaults/>"));
oStringWriter.WriteString(std::wstring(L"<a:extraClrSchemeLst>"));
for (int i = 0 ; i < pTheme->m_arExtraColorScheme.size(); i++)
{
CString str;
str.Format(_T(" %d"), i + 1);
WriteColorScheme(oStringWriter, pTheme->m_sThemeName + string2std_string(str), pTheme->m_arExtraColorScheme[i], true); //extra
}
oStringWriter.WriteString(std::wstring(L"</a:extraClrSchemeLst>"));
oStringWriter.WriteString(std::wstring(L"</a:theme>"));
oFile.WriteStringUTF8(oStringWriter.GetData());
oFile.CloseFile();
// masterslide
CRelsGenerator oRels(&m_oManager);
int nCountLayouts = (int)pTheme->m_arLayouts.size();
oRels.StartMaster(nIndexTheme, nStartLayout, nCountLayouts);
CStringWriter oWriter;
CString str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<p:sldMaster xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
<p:cSld>");
oWriter.WriteString(str1);
if (pTheme->m_bIsBackground)
{
WriteBackground(oWriter, oRels, pTheme->m_oBackground);
}
CString strElems = _T("<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
<a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>");
oWriter.WriteString(strElems);
size_t nElements = pTheme->m_arElements.size();
for (size_t nEl = 0; nEl < nElements; ++nEl)
{
if (isBodyPlaceholder(pTheme->m_arElements[nEl]->m_lPlaceholderType))
pTheme->m_arElements[nEl]->m_lPlaceholderType =100; //body !!
WriteElement(oWriter, oRels, pTheme->m_arElements[nEl]);
}
oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
CString strOverrideColorScheme = _T("<p:clrMap bg1=\"lt1\" tx1=\"dk1\" bg2=\"lt2\" tx2=\"dk2\" accent1=\"accent1\" accent2=\"accent2\" accent3=\"accent3\" accent4=\"accent4\" accent5=\"accent5\" accent6=\"accent6\" hlink=\"hlink\" folHlink=\"folHlink\"/>");
oWriter.WriteString(strOverrideColorScheme);
oWriter.WriteString(std::wstring(L"<p:sldLayoutIdLst>"));
size_t __nCountLayouts = 0;
for (int nIndexLayout = 0; nIndexLayout < nCountLayouts; ++nIndexLayout)
{
CString strMasterLayout = _T("");
strMasterLayout.Format(_T("<p:sldLayoutId id=\"%u\" r:id=\"rId%d\"/>"), 0x80000000 + nIndexTheme + 1 + nStartLayout + nIndexLayout, nIndexLayout + 1);
oWriter.WriteString(strMasterLayout);
WriteLayout(pTheme->m_arLayouts[nIndexLayout], nIndexLayout, nStartLayout, nIndexTheme);
}
oWriter.WriteString(std::wstring(L"</p:sldLayoutIdLst>"));
oWriter.WriteString(std::wstring(L"<p:txStyles>"));
oWriter.WriteString(std::wstring(L"<p:titleStyle>"));
CStylesWriter::ConvertStyles(pTheme->m_pStyles[1], pTheme->m_oInfo, oWriter, 9);
oWriter.WriteString(std::wstring(L"</p:titleStyle>"));
oWriter.WriteString(std::wstring(L"<p:bodyStyle>"));
CStylesWriter::ConvertStyles(pTheme->m_pStyles[2], pTheme->m_oInfo, oWriter, 9);
oWriter.WriteString(std::wstring(L"</p:bodyStyle>"));
oWriter.WriteString(std::wstring(L"<p:otherStyle>"));
CStylesWriter::ConvertStyles(pTheme->m_pStyles[3], pTheme->m_oInfo, oWriter, 9);
oWriter.WriteString(std::wstring(L"</p:otherStyle>"));
oWriter.WriteString(std::wstring(L"</p:txStyles></p:sldMaster>"));
CString strSlideMasterFile;
strSlideMasterFile.Format(_T("slideMaster%d.xml"), nIndexTheme + 1);
strSlideMasterFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + strSlideMasterFile;
oFile.CreateFile(strSlideMasterFile);
CString strMaster = oWriter.GetData();
oFile.WriteStringUTF8(strMaster);
oFile.CloseFile();
oRels.CloseRels();
CString strSlideMasterRelsFile;
strSlideMasterRelsFile.Format(_T("slideMaster%d.xml.rels"), nIndexTheme + 1);
strSlideMasterRelsFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + strSlideMasterRelsFile;
oRels.SaveRels(strSlideMasterRelsFile);
nStartLayout += nCountLayouts;
}
}
void NSPresentationEditor::CPPTXWriter::WriteColorScheme(CStringWriter& oStringWriter, const std::wstring & name, const std::vector<CColor> & colors, bool extra)
{
if (colors.size() < 1)
{
oStringWriter.WriteString(std::wstring(L"<a:clrScheme name=\"Default\"><a:dk1><a:sysClr val=\"windowText\" lastClr=\"000000\"/>\
</a:dk1><a:lt1><a:sysClr val=\"window\" lastClr=\"FFFFFF\"/></a:lt1><a:dk2><a:srgbClr val=\"1F497D\"/></a:dk2><a:lt2>\
<a:srgbClr val=\"EEECE1\"/></a:lt2><a:accent1><a:srgbClr val=\"4F81BD\"/></a:accent1><a:accent2><a:srgbClr val=\"C0504D\"/>\
</a:accent2><a:accent3><a:srgbClr val=\"9BBB59\"/></a:accent3><a:accent4><a:srgbClr val=\"8064A2\"/></a:accent4><a:accent5>\
<a:srgbClr val=\"4BACC6\"/></a:accent5><a:accent6><a:srgbClr val=\"F79646\"/></a:accent6><a:hlink><a:srgbClr val=\"0000FF\"/>\
</a:hlink><a:folHlink><a:srgbClr val=\"800080\"/></a:folHlink></a:clrScheme>"));
return;
}
if (extra)
oStringWriter.WriteString(std::wstring(L"<a:extraClrScheme>"));
oStringWriter.WriteString(std::wstring(L"<a:clrScheme name=\""));
oStringWriter.WriteStringXML(name);
oStringWriter.WriteString(std::wstring(L"\">"));
CString strVal;
strVal.Format(_T("<a:dk1><a:srgbClr val=\"%06X\"/></a:dk1>"), colors[14].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:lt1><a:srgbClr val=\"%06X\"/></a:lt1>"), colors[13].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:dk2><a:srgbClr val=\"%06X\"/></a:dk2>"), colors[16].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:lt2><a:srgbClr val=\"%06X\"/></a:lt2>"), colors[15].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent1><a:srgbClr val=\"%06X\"/></a:accent1>"), colors[5].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent2><a:srgbClr val=\"%06X\"/></a:accent2>"), colors[6].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent3><a:srgbClr val=\"%06X\"/></a:accent3>"), colors[7].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent4><a:srgbClr val=\"%06X\"/></a:accent4>"), colors[8].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent5><a:srgbClr val=\"%06X\"/></a:accent5>"), colors[9].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:accent6><a:srgbClr val=\"%06X\"/></a:accent6>"), colors[10].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:hlink><a:srgbClr val=\"%06X\"/></a:hlink>"), colors[11].GetLONG_RGB());
oStringWriter.WriteString(strVal);
strVal.Format(_T("<a:folHlink><a:srgbClr val=\"%06X\"/></a:folHlink>"), colors[12].GetLONG_RGB());
oStringWriter.WriteString(strVal);
oStringWriter.WriteString(std::wstring(L"</a:clrScheme>"));
if (extra)
{
oStringWriter.WriteString(std::wstring(L"<a:clrMap bg1=\"lt1\" tx1=\"dk1\" bg2=\"lt2\" tx2=\"dk2\" accent1=\"accent1\" \
accent2=\"accent2\" accent3=\"accent3\" accent4=\"accent4\" accent5=\"accent5\" accent6=\"accent6\" hlink=\"hlink\" folHlink=\"folHlink\"/>"));
oStringWriter.WriteString(std::wstring(L"</a:extraClrScheme>"));
}
}
void NSPresentationEditor::CPPTXWriter::WriteBackground(CStringWriter& oWriter, CRelsGenerator& oRels, CBrush& oBackground)
{
oWriter.WriteString(std::wstring(L"<p:bg><p:bgPr>"));
m_pShapeWriter->SetRelsGenerator(&oRels);
{
oWriter.WriteString(m_pShapeWriter->ConvertBrush(oBackground));
}
oWriter.WriteString(std::wstring(L"</p:bgPr></p:bg>"));
}
void NSPresentationEditor::CPPTXWriter::WriteElement(CStringWriter& oWriter, CRelsGenerator& oRels, IElement* pElement, CLayout* pLayout)
{
CImageElement* pImageElem = dynamic_cast<CImageElement*>(pElement);
if (pImageElem)
{
pImageElem->m_oMetric = m_pDocument->m_oInfo;
pImageElem->NormalizeCoordsByMetric();
m_pShapeWriter->SetShape(pImageElem);
}
CShapeElement* pShapeElem = dynamic_cast<CShapeElement*>(pElement);
if (pShapeElem)
{
pShapeElem->m_oMetric = m_pDocument->m_oInfo;
pShapeElem->NormalizeCoordsByMetric();
m_pShapeWriter->SetShape(pShapeElem);
}
if (pImageElem || pShapeElem)
{
m_pShapeWriter->SetRelsGenerator(&oRels);
if (NULL != pLayout)
{
if (-1 != pElement->m_lPlaceholderType)
{
size_t nCountElements = pLayout->m_arElements.size();
for (size_t nIndex = 0; nIndex < nCountElements; ++nIndex)
{
if ((pElement->m_lPlaceholderType == pLayout->m_arElements[nIndex]->m_lPlaceholderType) &&
(pElement->m_lPlaceholderID == pLayout->m_arElements[nIndex]->m_lPlaceholderID))
{
IElement* pElLayout = pLayout->m_arElements[nIndex];
bool bIsEqualTransform = ((pElement->m_dRotate == pElLayout->m_dRotate)
&& (pElement->m_bFlipH == pElLayout->m_bFlipH) && (pElement->m_bFlipV == pElLayout->m_bFlipV));
if (bIsEqualTransform)
{
if (pElement->m_rcBounds.IsEqual(pElLayout->m_rcBounds, 0.5))
pElement->m_bBoundsEnabled = false;
}
break;
}
}
}
}
oWriter.WriteString(m_pShapeWriter->ConvertShape());
}
}
void NSPresentationEditor::CPPTXWriter::WriteLayout(CLayout& oLayout, int nIndexLayout, int nStartLayout, int nIndexTheme)
{
CStringWriter oWriter;
CRelsGenerator oRels(&m_oManager);
oRels.StartLayout(nIndexTheme);
oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
oWriter.WriteString(std::wstring(L"<p:sldLayout xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\""));
oWriter.WriteString(std::wstring(L" type=\"") + oLayout.m_strLayoutType + _T("\""));
oWriter.WriteString(std::wstring(L" showMasterSp=\"") + (oLayout.m_bShowMasterShapes ? _T("1") : _T("0")));
oWriter.WriteString(std::wstring(L"\" preserve=\"1\"><p:cSld"));
if ( oLayout.m_sName.empty() == false)
oWriter.WriteString(std::wstring(L" name=\"") + oLayout.m_sName + std::wstring(L"\""));
oWriter.WriteString(std::wstring(L">"));
if (oLayout.m_bIsBackground)
{
WriteBackground(oWriter, oRels, oLayout.m_oBackground);
}
CString strElems = _T("<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
<a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>");
oWriter.WriteString(strElems);
size_t nElements = oLayout.m_arElements.size();
for (size_t nEl = 0; nEl < nElements; ++nEl)
{
WriteElement(oWriter, oRels, oLayout.m_arElements[nEl]);
}
oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
oWriter.WriteString(std::wstring(L"<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>"));
oWriter.WriteString(std::wstring(L"</p:sldLayout>"));
oRels.CloseRels();
CString strXml = oWriter.GetData();
CString strFile = _T("");
strFile.Format(_T("slideLayout%d.xml"), nIndexLayout + nStartLayout + 1);
CFile oFile;
CString strFileLayoutPath= m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("slideLayouts") + FILE_SEPARATOR_STR;
oFile.CreateFile(strFileLayoutPath + strFile);
oFile.WriteStringUTF8(strXml);
oFile.CloseFile();
strFile = _T("");
strFile.Format(_T("slideLayout%d.xml.rels"), nIndexLayout + nStartLayout + 1);
oRels.SaveRels(strFileLayoutPath + _T("_rels") + FILE_SEPARATOR_STR + strFile);
}
void NSPresentationEditor::CPPTXWriter::WriteSlide(int nIndexSlide)
{
CStringWriter oWriter;
CRelsGenerator oRels(&m_oManager);
CSlide* pSlide = m_pDocument->m_arSlides[nIndexSlide];
if (0 == pSlide->m_lThemeID)
oRels.StartSlide(pSlide->m_lLayoutID, nIndexSlide);
else
{
int nLayout = pSlide->m_lLayoutID;
for (int i = 0; i < pSlide->m_lThemeID; ++i)
nLayout += (int)m_pDocument->m_arThemes[i].m_arLayouts.size();
oRels.StartSlide(nLayout, nIndexSlide);
}
oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><p:sld xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">"));
oWriter.WriteString(std::wstring(L"<p:cSld"));
if ( pSlide->m_sName.empty() == false)
oWriter.WriteString(std::wstring(L" name=\"") + pSlide->m_sName + std::wstring(L"\""));
oWriter.WriteString(std::wstring(L">"));
if (pSlide->m_bIsBackground)
{
WriteBackground(oWriter, oRels, pSlide->m_oBackground);
}
oWriter.WriteString(std::wstring(L"<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
<a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>"));
for (size_t nEl = 0; nEl < pSlide->m_arElements.size(); ++nEl)
{
WriteElement(oWriter, oRels, pSlide->m_arElements[nEl], &m_pDocument->m_arThemes[pSlide->m_lThemeID].m_arLayouts[pSlide->m_lLayoutID]);
}
oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
oWriter.WriteString(std::wstring(L"<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>"));
oWriter.WriteString(std::wstring(L"<p:timing><p:tnLst><p:par><p:cTn id=\"1\" dur=\"indefinite\" restart=\"never\" nodeType=\"tmRoot\" /></p:par></p:tnLst></p:timing>"));
oWriter.WriteString(std::wstring(L"</p:sld>"));
oRels.CloseRels();
CString strXml = oWriter.GetData();
CString strFile = _T("");
strFile.Format(_T("slide%d.xml"), nIndexSlide + 1);
CString strFileSlidePath= m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("slides") + FILE_SEPARATOR_STR;
CFile oFile;
oFile.CreateFile(strFileSlidePath + strFile);
oFile.WriteStringUTF8(strXml);
oFile.CloseFile();
strFile = _T("");
strFile.Format(_T("slide%d.xml.rels"), nIndexSlide + 1);
oRels.SaveRels(strFileSlidePath + _T("_rels") + FILE_SEPARATOR_STR + strFile);
}
void NSPresentationEditor::CPPTXWriter::WriteSlides()
{
size_t nCountSlides = m_pDocument->m_arSlides.size();
for (size_t nIndexS = 0; nIndexS < nCountSlides; ++nIndexS)
{
CRelsGenerator::StartNotes((int)nIndexS, m_strTempDirectory, m_pDocument->m_arSlides[nIndexS]->m_strComment);
WriteSlide((int)nIndexS);
}
}
\ No newline at end of file
ASCPresentationEditor/PPTXWriter/Converter.h deleted 100644 → 0
View file @ b8e32028
#pragma once
#include "ImageManager.h"
class CStylesWriter;
class CPPTUserInfo;
namespace NSPresentationEditor
{
class CDocument;
class CShapeWriter;
class CPPTXWriter
{
public:
CString m_strTempDirectory;
CString m_strDstFileName;
CDocument * m_pDocument;
CPPTUserInfo* m_pUserInfo;
CImageManager m_oManager;
CShapeWriter* m_pShapeWriter;
public:
CPPTXWriter();
~CPPTXWriter();
void CreateFile(CDocument * pDocument);
void CreateFile(CPPTUserInfo* pUserInfo);
void CloseFile();
void Write()
{
}
protected:
void WriteApp (CFile& oFile);
void WriteContentTypes ();
void WritePresInfo ();
void WriteAll ();
void WriteThemes ();
void WriteSlides ();
void WriteLayout (CLayout& oLayout, int nIndexLayout, int nStartLayout, int nIndexTheme);
void WriteSlide (int nIndexSlide);
void WriteColorScheme (CStringWriter& oWriter, const std::wstring & name, const std::vector<CColor> & colors, bool extra = false);
void WriteBackground (CStringWriter& oWriter, CRelsGenerator& oRels, CBrush& oBackground);
void WriteElement (CStringWriter& oWriter, CRelsGenerator& oRels, IElement* pElement, CLayout* pLayout = NULL);
};
}
\ No newline at end of file
ASCPresentationEditor/PPTXWriter/ImageManager.h deleted 100644 → 0
View file @ b8e32028
#pragma once
#ifndef DISABLE_FILE_DOWNLOADER
#include "../../Common/FileDownloader.h"
#endif
namespace NSPresentationEditor
{
class CImageManager
{
private:
std::map<std::wstring, std::wstring> m_mapImages;
LONG m_lIndexNextImage;
std::wstring m_strDstMedia;
public:
CImageManager() : m_lIndexNextImage(0)
{
}
~CImageManager()
{
}
AVSINLINE void Clear()
{
m_mapImages.clear();
m_lIndexNextImage = 0;
}
AVSINLINE void SetDstMedia(const CString& strDst)
{
m_strDstMedia = strDst;
}
public:
AVSINLINE std::wstring GenerateImage(const std::wstring& strInput)
{
std::map<std::wstring, std::wstring>::iterator pPair = m_mapImages.find(strInput);
if (m_mapImages.end() != pPair)
{
return pPair->second;
}
if (IsNeedDownload(strInput))
return DownloadImage(strInput);
std::wstring strExts = _T(".jpg");
int nIndexExt = strInput.rfind(TCHAR('.'));
if (-1 != nIndexExt)
strExts = strInput.substr(nIndexExt);
if (strExts == _T(".tmp")) strExts = _T(".png");
CString strImage = _T("");
strImage.Format(_T("image%d"), m_lIndexNextImage++);
std::wstring strOutput = m_strDstMedia + string2std_string(strImage) + strExts;
strImage = _T("../media/") + strImage + std_string2string(strExts);
//
if (strOutput != strInput)
{
if (CDirectory::CopyFile(std_string2string(strInput), std_string2string(strOutput), NULL, NULL) == false)
{
return L"";
}
}
m_mapImages[strInput] = string2std_string(strImage);
return strImage;
}
AVSINLINE bool IsNeedDownload(const std::wstring& strFile)
{
int n1 = strFile.find(_T("www"));
int n2 = strFile.find(_T("http"));
int n3 = strFile.find(_T("ftp"));
if (((n1 >= 0) && (n1 < 10)) || ((n2 >= 0) && (n2 < 10)) || ((n3 >= 0) && (n3 < 10)))
return true;
return false;
}
AVSINLINE std::wstring DownloadImage(const std::wstring& strFile)
{
#ifndef DISABLE_FILE_DOWNLOADER
CFileDownloader oDownloader(strFile, TRUE);
oDownloader.Start( 1 );
while ( oDownloader.IsRunned() )
{
::Sleep( 10 );
}
if ( oDownloader.IsFileDownloaded() )
{
return GenerateImage( oDownloader.GetFilePath() );
}
#endif
return _T("");
}
};
static std::wstring CorrectXmlString3(const std::wstring & str)
{
std::wstring buffer;
buffer.reserve(str.size());
for(size_t pos = 0; pos != str.size(); ++pos)
{
switch(str[pos])
{
case '&': buffer.append(_T("&amp;")); break;
case '\"': buffer.append(_T("&quot;")); break;
case '\'': buffer.append(_T("&apos;")); break;
case '<': buffer.append(_T("&lt;")); break;
case '>': buffer.append(_T("&gt;")); break;
default: buffer.append(&str[pos], 1); break;
}
}
return buffer;
}
class CRelsGenerator
{
private:
NSPresentationEditor::CStringWriter m_oWriter;
int m_lNextRelsID;
std::map<std::wstring, int> m_mapImages;
CImageManager* m_pManager;
std::map<std::wstring, std::wstring> m_mapHyperlinks;
public:
CRelsGenerator(CImageManager* pManager) : m_oWriter(), m_lNextRelsID(1)
{
m_pManager = pManager;
}
~CRelsGenerator()
{
}
AVSINLINE void Clear()
{
m_oWriter.ClearNoAttack();
m_lNextRelsID = 1;
m_mapImages.clear();
m_mapHyperlinks.clear();
}
AVSINLINE void StartMaster(int nIndexTheme, int nStartLayoutIndex, int nCountLayouts)
{
CString str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
m_oWriter.WriteString(str1);
int nCurrent = nStartLayoutIndex;
for (int i = 0; i < nCountLayouts; ++i)
{
CString str = _T("");
str.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout%d.xml\"/>"),
m_lNextRelsID++, nCurrent + 1);
++nCurrent;
m_oWriter.WriteString(str);
}
CString s = _T("");
s.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"../theme/theme%d.xml\"/>" ),
m_lNextRelsID++, nIndexTheme + 1);
m_oWriter.WriteString(s);
}
AVSINLINE void StartLayout(int nIndexTheme)
{
CString str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
m_oWriter.WriteString(str1);
CString str = _T("");
str.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster\" Target=\"../slideMasters/slideMaster%d.xml\"/>"),
m_lNextRelsID++, nIndexTheme + 1);
m_oWriter.WriteString(str);
}
AVSINLINE void StartSlide(int nIndexLayout, int nIndexSlide)
{
CString str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
m_oWriter.WriteString(str1);
CString str = _T("");
str.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout%d.xml\"/>"),
m_lNextRelsID++, nIndexLayout + 1);
m_oWriter.WriteString(str);
str = _T("");
str.Format(_T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide\" Target=\"../notesSlides/notesSlide%d.xml\"/>"), m_lNextRelsID++, nIndexSlide + 1);
m_oWriter.WriteString(str);
}
static AVSINLINE void StartNotes(int nIndexSlide, CString strDirectory, std::wstring strComment)
{
CString sNum = _T("");
sNum.Format(_T("%d"), nIndexSlide + 1);
CString strNoteSlideRels = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"../slides/slide") + sNum + _T(".xml\"/>\
<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"../notesMasters/notesMaster1.xml\"/>\
</Relationships>");
CString strNoteRels = strDirectory + FILE_SEPARATOR_STR + _T("ppt") +
+ FILE_SEPARATOR_STR + _T("notesSlides")
+ FILE_SEPARATOR_STR + _T("_rels")
+ FILE_SEPARATOR_STR + _T("notesSlide") + sNum + _T(".xml.rels");
CFile oFile;
oFile.CreateFile(strNoteRels);
oFile.WriteStringUTF8(strNoteSlideRels);
oFile.CloseFile();
CString strNoteSlide = strDirectory + FILE_SEPARATOR_STR + _T("ppt") +
+ FILE_SEPARATOR_STR + _T("notesSlides")
+ FILE_SEPARATOR_STR + _T("notesSlide") + sNum + _T(".xml");
oFile.CreateFile(strNoteSlide);
CString strW1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
<p:notes xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
<p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x=\"0\" y=\"0\"/>\
<a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr><p:sp><p:nvSpPr><p:cNvPr id=\"100000\" name=\"\"/>\
<p:cNvSpPr><a:spLocks noGrp=\"1\" noChangeArrowheads=\"1\"/></p:cNvSpPr><p:nvPr><p:ph type=\"body\" idx=\"1\"/></p:nvPr></p:nvSpPr><p:spPr/>\
<p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr smtClean=\"0\"/><a:t>");
CString strW2 = _T("</a:t></a:r><a:endParaRPr/></a:p></p:txBody></p:sp></p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:notes>");
CorrectXmlString(strComment);
oFile.WriteStringUTF8(strW1);
oFile.WriteStringUTF8(strComment);
oFile.WriteStringUTF8(strW2);
oFile.CloseFile();
}
AVSINLINE void CloseRels()
{
CString str = _T("</Relationships>");
m_oWriter.WriteString(str);
}
AVSINLINE void SaveRels(const CString& strFile)
{
CFile oFile;
oFile.CreateFile(strFile);
CString strMem = m_oWriter.GetData();
oFile.WriteStringUTF8(strMem);
oFile.CloseFile();
}
AVSINLINE CString WriteHyperlink(const std::wstring& strHyperlink)
{
std::map<std::wstring, std::wstring>::iterator pPair = m_mapHyperlinks.find(strHyperlink);
if (m_mapHyperlinks.end() != pPair)
{
CString strRid = _T("");
strRid.Format(_T("rId%d"), pPair->second);
return strRid;
}
m_mapHyperlinks[strHyperlink] = m_lNextRelsID;
CString strRid = _T("");
strRid.Format(_T("rId%d"), m_lNextRelsID++);
std::wstring strRels = _T("<Relationship Id=\"") ;
strRels += string2std_string(strRid) + _T("\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink\" Target=\"");
strRels += strHyperlink + _T("\"/>");
m_oWriter.WriteString(strRels);
}
AVSINLINE CString WriteHyperlinkImage(const std::wstring& strImage, bool bExternal = true)
{
std::map<std::wstring, int>::iterator pPair = m_mapImages.find(strImage);
if (m_mapImages.end() != pPair)
{
CString strRid = _T("");
strRid.Format(_T("rId%d"), pPair->second);
return strRid;
}
m_mapImages[strImage] = m_lNextRelsID;
CString strRid = _T("");
strRid.Format(_T("rId%d"), m_lNextRelsID++);
std::wstring strRels = _T("<Relationship Id=\"") ;
strRels += string2std_string(strRid) + _T("\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image\" Target=\"");
strRels += strImage + _T("\"");
if (bExternal)
strRels += std::wstring(L" TargetMode=\"External\"");
strRels += std::wstring(L"/>");
m_oWriter.WriteString(strRels);
return strRid;
}
AVSINLINE CString WriteImage(const std::wstring& strImagePath)
{
std::wstring strImage = m_pManager->GenerateImage(strImagePath);
if (strImage.empty()) return WriteHyperlinkImage(CorrectXmlString3(strImagePath), true);
return WriteHyperlinkImage(strImage, false);
}
};
}
ASCPresentationEditor/PPTXWriter/ShapeWriter.cpp deleted 100644 → 0
View file @ b8e32028
#include "ShapeWriter.h"
#include "StylesWriter.h"
#include "../../ASCOfficeXlsFile2/source/XlsXlsxConverter/ShapeType.h"
#include "../../Common/MS-LCID.h"
const double EMU_MM = 36000;
void CStylesWriter::ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLevel, NSPresentationEditor::CMetricInfo& oMetricInfo,
NSPresentationEditor::CStringWriter& oWriter, const int& nLevel)
{// CTextPFRun CTextCFRun ShapeWriter - todooo -
CString str1;
if (nLevel == 9)
str1 = _T("<a:defPPr");
else
str1.Format(_T("<a:lvl%dpPr"), nLevel + 1);
oWriter.WriteString(str1);
NSPresentationEditor::CTextPFRun* pPF = &oLevel.m_oPFRun;
if (pPF->textDirection.is_init())
{
if (pPF->textDirection.get() == 1) oWriter.WriteString(std::wstring(L" rtl=\"1\""));
else oWriter.WriteString(std::wstring(L" rtl=\"0\""));
}
if (pPF->fontAlign.is_init())
{
CString strProp = GetFontAlign(pPF->fontAlign.get());
oWriter.WriteString(std::wstring(L" fontAlgn=\"") + string2std_string(strProp) + _T("\""));
}
if (pPF->leftMargin.is_init())
{
CString strProp;
strProp.Format(_T(" marL=\"%d\""), pPF->leftMargin.get());
oWriter.WriteString(strProp);
if (pPF->indent.is_init() == false)
pPF->indent = (LONG)0;
}
if (pPF->indent.is_init())
{
CString strProp;
strProp.Format(_T(" indent=\"%d\""), pPF->indent.get());
oWriter.WriteString(strProp);
}
if (pPF->textAlignment.is_init())
{
CString strProp = GetTextAlign(pPF->textAlignment.get());
oWriter.WriteString(std::wstring(L" algn=\"") + string2std_string(strProp) + _T("\""));
}
if (pPF->defaultTabSize.is_init())
{
CString strProp;
strProp.Format(_T(" defTabSz=\"%d\""), pPF->defaultTabSize.get());
oWriter.WriteString(strProp);
}
CString str2 = _T(">");
oWriter.WriteString(str2);
if (pPF->tabStops.size() > 0)
{
oWriter.WriteString(std::wstring(L"<a:tabLst>"));
for (int t = 0 ; t < pPF->tabStops.size(); t++)
{
CString strTabPos; strTabPos.Format(L"%d", pPF->tabStops[t].first) ;
oWriter.WriteString(std::wstring(L"<a:tab pos=\"") + string2std_string(strTabPos) + _T("\""));
if (pPF->tabStops[t].second == 1) oWriter.WriteString(std::wstring(L" algn=\"ctr\"/>"));
else if (pPF->tabStops[t].second == 2) oWriter.WriteString(std::wstring(L" algn=\"r\"/>"));
else if (pPF->tabStops[t].second == 3) oWriter.WriteString(std::wstring(L" algn=\"dec\"/>"));
else oWriter.WriteString(std::wstring(L" algn=\"l\"/>"));
}
oWriter.WriteString(std::wstring(L"</a:tabLst>"));
}
if (pPF->hasBullet.is_init())
{
if (pPF->hasBullet.get())
{
if (pPF->bulletColor.is_init())
{
oWriter.WriteString(std::wstring(L"<a:buClr>"));
oWriter.WriteString(NSPresentationEditor::CShapeWriter::ConvertColor(pPF->bulletColor.get(), 255));
oWriter.WriteString(std::wstring(L"</a:buClr>"));
}
if (pPF->bulletSize.is_init())
{
if (pPF->bulletSize.get() > 24 && pPF->bulletSize.get() < 401)
{
CString str;
str.Format(_T("<a:buSzPct val=\"%d\"/>"), pPF->bulletSize.get() * 1000 );
oWriter.WriteString(str);
}
if (pPF->bulletSize.get() < 0 && pPF->bulletSize.get() > -4001)
{
CString str;
str.Format(_T("<a:buSzPts val=\"%d\"/>"), - pPF->bulletSize.get() );
oWriter.WriteString(str);
}
}
if (pPF->bulletFontProperties.is_init())
{
oWriter.WriteString(std::wstring(L"<a:buFont typeface=\"") + pPF->bulletFontProperties->strFontName + _T("\"/>"));
}
if (pPF->bulletChar.is_init())
{
wchar_t bu = pPF->bulletChar.get();
oWriter.WriteString(std::wstring(L"<a:buChar char=\""));
oWriter.WriteStringXML(std::wstring(&bu, 1));
oWriter.WriteString(std::wstring(L"\"/>"));
}
}
else
{
CString strB = _T("<a:buNone/>");
oWriter.WriteString(strB);
}
}
double dKoef1 = 3.52777778;
if (pPF->lineSpacing.is_init())
{
LONG val = pPF->lineSpacing.get();
if (val > 0)
{
CString str = _T("");
str.Format(_T("<a:lnSpc><a:spcPts val=\"%d\"/></a:lnSpc>"), (int)(val * 0.125 * 100/*/ dKoef1*/));
oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{
CString str = _T("");
str.Format(_T("<a:lnSpc><a:spcPct val=\"%d\"/></a:lnSpc>"), -val * 1000);
oWriter.WriteString(str);
}
}
if (pPF->spaceAfter.is_init())
{
LONG val = pPF->spaceAfter.get();
if (val > 0)
{
CString str = _T("");
str.Format(_T("<a:spcAft><a:spcPts val=\"%d\"/></a:spcAft>"), (int)(val * 0.125 * 100/*/ dKoef1*/));
oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{
CString str = _T("");
str.Format(_T("<a:spcAft><a:spcPct val=\"%d\"/></a:spcAft>"), -val * 1000);
oWriter.WriteString(str);
}
}
if (pPF->spaceBefore.is_init())
{
LONG val = pPF->spaceBefore.get();
if (val > 0)
{
CString str = _T("");
str.Format(_T("<a:spcBef><a:spcPts val=\"%d\"/></a:spcBef>"), (int)(val * 0.125 * 100/*/ dKoef1*/));
oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{
CString str = _T("");
str.Format(_T("<a:spcBef><a:spcPct val=\"%d\"/></a:spcBef>"), -val * 1000);
oWriter.WriteString(str);
}
}
CString strCF1 = _T("<a:defRPr");
oWriter.WriteString(strCF1);
NSPresentationEditor::CTextCFRun* pCF = &oLevel.m_oCFRun;
if (pCF->Size.is_init())
{
CString strProp = _T("");
strProp.Format(_T(" sz=\"%d\""), (int)(100 * pCF->Size.get()));
oWriter.WriteString(strProp);
}
if (pCF->FontBold.is_init())
{
if (pCF->FontBold.get())
oWriter.WriteString(std::wstring(L" b=\"1\""));
else
oWriter.WriteString(std::wstring(L" b=\"0\""));
}
if (pCF->FontItalic.is_init())
{
if (pCF->FontItalic.get())
oWriter.WriteString(std::wstring(L" i=\"1\""));
else
oWriter.WriteString(std::wstring(L" i=\"0\""));
}
if (pCF->Language.is_init())
{
std::wstring str_lang = msLCID2wstring(pCF->Language.get());
if (str_lang.length() > 0)
oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + _T("\""));
}
oWriter.WriteString(std::wstring(L">"));
if (pCF->Color.is_init())
{
if (pCF->Color->m_lSchemeIndex != -1)
{
CString strProp = _T("<a:solidFill><a:schemeClr val=\"") + GetColorInScheme(pCF->Color->m_lSchemeIndex) + _T("\"/></a:solidFill>");
oWriter.WriteString(strProp);
}
else
{
CString strColor = _T("");
strColor.Format(_T("%06x"), pCF->Color->GetLONG_RGB());
CString strProp = _T("<a:solidFill><a:srgbClr val=\"") + strColor + _T("\"/></a:solidFill>");
oWriter.WriteString(strProp);
}
}
if (pCF->Typeface.is_init())
{
if (0 == pCF->Typeface.get())
{
CString strProp = _T("<a:latin typeface=\"+mj-lt\"/>");
oWriter.WriteString(strProp);
}
else
{
CString strProp = _T("<a:latin typeface=\"+mn-lt\"/>");
oWriter.WriteString(strProp);
}
}
else if ((pCF->FontProperties.is_init()) && (!pCF->FontProperties->strFontName.empty()))
{
oWriter.WriteString(std::wstring(L"<a:latin typeface=\"") + pCF->FontProperties->strFontName + _T("\"/>"));
}
if (pCF->FontPropertiesEA.is_init())
{
oWriter.WriteString(std::wstring(L"<a:ea typeface=\"") + pCF->FontPropertiesEA->strFontName + _T("\"/>"));
}
if (pCF->FontPropertiesSym.is_init())
{
oWriter.WriteString(std::wstring(L"<a:sym typeface=\"") + pCF->FontPropertiesSym->strFontName + _T("\"/>"));
}
CString strCF2 = _T("</a:defRPr>");
oWriter.WriteString(strCF2);
CString str3 = _T("");
if (nLevel == 9)
str3 = _T("</a:defPPr>");
else
str3.Format(_T("</a:lvl%dpPr>"), nLevel + 1);
oWriter.WriteString(str3);
}
NSPresentationEditor::CShapeWriter::CShapeWriter()
{
m_pRels = NULL;
m_lNextShapeID = 1000;
m_bWordArt = false;
m_bTextBox = false;
//////////////////////////////////////////////////////////////////////
m_dDpiX = 96.0;
m_dDpiY = 96.0;
m_lClipMode = c_nClipRegionTypeWinding;
m_pSimpleGraphicsConverter = new Aggplus::CGraphicsPathSimpleConverter();
m_pSimpleGraphicsConverter->SetRenderer(this);
m_dTransformAngle = 0.0;
m_dWidth = 100;
m_dHeight = 100;
m_pFontManager = NULL;
m_pImageElement = NULL;
m_pShapeElement = NULL;
}
CString NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
{
NSPresentationEditor::CStringWriter line_writer;
CString strLine = _T("");
strLine.Format(_T("<a:ln w=\"%d\">"), (int)(pen.Size * 36000));
line_writer.WriteString(strLine);
line_writer.WriteString(std::wstring(L"<a:solidFill>"));
line_writer.WriteString(ConvertColor(pen.Color, pen.Alpha));
line_writer.WriteString(std::wstring(L"</a:solidFill>"));
line_writer.WriteString(std::wstring(L"<a:round/><a:headEnd/><a:tailEnd/></a:ln>"));
return line_writer.GetData();
}
CString NSPresentationEditor::CShapeWriter::ConvertBrush(CBrush & brush)
{
NSPresentationEditor::CStringWriter brush_writer;
if (brush.Type == c_BrushTypeTexture)
{
CString strRid = m_pRels->WriteImage(brush.TexturePath);
brush_writer.WriteString(std::wstring(L"<a:blipFill dpi=\"0\" rotWithShape=\"1\"><a:blip r:embed=\"") + string2std_string(strRid) + _T("\"/><a:srcRect/>"));
if ( brush.TextureMode == c_BrushTextureModeTile)
brush_writer.WriteString(std::wstring(L"<a:tile/>"));
else
brush_writer.WriteString(std::wstring(L"<a:stretch><a:fillRect/></a:stretch>"));
brush_writer.WriteString(std::wstring(L"</a:blipFill>"));
}
else if ( brush.Type == c_BrushTypeNoFill)
{
brush_writer.WriteString(std::wstring(L"<a:noFill/>"));
}
else if ( brush.Type == c_BrushTypePathGradient1 ||
brush.Type == c_BrushTypePathGradient2 ||
brush.Type == c_BrushTypeCenter ||
brush.Type == c_BrushTypeHorizontal ||
brush.Type == c_BrushTypeVertical )
{
brush_writer.WriteString(std::wstring(L"<a:gradFill>"));
brush_writer.WriteString(std::wstring(L"<a:gsLst><a:gs pos=\"0\">"));
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(std::wstring(L"</a:gs><a:gs pos=\"100000\">"));
brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
brush_writer.WriteString(std::wstring(L"</a:gs></a:gsLst><a:lin ang=\"5400000\" scaled=\"1\"/>"));
brush_writer.WriteString(std::wstring(L"</a:gradFill>"));
}
else if(brush.Type == c_BrushTypePattern)
{// - -
brush_writer.WriteString(std::wstring(L"<a:pattFill prst=\"pct80\">"));
brush_writer.WriteString(std::wstring(L"<a:fgClr>"));
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(std::wstring(L"</a:fgClr>"));
brush_writer.WriteString(std::wstring(L"<a:bgClr>"));
brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
brush_writer.WriteString(std::wstring(L"</a:bgClr>"));
brush_writer.WriteString(std::wstring(L"</a:pattFill>"));
}
else
{
brush_writer.WriteString(std::wstring(L"<a:solidFill>"));
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(std::wstring(L"</a:solidFill>"));
}
return brush_writer.GetData();
}
CString NSPresentationEditor::CShapeWriter::ConvertShadow(CShadow & shadow)
{
std::wstring Preset;
bool Inner = false;
if (shadow.Visible == false) return _T("");
double dist = sqrt(shadow.DistanceY * shadow.DistanceY + shadow.DistanceX * shadow.DistanceX);
double dir = 0;
if (abs(shadow.DistanceY) > 0)
{
dir = 180 * atan(shadow.DistanceX / shadow.DistanceY) / 3.1415926;
if (dir < 0) dir += 180;
if (shadow.DistanceX < 0 && shadow.DistanceY < 0) dir *= 10;
}
if (shadow.Type == 1) Preset = L"shdw13";
if (shadow.Type == 5)
{
if (shadow.DistanceX < 0 && shadow.DistanceY < 0) Preset = L"shdw18";
else Preset = L"shdw17";
}
if (shadow.Type == 2 && shadow.OriginX < 0)
{
if (shadow.OriginX < -1.4)
{
if (shadow.ScaleYToY < 0) Preset = L"shdw15";
else Preset = L"shdw11";
}
else
{
if (shadow.ScaleYToY < 0) Preset = L"shdw16";
else Preset = L"shdw12";
}
}
CString strDir = _T("");
CString strDist = _T("");
if (shadow.DistanceY != 0 && shadow.DistanceX != 0)
{
if (shadow.DistanceY < 0 && shadow.DistanceX < 0) dir /=2;
strDir.Format(_T(" dir=\"%d\""), (int)(dir * 60000));
strDist.Format(_T(" dist=\"%d\""), (int)(dist * 36000));
}
CString strSY = _T("");
if (shadow.ScaleYToY < 1 || shadow.ScaleYToY > 1)
{
if (shadow.ScaleYToX < 1)shadow.ScaleYToY = -shadow.ScaleYToY;
strSY.Format(_T(" sy=\"%d\""), (int)(shadow.ScaleYToY * 100000));
}
CString strSX = _T("");
if (shadow.ScaleYToX < 1 || shadow.ScaleYToX > 1)
{
//strSX.Format(_T(" sx=\"%d\""), (int)(shadow.ScaleYToX * 100000));
strSX.Format(_T(" kx=\"%d\""), (int)((shadow.ScaleYToX + 0.5) * 360000));
}
NSPresentationEditor::CStringWriter shadow_writer;
shadow_writer.WriteString(std::wstring(L"<a:effectLst>"));
if (!Preset.empty())
{
shadow_writer.WriteString(std::wstring(L"<a:prstShdw"));
shadow_writer.WriteString(std::wstring(L" prst=\"") + Preset + std::wstring(L"\""));
//shadow_writer.WriteString(std::wstring(L" rotWithShape=\"0\" algn=\"ctr\""));
shadow_writer.WriteString(strDir);
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(std::wstring(L">"));
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(std::wstring(L"</a:prstShdw>"));
}
else if (Inner)
{
shadow_writer.WriteString(std::wstring(L"<a:innerShdw"));
shadow_writer.WriteString(std::wstring(L" rotWithShape=\"0\""));
if (strSX.IsEmpty() && strSY.IsEmpty())
{
shadow_writer.WriteString(std::wstring(L" algn=\"ctr\""));
}
shadow_writer.WriteString(strSX);
shadow_writer.WriteString(strSY);
shadow_writer.WriteString(strDir);
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(std::wstring(L">"));
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(std::wstring(L"</a:innerShdw>"));
}
else
{
shadow_writer.WriteString(std::wstring(L"<a:outerShdw"));
shadow_writer.WriteString(std::wstring(L" rotWithShape=\"0\""));
if (strSX.IsEmpty() && strSY.IsEmpty())
{
shadow_writer.WriteString(std::wstring(L" algn=\"ctr\""));
}
shadow_writer.WriteString(strSX);
shadow_writer.WriteString(strSY);
shadow_writer.WriteString(strDir);
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(std::wstring(L">"));
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(std::wstring(L"</a:outerShdw>"));
}
shadow_writer.WriteString(std::wstring(L"</a:effectLst>"));
return shadow_writer.GetData();
}
CString NSPresentationEditor::CShapeWriter::ConvertColor(CColor & color, long alpha)
{
NSPresentationEditor::CStringWriter color_writer;
if (color.m_lSchemeIndex == -1)
{
if (255 == alpha)
{
CString str = _T("");
str.Format(_T("<a:srgbClr val=\"%06X\"/>"), color.GetLONG_RGB());
color_writer.WriteString(str);
}
else
{
CString str = _T("");
str.Format(_T("<a:srgbClr val=\"%06X\"><a:alpha val=\"%d\"/></a:srgbClr>"), color.GetLONG_RGB(), (int)(alpha * 100000 / 255));
color_writer.WriteString(str);
}
}
else
{
if (255 == alpha)
{
CString str = _T("<a:schemeClr val=\"") + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + _T("\"/>");
color_writer.WriteString(str);
}
else
{
CString strAlpha; strAlpha.Format(_T("%d"), (int)(alpha * 100000 / 255));
CString str = _T("<a:schemeClr val=\"") + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + _T("\"><a:alpha val=\"") + strAlpha + _T("\"/></a:schemeClr>");
color_writer.WriteString(str);
}
}
return color_writer.GetData();
}
void NSPresentationEditor::CShapeWriter::WriteImageInfo()
{
m_oWriter.WriteString(std::wstring(L"<p:nvPicPr>"));
CString strShapeID;
strShapeID.Format(_T("%d"), m_lNextShapeID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") +string2std_string(strShapeID) + L"\"" );
if (m_pImageElement->m_sName.empty()) m_pImageElement->m_sName = std::wstring(L"Image ") + string2std_string(strShapeID);
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(m_pImageElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
//if (!m_pImageElement->m_sDescription.empty())
//{//
// m_oWriter.WriteString(std::wstring(L" descr=\""));
// m_oWriter.WriteStringXML(m_pImageElement->m_sDescription);
// m_oWriter.WriteString(std::wstring(L"\""));
//}
m_oWriter.WriteString(std::wstring(L"></p:cNvPr><p:cNvPicPr><a:spLocks noGrp=\"1\" noChangeAspect=\"1\"/></p:cNvPicPr>"));
++m_lNextShapeID;
if (-1 != m_pImageElement->m_lPlaceholderType)
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr><p:ph"));
if (m_pImageElement->m_lPlaceholderType > 0)
m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(m_pImageElement->m_lPlaceholderType) +_T("\""));
if (-1 != m_pImageElement->m_lPlaceholderID)
{
CString strIdx; strIdx.Format(_T("%d"), m_pImageElement->m_lPlaceholderID );
m_oWriter.WriteString(std::wstring(L" idx=\"") + string2std_string(strIdx) + _T("\""));
}
m_oWriter.WriteString(std::wstring(L"/></p:nvPr>"));
}
else
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
}
CString str2 = _T("</p:nvPicPr>");
m_oWriter.WriteString(str2);
}
void NSPresentationEditor::CShapeWriter::WriteShapeInfo()
{
m_oWriter.WriteString(std::wstring(L"<p:nvSpPr>"));
CString strShapeID = _T("");
if (m_pShapeElement->m_lID < 0)
m_pShapeElement->m_lID = m_lNextShapeID;
strShapeID.Format(L"%d", m_pShapeElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + string2std_string(strShapeID) + L"\"");
if (m_pShapeElement->m_sName.empty()) m_pShapeElement->m_sName = std::wstring(L"Shape ") + string2std_string(strShapeID);
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(m_pShapeElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!m_pShapeElement->m_sDescription.empty())
{
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteStringXML(m_pShapeElement->m_sDescription);
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (!m_pShapeElement->m_sHyperlink.empty())
{
std::wstring rId = (m_pRels->WriteHyperlink(m_pShapeElement->m_sHyperlink)).GetBuffer();
m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));
m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId ));
m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
}
m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
m_oWriter.WriteString(std::wstring(L"<p:cNvSpPr"));
if (m_bTextBox)
m_oWriter.WriteString(std::wstring(L" txBox=\"1\""));
m_oWriter.WriteString(std::wstring(L"><a:spLocks noGrp=\"1\" noChangeArrowheads=\"1\"/>"));
m_oWriter.WriteString(std::wstring(L"</p:cNvSpPr>"));
++m_lNextShapeID;
if (-1 != m_pShapeElement->m_lPlaceholderType)
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr><p:ph"));
if (m_pShapeElement->m_lPlaceholderType > 0 /*&& !isBodyPlaceholder(m_pShapeElement->m_lPlaceholderType)*/)
m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(m_pShapeElement->m_lPlaceholderType) + _T("\""));
if ( m_pShapeElement->m_lPlaceholderID != -1)
{
CString strIdx; strIdx.Format(_T("%d"), m_pShapeElement->m_lPlaceholderID );
m_oWriter.WriteString(std::wstring(L" idx=\"") + string2std_string(strIdx) + _T("\""));
}
if (m_pShapeElement->m_lPlaceholderSizePreset > 1 && !isTitlePlaceholder(m_pShapeElement->m_lPlaceholderType))
{
if (m_pShapeElement->m_lPlaceholderSizePreset == 1)
m_oWriter.WriteString(std::wstring(L" size=\"half\""));
if (m_pShapeElement->m_lPlaceholderSizePreset == 2)
m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
if (m_pShapeElement->m_lPlaceholderSizePreset == 3)
{
if (isBodyPlaceholder(m_pShapeElement->m_lPlaceholderType))
m_oWriter.WriteString(std::wstring(L" size=\"half\""));
else
m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
}
}
m_oWriter.WriteString(std::wstring(L"/></p:nvPr>"));
}
else
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
}
CString str2 = _T("</p:nvSpPr>");
m_oWriter.WriteString(str2);
}
void NSPresentationEditor::CShapeWriter::WriteTextInfo()
{
size_t nCount = m_pShapeElement->m_oShape.m_oText.m_arParagraphs.size();
m_oWriter.WriteString(std::wstring(L"<p:txBody>"));
m_oWriter.WriteString(std::wstring(L"<a:bodyPr" ));
// int __l = (int)((m_oBounds.left + m_oTextRect.left) * EMU_MM);
//int __t = (int)((m_oBounds.top + m_oTextRect.top) * EMU_MM);
//int __r = (int)((m_oBounds.right - m_oTextRect.right)* EMU_MM);
//int __b = (int)((m_oBounds.bottom - m_oTextRect.bottom)* EMU_MM);
//if (true)
//{
// CString str;
// str.Format(L" lIns=\"%d\" tIns=\"%d\" rIns=\"%d\" bIns=\"%d\"",__l, __t, __r, __b);
// m_oWriter.WriteString(str);
//}
//else
m_oWriter.WriteString(std::wstring(L" lIns=\"0\" tIns=\"0\" rIns=\"0\" bIns=\"0\""));
if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 0 )
m_oWriter.WriteString(" anchor=\"t\"");
else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 2 )
m_oWriter.WriteString(" anchor=\"b\"");
else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 1 )
{
m_oWriter.WriteString(" anchor=\"ctr\"");
m_oWriter.WriteString(" anchorCtr=\"0\"");
}
if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate > 0)
{
CString strProp;
strProp.Format(_T(" rot=\"%d\""), (int)(m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate * 60000));
m_oWriter.WriteString(strProp);
}
if (m_pShapeElement->m_oShape.m_oText.m_bVertical)
{
m_oWriter.WriteString(" vert=\"eaVert\"");
}
m_oWriter.WriteString(std::wstring(L">"));
if (m_bWordArt)
{
std::wstring prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)m_pShapeElement->m_lShapeType);
m_oWriter.WriteString(std::wstring(L"<a:prstTxWarp"));
m_oWriter.WriteString(std::wstring(L" prst=\"") + prstTxWarp + _T("\">"));
m_oWriter.WriteString(std::wstring(L"<a:avLst>"));//
CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(m_pShapeElement->m_oShape.m_pShape);
CString strVal;
for (int i = 0 ; (pPPTShape) && (i < pPPTShape->m_arAdjustments.size()); i++)
{
switch(m_pShapeElement->m_lShapeType)
{
case oox::msosptTextFadeUp:
{
double kf = 4.63; //""
strVal.Format(L"%d", (int)(kf * pPPTShape->m_arAdjustments[i]));
m_oWriter.WriteString(std::wstring(L"<a:gd name=\"adj\" fmla=\"val "));
m_oWriter.WriteString(strVal + _T("\"/>"));
}break;
}
}
m_oWriter.WriteString(std::wstring(L"</a:avLst>"));
m_oWriter.WriteString(std::wstring(L"</a:prstTxWarp>"));
}
if (m_pShapeElement->m_oShape.m_oText.m_bAutoFit)
{
m_oWriter.WriteString(std::wstring(L"<a:spAutoFit/>"));
}
m_oWriter.WriteString(std::wstring(L"</a:bodyPr>"));
if (0 == nCount)
{
m_oWriter.WriteString(std::wstring(L"<a:lstStyle/><a:p><a:endParaRPr dirty=\"0\"/></a:p></p:txBody>"));
return;
}
m_oWriter.WriteString(std::wstring(L"<a:lstStyle>"));
if (!m_bWordArt)
{
CStylesWriter::ConvertStyles(m_pShapeElement->m_oShape.m_oText.m_oStyles, m_oMetricInfo, m_oWriter);
}
m_oWriter.WriteString(std::wstring(L"</a:lstStyle>"));
for (size_t nIndexPar = 0; nIndexPar < nCount; ++nIndexPar)
{
NSPresentationEditor::CParagraph* pParagraph = &m_pShapeElement->m_oShape.m_oText.m_arParagraphs[nIndexPar];
//if (m_bWordArt && nIndexPar == nCount-1)
//{
// if (pParagraph->m_arSpans.size() < 1) break;
// if (pParagraph->m_arSpans.size() == 1 && pParagraph->m_arSpans[0].m_strText.empty()) break;
//}
CString _str1 = _T("");
_str1.Format(_T("<a:p><a:pPr lvl=\"%d\""), pParagraph->m_lTextLevel);
m_oWriter.WriteString(_str1);
NSPresentationEditor::CTextPFRun* pPF = &pParagraph->m_oPFRun;
if (pPF->textDirection.is_init())
{
if (pPF->textDirection.get() == 1) m_oWriter.WriteString(std::wstring(L" rtl=\"1\""));
else m_oWriter.WriteString(std::wstring(L" rtl=\"0\""));
}
if (pPF->fontAlign.is_init())
{
CString strProp = CStylesWriter::GetFontAlign(pPF->fontAlign.get());
m_oWriter.WriteString(std::wstring(L" fontAlgn=\"") + string2std_string(strProp) + _T("\""));
}
if (pPF->leftMargin.is_init())
{
CString strProp;
strProp.Format(_T(" marL=\"%d\""), pPF->leftMargin.get());
m_oWriter.WriteString(strProp);
if (pPF->indent.is_init() == false)
pPF->indent = (LONG)0;
}
if (pPF->indent.is_init())
{
int ind = pPF->indent.get();
CString strProp = _T("");
strProp.Format(_T(" indent=\"%d\""), pPF->indent.get());
m_oWriter.WriteString(strProp);
}
if (pPF->textAlignment.is_init())
{
CString strProp = CStylesWriter::GetTextAlign(pPF->textAlignment.get());
m_oWriter.WriteString(std::wstring(L" algn=\"") + string2std_string(strProp) + _T("\""));
}
if (pPF->defaultTabSize.is_init())
{
CString strProp = _T("");
strProp.Format(_T(" defTabSz=\"%d\""), pPF->defaultTabSize.get());
m_oWriter.WriteString(strProp);
}
CString _str2 = _T(">");
m_oWriter.WriteString(_str2);
double dKoef1 = 3.52777778; // :-) ...
if (pPF->lineSpacing.is_init())
{
LONG val = pPF->lineSpacing.get();
//1/1024 master unit or 1/589824 inch.
//1 inch = 576 master unit -> 1 master unit = 0.125 pt
if (val > 0)//The absolute value specifies spacing in master units.
{
CString str = _T("");
str.Format(_T("<a:lnSpc><a:spcPts val=\"%d\"/></a:lnSpc>"), (int)(val* 0.125 * 100/*/ dKoef1*/));
m_oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{//0 to 13200, inclusive - The value specifies spacing as a percentage of the text line height.
CString str = _T("");
str.Format(_T("<a:lnSpc><a:spcPct val=\"%d\"/></a:lnSpc>"), -val * 1000);
m_oWriter.WriteString(str);
}
}
if (pPF->spaceAfter.is_init())
{
LONG val = pPF->spaceAfter.get();
if (val > 0)
{
CString str = _T("");
str.Format(_T("<a:spcAft><a:spcPts val=\"%d\"/></a:spcAft>"), (int)(val * 0.125 * 100/*/ dKoef1*/));
m_oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{
CString str;
str.Format(_T("<a:spcAft><a:spcPct val=\"%d\"/></a:spcAft>"), -val * 1000);
m_oWriter.WriteString(str);
}
}
if (pPF->spaceBefore.is_init())
{
LONG val = pPF->spaceBefore.get();
if (val > 0)
{
CString str = _T("");
str.Format(_T("<a:spcBef><a:spcPts val=\"%d\"/></a:spcBef>"), (int)(val * 0.125 * 100/*/ dKoef1*/));
m_oWriter.WriteString(str);
}
else if (val < 0 && val > -13200)
{
CString str;
str.Format(_T("<a:spcBef><a:spcPct val=\"%d\"/></a:spcBef>"), -val * 1000);
m_oWriter.WriteString(str);
}
}
if (pPF->hasBullet.is_init())
{
if (pPF->hasBullet.get())
{
if (pPF->bulletColor.is_init())
{
m_oWriter.WriteString(std::wstring(L"<a:buClr>"));
m_oWriter.WriteString(ConvertColor(pPF->bulletColor.get(), 255));
m_oWriter.WriteString(std::wstring(L"</a:buClr>"));
}
if (pPF->bulletSize.is_init())
{
if (pPF->bulletSize.get() > 24 && pPF->bulletSize.get() < 401)
{
CString str;
str.Format(_T("<a:buSzPct val=\"%d\"/>"), pPF->bulletSize.get() * 1000 );
m_oWriter.WriteString(str);
}
if (pPF->bulletSize.get() < 0 && pPF->bulletSize.get() > -4001)
{
CString str;
str.Format(_T("<a:buSzPts val=\"%d\"/>"), - pPF->bulletSize.get() );
m_oWriter.WriteString(str);
}
}
if (pPF->bulletFontProperties.is_init())
{
m_oWriter.WriteString(std::wstring(L"<a:buFont typeface=\"") + pPF->bulletFontProperties->strFontName + _T("\"/>"));
}
bool set = true;
if (pPF->bulletFontProperties.is_init() == false && pPF->bulletSize.is_init() == false)
{
m_oWriter.WriteString(std::wstring(L"<a:buFontTx/>"));
if (pPF->bulletColor.is_init() == false)
set = false;
}
if (pPF->bulletChar.is_init())
{
wchar_t bu = pPF->bulletChar.get();
m_oWriter.WriteString(std::wstring(L"<a:buChar char=\""));
m_oWriter.WriteStringXML(std::wstring(&bu, 1));
m_oWriter.WriteString(std::wstring(L"\"/>"));
set = true;
}
if (!set && pParagraph->m_lTextLevel == 0)
{
wchar_t bu = 0x2022;
m_oWriter.WriteString(std::wstring(L"<a:buChar char=\""));
m_oWriter.WriteStringXML(std::wstring(&bu, 1));
m_oWriter.WriteString(std::wstring(L"\"/>"));
}
}
else
{
m_oWriter.WriteString(std::wstring(L"<a:buNone/>"));
}
}
m_oWriter.WriteString(std::wstring(L"</a:pPr>"));
std::wstring typeRun = L"a:r";
size_t nCountSpans = pParagraph->m_arSpans.size();
for (size_t nSpan = 0; nSpan < nCountSpans; ++nSpan)
{
if (true)
{
if ((nSpan == (nCountSpans - 1)) && (_T("\n") == pParagraph->m_arSpans[nSpan].m_strText || pParagraph->m_arSpans[nSpan].m_strText.empty()) )
{
NSPresentationEditor::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
{
CString strProp;
strProp.Format(_T("<a:endParaRPr lang=\"en-US\" sz=\"%d\"/>"), (int)(100 * pCF->Size.get()));
m_oWriter.WriteString(strProp);
}
else
{
m_oWriter.WriteString(std::wstring(L"<a:endParaRPr lang=\"en-US\"/>"));
}
continue;
}
}
if (pParagraph->m_arSpans[nSpan].m_strText.empty()) continue;
NSPresentationEditor::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
bool bIsBr = false;
int span_sz = pParagraph->m_arSpans[nSpan].m_strText.length() ;
if ((span_sz==1 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (TCHAR)13 )) ||
((span_sz==2 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (TCHAR)13 ) && ( pParagraph->m_arSpans[nSpan].m_strText[1] == (TCHAR)13 ))))
{
bIsBr=true;
}
if (bIsBr)
{
//if (pParagraph->m_arSpans.size() < 2)
continue;
CString strRun1 = _T("<a:br><a:rPr");
m_oWriter.WriteString(strRun1);
}
else
{
if (m_pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber && pParagraph->m_arSpans[nSpan].m_bField)
{
m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D038279B-FC19-497E-A7D1-5ADD9CAF016F}\" type=\"slidenum\"><a:rPr"));
}
else if (m_pShapeElement->m_lPlaceholderType == PT_MasterDate && m_pShapeElement->m_nFormatDate == 1 && pParagraph->m_arSpans[nSpan].m_bField)
{
m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D7E01130-044F-4930-9A27-C729C70D8524}\" type=\"datetime1\"><a:rPr"));
}
else
{
m_oWriter.WriteString(std::wstring(L"<a:r><a:rPr"));
}
}
if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
{
CString strProp = _T("");
strProp.Format(_T(" sz=\"%d\""), (int)(100 * pCF->Size.get()));
m_oWriter.WriteString(strProp);
}
if (pCF->FontBold.is_init())
{
if (pCF->FontBold.get())
m_oWriter.WriteString(std::wstring(L" b=\"1\""));
else
m_oWriter.WriteString(std::wstring(L" b=\"0\""));
}
if (pCF->FontItalic.is_init())
{
if (pCF->FontItalic.get())
m_oWriter.WriteString(std::wstring(L" i=\"1\""));
else
m_oWriter.WriteString(std::wstring(L" i=\"0\""));
}
if (pCF->FontUnderline.is_init())
{
if (pCF->FontUnderline.get())
m_oWriter.WriteString(std::wstring(L" u=\"sng\""));
else
m_oWriter.WriteString(std::wstring(L" u=\"none\""));
}
if (pCF->Language.is_init())
{
std::wstring str_lang = msLCID2wstring(pCF->Language.get());
if (str_lang.length() > 0)
m_oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + _T("\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (m_bWordArt)
{// - , , !!!
if (m_pShapeElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(m_pShapeElement->m_oPen));
}
m_oWriter.WriteString(ConvertBrush(m_pShapeElement->m_oBrush));
m_oWriter.WriteString(ConvertShadow(m_pShapeElement->m_oShadow));
}
else
{
if (pCF->Color.is_init())
{
if (pCF->Color->m_lSchemeIndex != -1)
{
CString strProp = _T("<a:solidFill><a:schemeClr val=\"") + CStylesWriter::GetColorInScheme(pCF->Color->m_lSchemeIndex) + _T("\"/></a:solidFill>");
m_oWriter.WriteString(strProp);
}
else
{
CString strColor = _T("");
strColor.Format(_T("%06x"), pCF->Color->GetLONG_RGB());
CString strProp = _T("<a:solidFill><a:srgbClr val=\"") + strColor + _T("\"/></a:solidFill>");
m_oWriter.WriteString(strProp);
}
}
}
if (pCF->Typeface.is_init())
{
if (0 == pCF->Typeface.get())
{
CString strProp = _T("<a:latin typeface=\"+mj-lt\"/>");
m_oWriter.WriteString(strProp);
}
else
{
CString strProp = _T("<a:latin typeface=\"+mn-lt\"/>");
m_oWriter.WriteString(strProp);
}
}
else if (pCF->FontProperties.is_init())
{
m_oWriter.WriteString(std::wstring(L"<a:latin typeface=\"") + pCF->FontProperties->strFontName + _T("\"/>"));
}
if (pCF->FontPropertiesEA.is_init())
{
m_oWriter.WriteString(std::wstring(L"<a:ea typeface=\"") + pCF->FontPropertiesEA->strFontName + _T("\"/>"));
}
if (pCF->FontPropertiesSym.is_init())
{
m_oWriter.WriteString(std::wstring(L"<a:sym typeface=\"") + pCF->FontPropertiesSym->strFontName + _T("\"/>"));
}
m_oWriter.WriteString(std::wstring(L"</a:rPr>"));
if (!bIsBr)
{
CString strT1 = _T("<a:t>");
m_oWriter.WriteString(strT1);
std::wstring strT = pParagraph->m_arSpans[nSpan].m_strText;
NSPresentationEditor::CorrectXmlString(strT);
m_oWriter.WriteString(strT);
CString strT2 = _T("</a:t>");
m_oWriter.WriteString(strT2);
if ((m_pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber ||
(m_pShapeElement->m_lPlaceholderType == PT_MasterDate && m_pShapeElement->m_nFormatDate == 1)) && pParagraph->m_arSpans[nSpan].m_bField)
{
m_oWriter.WriteString(std::wstring(L"</a:fld>"));
}
else
m_oWriter.WriteString(std::wstring(L"</a:r>"));
}
else
{
m_oWriter.WriteString(std::wstring(L"</a:br>"));
}
}
CString strEndPar = _T("</a:p>");
m_oWriter.WriteString(strEndPar);
}
CString str5 = _T("</p:txBody>");
m_oWriter.WriteString(str5);
}
CString NSPresentationEditor::CShapeWriter::ConvertShape()
{
if (m_pImageElement) return ConvertImage();
if (m_pShapeElement == NULL) return _T("");
std::wstring prstTxWarp;
std::wstring prstGeom = oox::Spt2ShapeType_mini((oox::MSOSPT)m_pShapeElement->m_lShapeType);
//rect, ellipse, line
if (prstGeom.empty())
{
prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)m_pShapeElement->m_lShapeType);
if (prstTxWarp.empty() == false)
{
m_bWordArt = true;
m_bTextBox = true;
prstGeom = L"rect";
m_oBrush.Type = c_BrushTypeNoFill;
}
}
else
{
if (oox::msosptTextBox == (oox::MSOSPT)m_pShapeElement->m_lShapeType)
m_bTextBox = true;
if (oox::msosptLine == (oox::MSOSPT)m_pShapeElement->m_lShapeType)
m_pShapeElement->m_bLine = true;
}
m_oWriter.WriteString(std::wstring(L"<p:sp>"));
WriteShapeInfo();
CGeomShapeInfo oInfo;
oInfo.SetBounds(m_oBounds);
oInfo.m_dRotate = m_pShapeElement->m_dRotate;
oInfo.m_bFlipH = m_pShapeElement->m_bFlipH;
oInfo.m_bFlipV = m_pShapeElement->m_bFlipV;
oInfo.m_lOriginalWidth = (LONG)m_pShapeElement->m_rcBoundsOriginal.GetWidth();
oInfo.m_lOriginalHeight = (LONG)m_pShapeElement->m_rcBoundsOriginal.GetHeight();
m_oWriter.WriteString(std::wstring(L"<p:spPr>"));
if (m_pShapeElement->m_bBoundsEnabled)
{
CString str;
m_oWriter.WriteString(std::wstring(L"<a:xfrm"));
if (0 != m_pShapeElement->m_dRotate)
{
str.Format(L" rot=\"%d\"", (int)(m_pShapeElement->m_dRotate * 60000));
m_oWriter.WriteString(str);
}
if (m_pShapeElement->m_bFlipH)
{
m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
}
if (m_pShapeElement->m_bFlipV)
{
m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
}
m_oWriter.WriteString(std::wstring(L">"));
str.Format(_T("<a:off x=\"%d\" y=\"%d\"/>"), (int)m_pShapeElement->m_rcBoundsOriginal.left, (int)m_pShapeElement->m_rcBoundsOriginal.top);
m_oWriter.WriteString(str);
int width = m_pShapeElement->m_rcBoundsOriginal.right - m_pShapeElement->m_rcBoundsOriginal.left;
int height = m_pShapeElement->m_rcBoundsOriginal.bottom - m_pShapeElement->m_rcBoundsOriginal.top;
if ( width > 0 || height > 0 )
{
str.Format(_T("<a:ext cx=\"%d\" cy=\"%d\"/>"), width, height);
m_oWriter.WriteString(str);
}
m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
}
if (m_pShapeElement->m_oShape.m_lDrawType & c_ShapeDrawType_Graphic)
{
m_pShapeElement->m_oShape.ToRenderer(dynamic_cast<IRenderer*>(this), oInfo, m_oMetricInfo, 0.0, 1.0);
}
if ((prstGeom.empty() == false || m_pShapeElement->m_bShapePreset) && prstTxWarp.empty())
{
if (prstGeom.empty()) prstGeom = L"rect";
m_oWriter.WriteString(std::wstring(L"<a:prstGeom"));
{
m_oWriter.WriteString(std::wstring(L" prst=\"") + prstGeom + std::wstring(L"\">"));
if (!m_bWordArt)
{
m_oWriter.WriteString(std::wstring(L"<a:avLst/>"));
}
}
m_oWriter.WriteString(std::wstring(L"</a:prstGeom>"));
}
else if (prstTxWarp.empty())
{
m_oWriter.WriteString(m_pShapeElement->ConvertPPTShapeToPPTX());
}
else
{
//word art
m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"/>"));
}
if (!m_bWordArt)
{
m_oWriter.WriteString(ConvertBrush(m_pShapeElement->m_oBrush));
if (m_pShapeElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(m_pShapeElement->m_oPen));
}
m_oWriter.WriteString(ConvertShadow(m_pShapeElement->m_oShadow));
}
m_oWriter.WriteString(std::wstring(L"</p:spPr>"));
WriteTextInfo();
m_oWriter.WriteString(std::wstring(L"</p:sp>"));
m_pShapeElement = NULL;
return m_oWriter.GetData();
}
CString NSPresentationEditor::CShapeWriter::ConvertImage()
{
if (m_pImageElement->m_bImagePresent == false)
{
if (m_pImageElement->m_sName.empty()) return _T("");
//ppt_presentation.ppt -
m_pImageElement->m_strImageFileName.clear();
m_pImageElement->m_bImagePresent = true;
}
m_oWriter.WriteString(std::wstring(L"<p:pic>"));
WriteImageInfo();
CGeomShapeInfo oInfo;
oInfo.SetBounds(m_oBounds);
oInfo.m_dRotate = m_pImageElement->m_dRotate;
oInfo.m_bFlipH = m_pImageElement->m_bFlipH;
oInfo.m_bFlipV = m_pImageElement->m_bFlipV;
oInfo.m_lOriginalWidth = (LONG)m_pImageElement->m_rcBoundsOriginal.GetWidth();
oInfo.m_lOriginalHeight = (LONG)m_pImageElement->m_rcBoundsOriginal.GetHeight();
m_oWriter.WriteString(std::wstring(L"<p:blipFill>"));
CString strRid;
if (m_pImageElement->m_strImageFileName.empty())
{
strRid = m_pRels->WriteHyperlinkImage(CorrectXmlString3(m_pImageElement->m_sImageName));
}
else
{
strRid = m_pRels->WriteImage(m_pImageElement->m_strImageFileName);
}
CString strWrite = _T("<a:blip r:embed=\"") + strRid + _T("\"/>");
m_oWriter.WriteString(strWrite);
m_oWriter.WriteString(std::wstring(L"<a:srcRect"));
if (m_pImageElement->m_bCropEnabled)
{
CString sCrop;
sCrop.Format(L" l=\"%d\"", (size_t)(m_pImageElement->m_lcropFromLeft*1.5));
m_oWriter.WriteString(sCrop);
sCrop.Format(L" t=\"%d\"", (size_t)(m_pImageElement->m_lcropFromTop*1.5));
m_oWriter.WriteString(sCrop);
sCrop.Format(L" r=\"%d\"", (size_t)(m_pImageElement->m_lcropFromRight*1.5));
m_oWriter.WriteString(sCrop);
sCrop.Format(L" b=\"%d\"", (size_t)(m_pImageElement->m_lcropFromBottom*1.5));
m_oWriter.WriteString(sCrop);
}
m_oWriter.WriteString(std::wstring(L"/>"));
if (m_pImageElement->m_bTile)
{
m_oWriter.WriteString(std::wstring(L"<a:tile/>"));
}
else if (m_pImageElement->m_bStretch)
{
m_oWriter.WriteString(std::wstring(L"<a:stretch><a:fillRect/></a:stretch>"));
}
m_oWriter.WriteString(std::wstring(L"</p:blipFill>"));
m_oWriter.WriteString(std::wstring(L"<p:spPr>"));
if (m_pImageElement->m_bBoundsEnabled)
{
CString str;
m_oWriter.WriteString(std::wstring(L"<a:xfrm"));
if (0 != m_pImageElement->m_dRotate)
{
str.Format(L" rot=\"%d\"", m_pImageElement->m_dRotate * 60000);
m_oWriter.WriteString(str);
}
if (m_pImageElement->m_bFlipH)
{
m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
}
if (m_pImageElement->m_bFlipV)
{
m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
}
m_oWriter.WriteString(std::wstring(L">"));
str.Format(_T("<a:off x=\"%d\" y=\"%d\"/>"), (int)m_pImageElement->m_rcBoundsOriginal.left, (int)m_pImageElement->m_rcBoundsOriginal.top);
m_oWriter.WriteString(str);
int width = m_pImageElement->m_rcBoundsOriginal.right - m_pImageElement->m_rcBoundsOriginal.left;
int height = m_pImageElement->m_rcBoundsOriginal.bottom - m_pImageElement->m_rcBoundsOriginal.top;
if ( width > 0 || height > 0 )
{
str.Format(_T("<a:ext cx=\"%d\" cy=\"%d\"/>"), width, height);
m_oWriter.WriteString(str);
}
m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
}
m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>"));
m_oWriter.WriteString(ConvertBrush(m_pImageElement->m_oBrush));
if (m_pImageElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(m_pImageElement->m_oPen));
}
m_oWriter.WriteString(std::wstring(L"</p:spPr>"));
m_oWriter.WriteString(std::wstring(L"</p:pic>"));
m_pImageElement = NULL;
return m_oWriter.GetData();
}
HRESULT NSPresentationEditor::CShapeWriter::get_Type(LONG* lType)
{
if (NULL == lType)
return S_FALSE;
*lType = c_nSVGConverter;
return S_OK;
}
//-------- --------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::NewPage()
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_Height(double* dHeight)
{
if (NULL != dHeight)
*dHeight = m_dHeight;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_Height(const double& dHeight)
{
m_dHeight = dHeight;
m_oBaseTransform.Reset();
double dScaleX = 43200 / (std::max)(m_oBounds.GetWidth(), 0.01);
double dScaleY = 43200 / (std::max)(m_oBounds.GetHeight(), 0.01);
m_oBaseTransform.Translate(-m_oBounds.left, -m_oBounds.top, Aggplus::MatrixOrderAppend);
m_oBaseTransform.Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);
CalculateFullTransform();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_Width(double* dWidth)
{
if (NULL != dWidth)
*dWidth = m_dWidth;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_Width(const double& dWidth)
{
m_dWidth = dWidth;
m_oBaseTransform.Reset();
double dScaleX = 43200 / (std::max)(m_oBounds.GetWidth(), 0.01);
double dScaleY = 43200 / (std::max)(m_oBounds.GetHeight(), 0.01);
m_oBaseTransform.Translate(-m_oBounds.left, -m_oBounds.top, Aggplus::MatrixOrderAppend);
m_oBaseTransform.Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);
CalculateFullTransform();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_DpiX(double* dDpiX)
{
if (NULL != dDpiX)
*dDpiX = m_dDpiX;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_DpiY(double* dDpiY)
{
if (NULL != dDpiY)
*dDpiY = m_dDpiY;
return S_OK;
}
// pen --------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetPen(BSTR bsXML)
{
//m_oPen.FromXmlString((CString)bsXML);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenColor(LONG* lColor)
{
*lColor = m_oPen.Color.GetLONG();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenColor(const LONG& lColor)
{
BYTE lScheme = ((DWORD)(lColor)) >> 24;
if (0xFF != lScheme)
m_oPen.Color.SetBGR(lColor);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenAlpha(LONG* lAlpha)
{
*lAlpha = m_oPen.Alpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenAlpha(const LONG& lAlpha)
{
m_oPen.Alpha = lAlpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenSize(double* dSize)
{
*dSize = m_oPen.Size;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenSize(const double& dSize)
{
m_oPen.Size = dSize * 25.4 / 96.0;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenDashStyle(BYTE* val)
{
*val = m_oPen.DashStyle;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenDashStyle(const BYTE& val)
{
m_oPen.DashStyle = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineStartCap(BYTE* val)
{
*val = m_oPen.LineStartCap;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineStartCap(const BYTE& val)
{
m_oPen.LineStartCap = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineEndCap(BYTE* val)
{
*val = m_oPen.LineEndCap;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineEndCap(const BYTE& val)
{
m_oPen.LineEndCap = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineJoin(BYTE* val)
{
*val = m_oPen.LineJoin;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineJoin(const BYTE& val)
{
m_oPen.LineJoin = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenDashOffset(double* val)
{
*val = m_oPen.DashOffset;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenDashOffset(const double& val)
{
m_oPen.DashOffset = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenAlign(LONG* val)
{
*val = m_oPen.Align;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenAlign(const LONG& val)
{
m_oPen.Align = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenMiterLimit(double* val)
{
*val = m_oPen.MiterLimit;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenMiterLimit(const double& val)
{
m_oPen.MiterLimit = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PenDashPattern(double* pPattern, LONG lCount)
{
if (NULL != pPattern)
{
m_oPen.SetDashPattern(pPattern, lCount);
}
return S_OK;
}
// brush ------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetBrush(BSTR bsXML)
{
//m_oBrush.FromXmlString((CString)bsXML);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushType(LONG* lType)
{
*lType = m_oBrush.Type;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushType(const LONG& lType)
{
m_oBrush.Type = lType;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushColor1(LONG* lColor)
{
*lColor = m_oBrush.Color1.GetLONG();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushColor1(const LONG& lColor)
{
BYTE lScheme = ((DWORD)(lColor)) >> 24;
if (0xFF != lScheme)
m_oBrush.Color1.SetBGR(lColor);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushAlpha1(LONG* lAlpha)
{
*lAlpha = m_oBrush.Alpha1;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushAlpha1(const LONG& lAlpha)
{
m_oBrush.Alpha1 = lAlpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushColor2(LONG* lColor)
{
*lColor = m_oBrush.Color2.GetLONG();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushColor2(const LONG& lColor)
{
m_oBrush.Color2.SetBGR(lColor);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushAlpha2(LONG* lAlpha)
{
*lAlpha = m_oBrush.Alpha2;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushAlpha2(const LONG& lAlpha)
{
m_oBrush.Alpha2 = lAlpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTexturePath(std::wstring* bsPath)
{
if (bsPath == NULL) return S_OK;
*bsPath = m_oBrush.TexturePath;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTexturePath(const std::wstring& bsPath)
{
m_oBrush.TexturePath = bsPath;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTextureMode(LONG* lMode)
{
*lMode = m_oBrush.TextureMode;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTextureMode(const LONG& lMode)
{
m_oBrush.TextureMode = lMode;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTextureAlpha(LONG* lTxAlpha)
{
*lTxAlpha = m_oBrush.TextureAlpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTextureAlpha(const LONG& lTxAlpha)
{
m_oBrush.TextureAlpha = lTxAlpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushLinearAngle(double* dAngle)
{
*dAngle = m_oBrush.LinearAngle;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushLinearAngle(const double& dAngle)
{
m_oBrush.LinearAngle = dAngle;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height)
{
m_oBrush.Rectable = val;
m_oBrush.Rect.X = (float)left;
m_oBrush.Rect.Y = (float)top;
m_oBrush.Rect.Width = (float)width;
m_oBrush.Rect.Height = (float)height;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::BrushBounds(const double& left, const double& top, const double& width, const double& height)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount)
{
return S_OK;
}
// font -------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetFont(BSTR bsXML)
{
//m_oFont.FromXmlString((CString)bsXML);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontName(std::wstring* bsName)
{
if (bsName == NULL) return S_OK;
*bsName = m_oFont.Name;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontName(const std::wstring& bsName)
{
m_oFont.Name = bsName;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontPath(std::wstring* bsName)
{
if (bsName == NULL) return S_OK;
*bsName = m_oFont.Path;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontPath(const std::wstring& bsName)
{
m_oFont.Path = std_string2string(bsName);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontSize(double* dSize)
{
*dSize = m_oFont.Size;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontSize(const double& dSize)
{
m_oFont.Size = dSize;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontStyle(LONG* lStyle)
{
*lStyle = m_oFont.GetStyle();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontStyle(const LONG& lStyle)
{
m_oFont.SetStyle(lStyle);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontStringGID(INT* bGID)
{
*bGID = m_oFont.StringGID;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontStringGID(const INT& bGID)
{
m_oFont.StringGID = bGID;
m_pFontManager->SetStringGID(bGID);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontCharSpace(double* dSpace)
{
*dSpace = m_oFont.CharSpace;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontCharSpace(const double& dSpace)
{
m_oFont.CharSpace = dSpace;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontFaceIndex(int* lFaceIndex)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontFaceIndex(const int& lFaceIndex)
{
return S_OK;
}
// shadow -----------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetShadow(BSTR bsXML)
{
//m_oShadow.FromXmlString((CString)bsXML);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowDistanceX(double* val)
{
*val = m_oShadow.DistanceX;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowDistanceX(double val)
{
m_oShadow.DistanceX = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowDistanceY(double* val)
{
*val = m_oShadow.DistanceY;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowDistanceY(double val)
{
m_oShadow.DistanceY = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowBlurSize(double* val)
{
*val = m_oShadow.BlurSize;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowBlurSize(double val)
{
m_oShadow.BlurSize = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowColor(LONG* val)
{
*val = m_oShadow.Color.GetLONG();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowColor(LONG val)
{
m_oShadow.Color.SetBGR(val);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowAlpha(LONG* val)
{
*val = m_oShadow.Alpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowAlpha(LONG val)
{
m_oShadow.Alpha = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowVisible(bool* val)
{
*val = m_oShadow.Visible;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowVisible(bool val)
{
m_oShadow.Visible = val;
return S_OK;
}
// edge -------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetEdgeText(BSTR bsXML)
{
//m_oEdge.FromXmlString((CString)bsXML);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeVisible(LONG* val)
{
*val = m_oEdge.Visible;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeVisible(LONG val)
{
m_oEdge.Visible = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeColor(LONG* val)
{
*val = m_oEdge.Color.GetLONG();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeColor(LONG val)
{
m_oEdge.Color.SetBGR(val);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeAlpha(LONG* val)
{
*val = m_oEdge.Alpha;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeAlpha(LONG val)
{
m_oEdge.Alpha = val;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeDist(double* val)
{
*val = m_oEdge.Dist;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeDist(double val)
{
m_oEdge.Dist = val;
return S_OK;
}
//-------- --------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
if (c_nHyperlinkType == m_lCurrentCommandType)
return S_OK;
if (true)
{
PathCommandEnd();
BeginCommand(c_nPathType);
PathCommandText(bsText, x, y, w, h);
DrawPath(c_nWindingFillMode);
EndCommand(c_nPathType);
PathCommandEnd();
return S_OK;
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandLong(const LONG& lType, const LONG& lCommand)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDouble(const LONG& lType, const double& dCommand)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandString(const LONG& lType, const std::wstring& sCommand)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
if (true)
{
PathCommandEnd();
BeginCommand(c_nPathType);
PathCommandTextEx(bsUnicodeText, pGids, nGidsCount ,x, y, w, h);
DrawPath(c_nWindingFillMode);
EndCommand(c_nPathType);
PathCommandEnd();
return S_OK;
}
return S_OK;
}
//-------- ---------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::BeginCommand(const DWORD& lType)
{
if (c_nPathType == lType)
{
m_pSimpleGraphicsConverter->PathCommandEnd();
}
m_lCurrentCommandType = lType;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::EndCommand(const DWORD& lType)
{
m_lCurrentCommandType = -1;
return S_OK;
}
//-------- Graphics Path -----------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::PathCommandMoveTo(const double& x, const double& y)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
MoveTo(x, y);
}
else
{
m_pSimpleGraphicsConverter->PathCommandMoveTo(x, y);
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandLineTo(const double& x, const double& y)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
LineTo(x, y);
}
else
{
m_pSimpleGraphicsConverter->PathCommandLineTo(x, y);
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandLinesTo(double* points, const int& count)
{
m_pSimpleGraphicsConverter->PathCommandLinesTo(points, count);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
CurveTo(x1, y1, x2, y2, x3, y3);
}
else
{
m_pSimpleGraphicsConverter->PathCommandCurveTo(x1, y1, x2, y2, x3, y3);
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandCurvesTo(double* points, const int& count)
{
m_pSimpleGraphicsConverter->PathCommandCurvesTo(points, count);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle)
{
m_pSimpleGraphicsConverter->PathCommandArcTo(x, y, w, h, startAngle, sweepAngle);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandClose()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
Close();
}
else
{
m_pSimpleGraphicsConverter->PathCommandClose();
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandEnd()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
End();
}
else
{
m_pSimpleGraphicsConverter->PathCommandEnd();
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::DrawPath(const LONG& nType)
{
bool bIsStroke = ((0x01 == (nType & 0x01)) && (0 != m_oPen.Alpha));
bool bIsFill = ((0xFF < nType) && (0 != m_oBrush.Alpha1));
if (bIsStroke && bIsFill)
{
CString str = _T("");
str.Format(_T("<a:path w=\"43200\" h=\"43200\">"));
m_oWriterVML.WriteString(str);
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
else if (bIsStroke)
{
CString str = _T("");
str.Format(_T("<a:path w=\"43200\" h=\"43200\" fill=\"none\">"));
m_oWriterVML.WriteString(str);
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
else if (bIsFill)
{
CString str = _T("");
str.Format(_T("<a:path w=\"43200\" h=\"43200\" stroke=\"0\">"));
m_oWriterVML.WriteString(str);
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandStart()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
Start();
}
else
{
m_pSimpleGraphicsConverter->PathCommandEnd();
m_pSimpleGraphicsConverter->PathCommandStart();
}
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandGetCurrentPoint(double* fX, double* fY)
{
m_pSimpleGraphicsConverter->PathCommandGetCurrentPoint(fX, fY);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
_SetFont();
m_pSimpleGraphicsConverter->PathCommandText(bsText, m_pFontManager, x, y, w, h, 0);
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
bool bGid = m_oFont.StringGID;
//TODOO
//if (NULL != bsGidText)
//{
// m_oFont.StringGID = true;
// PathCommandText(bsUnicodeText, x, y, w, h, baselineOffset);
//}
m_oFont.StringGID = false;
PathCommandText(bsUnicodeText, x, y, w, h);
m_oFont.StringGID = bGid;
return S_OK;
}
//-------- ---------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha)
{
return S_OK;
}
// transform --------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags)
{
if ((dWidth <= 1) || (dHeight <= 1))
lFlags = 0;
bool bFlipX = (0 != (c_nParamFlipX & lFlags));
bool bFlipY = (0 != (c_nParamFlipY & lFlags));
double m11 = bFlipX ? -1.0 : 1.0;
double m22 = bFlipY ? -1.0 : 1.0;
Aggplus::CMatrix oMatrix(1, 0, 0, 1, 0, 0);
if ((0 != dAngle) || (0 != lFlags))
{
double dCentreX = (dLeft + dWidth / 2.0);
double dCentreY = (dTop + dHeight / 2.0);
oMatrix.Translate(-dCentreX, -dCentreY , Aggplus::MatrixOrderAppend);
oMatrix.Rotate(dAngle , Aggplus::MatrixOrderAppend);
oMatrix.Scale(m11, m22 , Aggplus::MatrixOrderAppend);
oMatrix.Translate(dCentreX, dCentreY , Aggplus::MatrixOrderAppend);
}
m_oTransform = oMatrix;
CalculateFullTransform();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6)
{
Aggplus::CMatrix oTrans(m1, m2, m3, m4, m5, m6);
m_oTransform = oTrans;
CalculateFullTransform();
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::ResetTransform(void)
{
m_oTransform.Reset();
CalculateFullTransform();
return S_OK;
}
// -----------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::get_ClipMode(LONG* plMode)
{
*plMode = m_lClipMode;
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ClipMode(const LONG& lMode)
{
m_lClipMode = lMode;
return S_OK;
}
// additiaonal params ----------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetAdditionalParam(BSTR ParamName, VARIANT ParamValue)
{
return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::GetAdditionalParam(BSTR ParamName, VARIANT* ParamValue)
{
return S_OK;
}
// --------------------------------------------------------------------------------------------
ASCPresentationEditor/PPTXWriter/ShapeWriter.h deleted 100644 → 0
View file @ b8e32028
#pragma once
#include "../OfficeDrawing/Document.h"
#include "ImageManager.h"
namespace NSPresentationEditor
{
static inline LONG GetPPTXPlaceHolderType(const int & lType)
{
switch (lType)
{
case PT_None: break;
case PT_MasterTitle:
case PT_Title:
case PT_VerticalTitle:
return 15; // title
case PT_MasterBody:
case PT_Body:
case PT_MasterNotesBody:
case PT_VerticalBody:
case PT_NotesBody:
return 0; // body
case PT_MasterCenterTitle:
case PT_CenterTitle:
return 3; // ctrTitle
case PT_MasterSubTitle:
case PT_SubTitle:
return 13; // subtitle
case PT_Object:
case PT_VerticalObject:
return 9; // object
case PT_MasterNotesSlideImage:
case PT_NotesSlideImage:
return 11; // slideImg
case PT_Graph:
return 1; //chart
case PT_Table:
return 14; // table
case PT_ClipArt:
return 2; // clipArt
case PT_OrgChart:
return 1; // chart
case PT_Media:
return 8; // media
case PT_Picture:
return 10; // picture
case PT_MasterDate:
return 5; // date
case PT_MasterSlideNumber:
return 12; // sldNum
case PT_MasterFooter:
return 6; // footer
case PT_MasterHeader:
return 7; // header
default:
break;
}
return lType;
}
AVSINLINE std::wstring GetPhType(const int & lType)
{
int TypePPTX = GetPPTXPlaceHolderType(lType);
switch (TypePPTX)
{
case 0: return _T("body");
case 100: return _T("body"); // master pages
case 1: return _T("chart");
case 2: return _T("clipArt");
case 3: return _T("ctrTitle");
case 4: return _T("dgm");
case 5: return _T("dt");
case 6: return _T("ftr");
case 7: return _T("hdr");
case 8: return _T("media");
case 9: return _T("obj");
case 10: return _T("pic");
case 11: return _T("sldImg");
case 12: return _T("sldNum");
case 13: return _T("subTitle");
case 14: return _T("tbl");
case 15: return _T("title");
default: break;
}
return _T("body");
}
class CShapeWriter : public IRenderer
{
private:
NSPresentationEditor::CStringWriter m_oWriterPath;
NSPresentationEditor::CStringWriter m_oWriterVML;
NSPresentationEditor::CStringWriter m_oWriter;
NSPresentationEditor::CDoubleRect m_oBounds;
NSPresentationEditor::CDoubleRect m_oTextRect;
NSPresentationEditor::CMetricInfo m_oMetricInfo;
NSPresentationEditor::CShapeElement* m_pShapeElement;
NSPresentationEditor::CImageElement* m_pImageElement;
NSPresentationEditor::CRelsGenerator* m_pRels;
LONG m_lNextShapeID;
bool m_bWordArt;
bool m_bTextBox;
public:
CShapeWriter();
~CShapeWriter()
{
RELEASEOBJECT(m_pSimpleGraphicsConverter);
RELEASEOBJECT(m_pSimpleGraphicsConverter);
}
AVSINLINE void InitNextId()
{
m_lNextShapeID = 1000;
}
AVSINLINE void SetShape(CImageElement* pShapeElem)
{
m_pSimpleGraphicsConverter->PathCommandEnd();
m_pImageElement = pShapeElem;
m_pShapeElement = NULL;
m_oMetricInfo = m_pImageElement->m_oMetric;
m_oBounds = m_pImageElement->m_rcBounds;
m_oTextRect = m_oBounds;
m_bWordArt = false;
m_bTextBox = false;
m_oWriter.ClearNoAttack();
m_oWriterPath.ClearNoAttack();
m_oWriterVML.ClearNoAttack();
}
AVSINLINE void SetShape(CShapeElement* pShapeElem)
{
m_pSimpleGraphicsConverter->PathCommandEnd();
m_pShapeElement = pShapeElem;
m_pImageElement = NULL;
m_oMetricInfo = m_pShapeElement->m_oMetric;
m_oBounds = m_pShapeElement->m_rcBounds;
m_oTextRect = m_oBounds;
m_bWordArt = false;
m_bTextBox = false;
if (m_pShapeElement)
{
m_pShapeElement->m_oShape.GetTextRect(m_oTextRect);
}
m_oWriter.ClearNoAttack();
m_oWriterPath.ClearNoAttack();
m_oWriterVML.ClearNoAttack();
}
//--------------------------------------------------------------------
CString ConvertShape ();
CString ConvertImage ();
CString ConvertLine (CPen & pen);
CString ConvertShadow (CShadow & shadow);
CString ConvertBrush (CBrush & brush);
static CString ConvertColor (CColor & color, long alpha);
// -----------------------------------------------------------------------------
virtual HRESULT get_Type(LONG* lType) ;
//-------- --------------------------------------------------
virtual HRESULT NewPage() ;
virtual HRESULT get_Height(double* dHeight);
virtual HRESULT put_Height(const double& dHeight);
virtual HRESULT get_Width(double* dWidth);
virtual HRESULT put_Width(const double& dWidth) ;
virtual HRESULT get_DpiX(double* dDpiX) ;
virtual HRESULT get_DpiY(double* dDpiY) ;
// pen --------------------------------------------------------------------------------------
virtual HRESULT get_PenColor(LONG* lColor) ;
virtual HRESULT put_PenColor(const LONG& lColor);
virtual HRESULT get_PenAlpha(LONG* lAlpha) ;
virtual HRESULT put_PenAlpha(const LONG& lAlpha);
virtual HRESULT get_PenSize(double* dSize) ;
virtual HRESULT put_PenSize(const double& dSize);
virtual HRESULT get_PenDashStyle(BYTE* val) ;
virtual HRESULT put_PenDashStyle(const BYTE& val);
virtual HRESULT get_PenLineStartCap(BYTE* val) ;
virtual HRESULT put_PenLineStartCap(const BYTE& val) ;
virtual HRESULT get_PenLineEndCap(BYTE* val) ;
virtual HRESULT put_PenLineEndCap(const BYTE& val);
virtual HRESULT get_PenLineJoin(BYTE* val) ;
virtual HRESULT put_PenLineJoin(const BYTE& val);
virtual HRESULT get_PenDashOffset(double* dOffset);
virtual HRESULT put_PenDashOffset(const double& dOffset);
virtual HRESULT get_PenAlign(LONG* lAlign) ;
virtual HRESULT put_PenAlign(const LONG& lAlign);
virtual HRESULT get_PenMiterLimit(double* dOffset);
virtual HRESULT put_PenMiterLimit(const double& dOffset);
virtual HRESULT PenDashPattern(double* pPattern, LONG lCount);
// brush ------------------------------------------------------------------------------------
virtual HRESULT get_BrushType(LONG* lType) ;
virtual HRESULT put_BrushType(const LONG& lType) ;
virtual HRESULT get_BrushColor1(LONG* lColor) ;
virtual HRESULT put_BrushColor1(const LONG& lColor) ;
virtual HRESULT get_BrushAlpha1(LONG* lAlpha) ;
virtual HRESULT put_BrushAlpha1(const LONG& lAlpha) ;
virtual HRESULT get_BrushColor2(LONG* lColor) ;
virtual HRESULT put_BrushColor2(const LONG& lColor) ;
virtual HRESULT get_BrushAlpha2(LONG* lAlpha) ;
virtual HRESULT put_BrushAlpha2(const LONG& lAlpha) ;
virtual HRESULT get_BrushTexturePath(std::wstring* bsPath);
virtual HRESULT put_BrushTexturePath(const std::wstring& bsPath);
virtual HRESULT get_BrushTextureMode(LONG* lMode) ;
virtual HRESULT put_BrushTextureMode(const LONG& lMode) ;
virtual HRESULT get_BrushTextureAlpha(LONG* lTxAlpha) ;
virtual HRESULT put_BrushTextureAlpha(const LONG& lTxAlpha);
virtual HRESULT get_BrushLinearAngle(double* dAngle) ;
virtual HRESULT put_BrushLinearAngle(const double& dAngle);
virtual HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height);
virtual HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height);
virtual HRESULT put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount);
// font -------------------------------------------------------------------------------------
virtual HRESULT get_FontName(std::wstring* bsName);
virtual HRESULT put_FontName(const std::wstring& bsName);
virtual HRESULT get_FontPath(std::wstring* bsName);
virtual HRESULT put_FontPath(const std::wstring& bsName);
virtual HRESULT get_FontSize(double* dSize) ;
virtual HRESULT put_FontSize(const double& dSize);
virtual HRESULT get_FontStyle(LONG* lStyle) ;
virtual HRESULT put_FontStyle(const LONG& lStyle);
virtual HRESULT get_FontStringGID(INT* bGID) ;
virtual HRESULT put_FontStringGID(const INT& bGID);
virtual HRESULT get_FontCharSpace(double* dSpace);
virtual HRESULT put_FontCharSpace(const double& dSpace) ;
virtual HRESULT get_FontFaceIndex(int* lFaceIndex);
virtual HRESULT put_FontFaceIndex(const int& lFaceIndex);
//-------- --------------------------------------------------------
virtual HRESULT CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h) ;
virtual HRESULT CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h) ;
virtual HRESULT CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h) ;
virtual HRESULT CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h);
//-------- ---------------------------------------------------------------
virtual HRESULT BeginCommand(const DWORD& lType);
virtual HRESULT EndCommand(const DWORD& lType) ;
//-------- Graphics Path -----------------------------------------------
virtual HRESULT PathCommandMoveTo(const double& x, const double& y);
virtual HRESULT PathCommandLineTo(const double& x, const double& y);
virtual HRESULT PathCommandLinesTo(double* points, const int& count) ;
virtual HRESULT PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3) ;
virtual HRESULT PathCommandCurvesTo(double* points, const int& count) ;
virtual HRESULT PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle);
virtual HRESULT PathCommandClose() ;
virtual HRESULT PathCommandEnd() ;
virtual HRESULT DrawPath(const LONG& nType) ;
virtual HRESULT PathCommandStart() ;
virtual HRESULT PathCommandGetCurrentPoint(double* x, double* y);
virtual HRESULT PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h) ;
virtual HRESULT PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h);
virtual HRESULT PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h);
virtual HRESULT PathCommandTextEx(const std::wstring& sText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h) ;
//-------- ---------------------------------------------------
virtual HRESULT DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h) ;
virtual HRESULT DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha = 255);
// transform --------------------------------------------------------------------------------
virtual HRESULT GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags);
virtual HRESULT SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags);
virtual HRESULT SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6);
virtual HRESULT GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF);
virtual HRESULT ResetTransform();
// -----------------------------------------------------------------------------------------
virtual HRESULT get_ClipMode(LONG* plMode);
virtual HRESULT put_ClipMode(const LONG& lMode) ;
// additiaonal params ----------------------------------------------------------------------
virtual HRESULT CommandLong(const LONG& lType, const LONG& lCommand);
virtual HRESULT CommandDouble(const LONG& lType, const double& dCommand) ;
virtual HRESULT CommandString(const LONG& lType, const std::wstring& sCommand);
//////////////////////////////////////////////////////////////////////////////////////////////////
// shadow -----------------------------------------------------------------------------------
HRESULT SetShadow (BSTR bsXML);
HRESULT get_ShadowDistanceX (double* val);
HRESULT put_ShadowDistanceX (double val);
HRESULT get_ShadowDistanceY (double* val);
HRESULT put_ShadowDistanceY (double val);
HRESULT get_ShadowBlurSize (double* val);
HRESULT put_ShadowBlurSize (double val);
HRESULT get_ShadowColor (LONG* val);
HRESULT put_ShadowColor (LONG val);
HRESULT get_ShadowAlpha (LONG* val);
HRESULT put_ShadowAlpha (LONG val);
HRESULT get_ShadowVisible (bool* val);
HRESULT put_ShadowVisible (bool val);
// edge -------------------------------------------------------------------------------------
HRESULT SetEdgeText (BSTR bsXML);
HRESULT get_EdgeVisible (LONG* val);
HRESULT put_EdgeVisible (LONG val);
HRESULT get_EdgeColor (LONG* val);
HRESULT put_EdgeColor (LONG val);
HRESULT get_EdgeAlpha (LONG* val);
HRESULT put_EdgeAlpha (LONG val);
HRESULT get_EdgeDist (double* val);
HRESULT put_EdgeDist (double val);
HRESULT SetFont(BSTR bsXML);
HRESULT SetPen(BSTR bsXML);
HRESULT SetBrush(BSTR bsXML);
// additiaonal params ----------------------------------------------------------------------
HRESULT SetAdditionalParam (BSTR ParamName, VARIANT ParamValue);
HRESULT GetAdditionalParam (BSTR ParamName, VARIANT* ParamValue);
public:
void SetRelsGenerator(CRelsGenerator* pGenerator)
{
m_pRels = pGenerator;
}
protected:
void CalculateFullTransform()
{
m_oFullTransform = m_oBaseTransform;
m_oFullTransform.Multiply(&m_oTransform, Aggplus::MatrixOrderPrepend);
m_dTransformAngle = m_oTransform.z_Rotation();
}
void _SetFont()
{
if (NULL == m_pFontManager)
{
m_pFontManager = new CFontManager();
m_pFontManager->Initialize();
}
m_pFontManager->SetStringGID(m_oFont.StringGID);
if (_T("") == m_oFont.Path)
{
m_pFontManager->LoadFontByName(m_oFont.Name, (float)m_oFont.Size, m_oFont.GetStyle(), m_dDpiX, m_dDpiY);
}
else
{
m_pFontManager->LoadFontFromFile(m_oFont.Path, (float)m_oFont.Size, m_dDpiX, m_dDpiY, 0);
}
m_oInstalledFont = m_oFont;
}
public:
Aggplus::CGraphicsPathSimpleConverter* m_pSimpleGraphicsConverter; //
CFontManager* m_pFontManager; //
Aggplus::CMatrix m_oBaseTransform; // (: -> )
Aggplus::CMatrix m_oTransform; //
Aggplus::CMatrix m_oFullTransform; // (m_oBaseTransform * m_oTransform)
double m_dTransformAngle;
LONG m_lCurrentCommandType; //
double m_dDpiX;
double m_dDpiY;
LONG m_lClipMode;
CPen m_oPen; // ( AVSGraphics)
CBrush m_oBrush;
CFont m_oFont;
CShadow m_oShadow;
CEdgeText m_oEdge;
CFont m_oInstalledFont;
double m_dWidth;
double m_dHeight;
public:
inline void MoveTo(const double& dX, const double& dY)
{
double x = dX;
double y = dY;
m_oFullTransform.TransformPoint(x, y);
CString str = _T("");
str.Format(_T("<a:moveTo><a:pt x=\"%d\" y=\"%d\"/></a:moveTo>"), (LONG)x, (LONG)y);
m_oWriterPath.WriteString(str);
}
inline void LineTo(const double& dX, const double& dY)
{
double x = dX;
double y = dY;
m_oFullTransform.TransformPoint(x, y);
CString str = _T("");
str.Format(_T("<a:lnTo><a:pt x=\"%d\" y=\"%d\"/></a:lnTo>"), (LONG)x, (LONG)y);
m_oWriterPath.WriteString(str);
}
inline void CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
{
double _x1 = x1;
double _y1 = y1;
m_oFullTransform.TransformPoint(_x1, _y1);
double _x2 = x2;
double _y2 = y2;
m_oFullTransform.TransformPoint(_x2, _y2);
double _x3 = x3;
double _y3 = y3;
m_oFullTransform.TransformPoint(_x3, _y3);
CString str = _T("");
str.Format(_T("<a:cubicBezTo><a:pt x=\"%d\" y=\"%d\"/><a:pt x=\"%d\" y=\"%d\"/><a:pt x=\"%d\" y=\"%d\"/></a:cubicBezTo>"),
(LONG)_x1, (LONG)_y1, (LONG)_x2, (LONG)_y2, (LONG)_x3, (LONG)_y3);
m_oWriterPath.WriteString(str);
}
void Start()
{
m_oWriterPath.ClearNoAttack();
}
void End()
{
m_oWriterPath.ClearNoAttack();
}
void Close()
{
CString str = _T("<a:close/>");
m_oWriterPath.WriteString(str);
}
void WriteShapeInfo();
void WriteImageInfo();
void WriteTextInfo();
};
}
ASCPresentationEditor/PPTXWriter/StylesWriter.h deleted 100644 → 0
View file @ b8e32028
#pragma once
//#include "CSS.h"
class CStylesWriter
{
public:
AVSINLINE static CString GetTextAnchor(const WORD& value)
{
if (0 == value)
return _T("t");
if (1 == value)
return _T("ctr");
if (2 == value)
return _T("b");
return _T("t");
}
AVSINLINE static CString GetTextAlign(const WORD& value)
{
if (0 == value)
return _T("l");
if (1 == value)
return _T("ctr");
if (2 == value)
return _T("r");
if (3 == value)
return _T("just");
if (4 == value)
return _T("dist");
if (5 == value)
return _T("thaiDist");
if (6 == value)
return _T("justLow");
return _T("l");
}
//oArrayMem.push_back(oScheme[0]);//0
//oArrayMem.push_back(oScheme[1]);//1
//oArrayMem.push_back(oScheme[2]);//2
//oArrayMem.push_back(oScheme[3]);//3
//oArrayMem.push_back(oScheme[0]);//4
//oArrayMem.push_back(oScheme[4]);//5 //accent1
//oArrayMem.push_back(oScheme[5]);//6 //accent2
//oArrayMem.push_back(oScheme[0]);//7 //accent3
//oArrayMem.push_back(oScheme[5]);//8 //accent4
//oArrayMem.push_back(oScheme[4]);//9 //accent5
//oArrayMem.push_back(oScheme[7]);//10 //accent6
//oArrayMem.push_back(oScheme[6]);//11 //hlink
//oArrayMem.push_back(oScheme[7]);//12 //folHlink
//oArrayMem.push_back(oScheme[0]);//13 //lt1
//oArrayMem.push_back(oScheme[1]);//14 //dk1
//oArrayMem.push_back(oScheme[2]);//15 //lt2
//oArrayMem.push_back(oScheme[3]);//16 //dk2
AVSINLINE static CString GetColorInScheme(const LONG& lIndex)
{
switch (lIndex)
{
case 0: return _T("phClr");
case 1: return _T("bg1");
case 2: return _T("tx1");
case 3: return _T("bg2");
case 4: return _T("tx2");
case 5: return _T("accent1");
case 6: return _T("accent2");
case 7: return _T("accent3");
case 8: return _T("accent4");
case 9: return _T("accent5");
case 10: return _T("accent6");
case 11: return _T("hlink");
case 12: return _T("folHlink");
case 13: return _T("lt1");
case 14: return _T("dk1");
case 15: return _T("lt2");
case 16: return _T("dk2");
break;
};
return _T("none");
}
AVSINLINE static CString GetFontAlign(const WORD& value)
{
if (0 == value)
return _T("base");
if (1 == value)
return _T("t");
if (2 == value)
return _T("ctr");
if (3 == value)
return _T("b");
return _T("auto");
}
static CString ConvertStyles(NSPresentationEditor::CTextStyles& oStyles, NSPresentationEditor::CMetricInfo& oMetricInfo, int nCount = 10)
{
NSPresentationEditor::CStringWriter oWriter;
ConvertStyles(oStyles, oMetricInfo, oWriter, nCount);
return oWriter.GetData();
}
static void ConvertStyles(NSPresentationEditor::CTextStyles& oStyles, NSPresentationEditor::CMetricInfo& oMetricInfo,
NSPresentationEditor::CStringWriter& oWriter, int nCount = 10)
{
for (int i = 0; i < nCount; ++i)
{
if (oStyles.m_pLevels[i].is_init())
ConvertStyleLevel(oStyles.m_pLevels[i].get(), oMetricInfo, oWriter, i);
}
}
static CString ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLevel, NSPresentationEditor::CMetricInfo& oMetricInfo, const int& nLevel)
{
NSPresentationEditor::CStringWriter oWriter;
ConvertStyleLevel(oLevel, oMetricInfo, oWriter, nLevel);
return oWriter.GetData();
}
static void ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLevel, NSPresentationEditor::CMetricInfo& oMetricInfo,
NSPresentationEditor::CStringWriter& oWriter, const int& nLevel);
};
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7