void CEnvelopeWizard::AddDroppedGraphic(int nDragImage, POINT point)
{
if (!m_pEnvelopeDoc)
return;
CAGPage* pPage = m_pEnvelopeDoc->GetPage(0);
if (!pPage)
return;
CAGLayer* pUserLayer = pPage->GetUserLayer();
if (!pUserLayer)
return;
CAGSymImage* pImage = m_pGraphics[nDragImage];
if (!pImage)
return;
CAGSymImage* pNewImage = (CAGSymImage*)pImage->Duplicate();
if (!pNewImage)
return;
SetImageSize(pNewImage, &point);
pUserLayer->AddSymbol(pNewImage);
GetDocWin()->SymbolUnselect(true);
GetDocWin()->SymbolSelect(pNewImage);
GetDocWin()->SymbolInvalidate(pNewImage);
}
//--------------------------------------------------------------------------//
//--------------------------------------------------------------------------//
bool CAGDoc::Read(istream &input)
{
bool bReturn = true;
Free();
CAGDocIO DocIO(&input);
AGHDR Hdr;
DocIO.Read(&Hdr, sizeof(Hdr));
if (memcmp(Hdr.abId, AGDOC_ID, sizeof(Hdr.abId)) == 0 &&
Hdr.bVer <= AGDOC_VERSION)
{
DocIO.Read(&m_AGDocType, sizeof(m_AGDocType));
DocIO.Read(&m_nPages, sizeof(m_nPages));
for (int i = 0; i < m_nPages; i++)
{
CAGPage *pPage = new CAGPage();
pPage->Read(&DocIO);
m_pPages[i] = pPage;
}
if (m_nPages > 1)
m_nCurPage = 1;
}
else
bReturn = false;
DocIO.Close();
return bReturn;
}
//--------------------------------------------------------------------------//
//--------------------------------------------------------------------------//
void CCtlPanel::SetDoc(CAGDoc *pAGDoc)
{
m_pAGDoc = pAGDoc;
AGDOCTYPE DocType = m_pAGDoc->GetDocType();
bool bCardType = (DocType == DOC_CARD_SINGLEFOLD_PORTRAIT || DocType == DOC_CARD_SINGLEFOLD_LANDSCAPE ||
DocType == DOC_CARD_QUARTERFOLD_PORTRAIT || DocType == DOC_CARD_QUARTERFOLD_LANDSCAPE);
int nPages = m_pAGDoc->GetNumPages();
for (int nPage = 1, nMap = 0; nPage <= nPages; nPage++)
{
CAGPage *pPage = m_pAGDoc->GetPage(nPage);
if ((! pPage->IsEmpty()) || (bCardType && nPage == 4))
{
const char *pszPageName = pPage->GetPageName();
SetDlgItemText(IDC_PAGE1 + nMap, pszPageName);
::ShowWindow(GetDlgItem(IDC_PAGE1 + nMap), SW_SHOW);
m_PageMap[nMap++] = nPage;
}
}
while (nMap < 4)
{
::ShowWindow(GetDlgItem(IDC_PAGE1 + nMap), SW_HIDE);
m_PageMap[nMap++] = 0;
}
}
void CEnvelopeWizard::SetPageSize()
{
if (!m_pEnvelopeDoc)
return;
CAGPage* pPage = m_pEnvelopeDoc->GetCurrentPage();
if (!pPage)
return;
pPage->SetPageSize(m_PageSize);
GetDocWin()->ActivateNewPage();
}
void CEnvelopeWizard::InitGraphics(CAGDoc* pPrevDoc)
{
for (int nIndex = 0; nIndex < MAX_NUM_PICTURES; nIndex++)
m_pGraphics[nIndex] = NULL;
if (!pPrevDoc)
return;
int nGraphicItem = 0;
for (int nIndex = 0; nIndex < MAX_PAGES_TO_CHECK; nIndex++)
{
CAGPage* pPage = pPrevDoc->GetPage(nIndex);
if (!pPage)
continue;
int nLayers = pPage->GetNumLayers();
for (int l = 0; l < nLayers; l++)
{
CAGLayer* pLayer = pPage->GetLayer(l);
if (!pLayer)
continue;
int nSymbols = pLayer->GetNumSymbols();
for (int i = 0; i < nSymbols; i++)
{
CAGSym* pSym = (CAGSym*)pLayer->GetSymbol(i);
if (!pSym)
continue;
if (!pSym->IsImage())
continue;
CAGSymImage* pImage = (CAGSymImage*)pSym;
if (pImage->IsLocked() || pImage->IsDeleted())
continue;
CAGSymImage* pNewImage = (CAGSymImage*)pImage->Duplicate();
if (!pNewImage)
return;
// Add a copy of the image symbol to the list
// Be sure to set its location to (0,0) to make it easier to add to the envelope
CRect DestRect = pNewImage->GetDestRectTransformed();
DestRect.MoveToXY(0,0);
pNewImage->SetDestRect(DestRect);
pNewImage->SetMatrix(CAGMatrix());
pNewImage->SetHidden(false);
m_pGraphics[nGraphicItem] = pNewImage;
nGraphicItem++;
}
}
}
}
//--------------------------------------------------------------------------//
//--------------------------------------------------------------------------//
bool CAGDoc::Write(ostream &output)
{
bool bReturn = true;
CAGDocIO DocIO(&output);
AGHDR Hdr;
memcpy(Hdr.abId, AGDOC_ID, sizeof(Hdr.abId));
Hdr.bVer = AGDOC_VERSION;
DocIO.Write(&Hdr, sizeof(Hdr));
DocIO.Write(&m_AGDocType, sizeof(m_AGDocType));
DocIO.Write(&m_nPages, sizeof(m_nPages));
for (int i = 0; i < m_nPages; i++)
{
CAGPage *pPage = m_pPages[i];
pPage->Write(&DocIO);
}
DocIO.Close();
return bReturn;
}
void CEnvelopeWizard::CreateEnvelope(CAGDoc** ppAGDoc)
{
m_pEnvelopeDoc = new CAGDoc();
// Let the caller take control over this document
if (ppAGDoc)
*ppAGDoc = m_pEnvelopeDoc;
if (!m_pEnvelopeDoc)
return;
m_pEnvelopeDoc->SetPortrait(m_PageSize.cx <= m_PageSize.cy);
m_pEnvelopeDoc->SetDocType(DOC_ENVELOPE);
m_pEnvelopeDoc->SetFileName(CString("Untitled"));
m_pEnvelopeDoc->SetModified(true);
CAGPage* pPage = new CAGPage(m_PageSize.cx, m_PageSize.cy);
if (!pPage)
return;
m_pEnvelopeDoc->AddPage(pPage);
int nLayers = 2;
for (int j = 0; j < nLayers; j++)
pPage->AddLayer(new CAGLayer());
CAGLayer* pUserLayer = pPage->GetUserLayer();
if (!pUserLayer)
return;
CAGLayer* pMasterLayer = pPage->GetMasterLayer();
if (!pUserLayer)
return;
m_nMaxImageSize = m_PageSize.cy / 2;
m_pEnvelopePicture->GetPictureList()->DrawListViewThumbnails();
// Add the Background Item
CAGSymGraphic* pBackground = new CAGSymRectangle();
if (pBackground)
{
RECT BackgroundRect;
::SetRect(&BackgroundRect, 0, 0, m_PageSize.cx, m_PageSize.cy);
pBackground->SetDestRect(BackgroundRect);
pBackground->SetID(IDR_ENVELOPE_BACKGROUND);
pBackground->SetFillColor(RGB(240,240,255));
pBackground->SetFillColor2(RGB(255,255,255));
pBackground->SetFillType(FT_Solid);
pBackground->SetHidden(true);
pUserLayer->AddSymbol(pBackground);
}
int xCenter = m_PageSize.cx / 2;
int yCenter = m_PageSize.cy / 2;
RECT rMargins = { INCHES(0.375), INCHES(0.375), m_PageSize.cx - INCHES(0.375), m_PageSize.cy - INCHES(0.375)};
// Add the Send Address Text Item
CAGSymText* pSendAddr = new CAGSymText(ST_TEXT);
if (pSendAddr)
{
RECT SendRect;
SendRect.left = xCenter - (INCHES(1.75)/2);
SendRect.top = yCenter - (INCHES(1)/2);
SendRect.right = SendRect.left + INCHES(3.0);
SendRect.bottom = SendRect.top + INCHES(1.1);
pSendAddr->Create(SendRect);
pSendAddr->SetID(IDR_ENVELOPE_SEND);
SetAddressText(pSendAddr, m_strSendAddress);
pSendAddr->SelectAll(false);
pSendAddr->SetHorzJust(eFlushLeft);
pSendAddr->SetVertJust(eVertTop);
pSendAddr->SetEmphasis(false, false, false);
pUserLayer->AddSymbol(pSendAddr);
}
// Add the Return Address Text Item
CAGSymText* pReturnAddr = new CAGSymText(ST_TEXT);
if (pReturnAddr)
{
RECT ReturnRect;
ReturnRect.left = rMargins.left;
ReturnRect.top = rMargins.top;
ReturnRect.right = ReturnRect.left + INCHES(3.0);
ReturnRect.bottom = ReturnRect.top + INCHES(1.1);
pReturnAddr->Create(ReturnRect);
pReturnAddr->SetID(IDR_ENVELOPE_RETURN);
SetAddressText(pReturnAddr, m_strReturnAddress);
pReturnAddr->SelectAll(false);
pReturnAddr->SetHorzJust(eFlushLeft);
pReturnAddr->SetVertJust(eVertTop);
pReturnAddr->SetEmphasis(false, false, false);
pUserLayer->AddSymbol(pReturnAddr);
}
// Add the first image to the document
CAGSymImage* pImage = m_pGraphics[0];
if (!pImage)
return;
CAGSymImage* pNewImage = (CAGSymImage*)pImage->Duplicate();
if (!pNewImage)
return;
SetImageSize(pNewImage);
pNewImage->SetID(IDC_ENVELOPE_PIC_0);
pUserLayer->AddSymbol(pNewImage);
GetDocWin()->SymbolUnselect(true);
GetDocWin()->SymbolSelect(pNewImage);
GetDocWin()->Position(POS_LEFT, POS_BOTTOM, 0/*id*/);
}
int CXMLDlg::CreatePages(HTREEITEM pItem)
{
HTREEITEM pChildItem = m_treeOutput.GetChildItem(pItem);
if (!pChildItem)
{
ASSERT(false);
return 0;
}
int nPages = 0;
while (pChildItem)
{
CString szItemType = m_treeOutput.GetItemText(pChildItem);
if (!szItemType.CompareNoCase(_T("page")) )
{
POINT Size = {0,0};
GetCurrentObjectSize(pChildItem, Size);
int iPageWidth = Size.x;
int iPageHeight = Size.y;
AGDOCTYPE Type = m_pAGDoc->GetDocType();
POINT ptSplitOffset = {0,0};
int iPagesToMake = 1;
if ((Type == DOC_QUARTERCARD || Type == DOC_HALFCARD || Type == DOC_NOTECARD) && nPages == 1)
iPagesToMake = 2;
else
if (Type == DOC_CALENDAR && (iPageWidth > 11*1800 || iPageHeight > 11*1800))
iPagesToMake = 2;
if (iPagesToMake > 1)
{ // Split the larger dimension
if (iPageWidth > iPageHeight)
{
iPageWidth /= iPagesToMake;
ptSplitOffset.x = iPageWidth;
}
else
{
iPageHeight /= iPagesToMake;
ptSplitOffset.y = iPageHeight;
}
}
for (int i=0; i<iPagesToMake; i++)
{
if (Type == DOC_CALENDAR && iPagesToMake > 1)
{
// Special case to skip the top part of a calendar cover
if (nPages == 0 && i == 0)
continue;
// Special case to skip the bottom part of a calendar back
if (nPages == 13 && i == 1)
continue;
}
CAGPage* pPage = new CAGPage(iPageWidth, iPageHeight);
if (!pPage)
{
ASSERT(false);
return nPages;
}
m_pAGDoc->AddPage(pPage);
CString strPageName = GetPageName(nPages);
pPage->SetPageName(strPageName);
for (int j = 0; j < NLAYERS; j++)
pPage->AddLayer(new CAGLayer());
POINT ptOffset = {0,0};
if (i > 0)
ptOffset = ptSplitOffset;
HandlePageItems(pChildItem, pPage, ptOffset);
nPages++;
}
}
pChildItem = m_treeOutput.GetNextItem(pChildItem, TVGN_NEXT);
}
return nPages;
}
bool CPageNavigator::SelectPage(int nPage, bool bSetState)
{
if (!m_hWnd || !m_pAGDoc)
return false;
int nPages = m_pAGDoc->GetNumPages();
if (nPage < 0 || nPage >= nPages)
return false;
if (m_nPage == nPage)
return false;
// Reset the image of the old selected page
if (m_nPage >= 0)
{
LV_ITEM lvItem;
::ZeroMemory(&lvItem, sizeof(lvItem));
lvItem.mask = LVIF_IMAGE;
lvItem.iItem = m_nPage;
GetItem(&lvItem);
if (lvItem.iImage >= nPages)
{
lvItem.mask = LVIF_IMAGE;
lvItem.iImage -= nPages;
SetItem(&lvItem);
}
}
m_nPage = nPage;
// Set the image of the newly selected page
if (m_nPage >= 0)
{
LV_ITEM lvItem;
::ZeroMemory(&lvItem, sizeof(lvItem));
lvItem.mask = LVIF_IMAGE;
lvItem.iItem = m_nPage;
GetItem(&lvItem);
if (lvItem.iImage < nPages)
{
lvItem.mask = LVIF_IMAGE;
lvItem.iImage += nPages;
SetItem(&lvItem);
}
}
// Set the page name into the static label control
CString strPageName;
CAGPage* pPage = m_pAGDoc->GetPage(m_nPage);
if (pPage)
pPage->GetPageName(strPageName);
if (::IsWindow(m_LabelPage.m_hWnd))
m_LabelPage.SetText(strPageName);
// Scroll the page into position, if necessary
EnsureIconVisible(m_nPage);
// Select the list control item
if (bSetState)
SetItemState(m_nPage, LVIS_SELECTED, LVIS_SELECTED|LVIS_FOCUSED);
// Show or hide the next/prev buttons as necessary
bool bNormalCard = m_bIsCard && (nPages <= 4);
int nCmdShowPrev = (bNormalCard ? SW_HIDE : (nPage <= 0 ? SW_HIDE : SW_SHOW));
int nCmdShowNext = (bNormalCard ? SW_HIDE : (nPage >= nPages - 1 ? SW_HIDE : SW_SHOW));
::ShowWindow(m_hWndPrevButton, nCmdShowPrev);
::ShowWindow(m_hWndNextButton, nCmdShowNext);
return true;
}
//--------------------------------------------------------------------------//
// Print single-fold card. //
//--------------------------------------------------------------------------//
bool CAGDoc::PrintCardSingle(PRINTSIDE PrintSide, char *pszDriver,
char *pszDevice, char *pszOutput,
DEVMODE *pDevMode, bool &bRotated,
const char *pszFileName)
{
if (m_nPages != 4)
return (false);
bool bPortrait = (m_AGDocType == DOC_CARDHH || m_AGDocType == DOC_CARDFH);
if (pDevMode)
{
if (bPortrait)
pDevMode->dmOrientation = DMORIENT_PORTRAIT;
else
pDevMode->dmOrientation = DMORIENT_LANDSCAPE;
pDevMode->dmFields |= DM_ORIENTATION;
}
CAGDC *pDC = new CAGDC(pszDriver, pszDevice, pszOutput, pDevMode);
CAGDCInfo di = pDC->GetDeviceInfo();
if (pDevMode && pDevMode->dmOrientation == DMORIENT_PORTRAIT &&
di.m_nHorzSize > di.m_nVertSize)
{
delete pDC;
pDevMode->dmOrientation = DMORIENT_LANDSCAPE;
pDC = new CAGDC(pszDriver, pszDevice, pszOutput, pDevMode);
di = pDC->GetDeviceInfo();
}
else if (pDevMode && pDevMode->dmOrientation == DMORIENT_LANDSCAPE &&
di.m_nVertSize > di.m_nHorzSize)
{
delete pDC;
pDevMode->dmOrientation = DMORIENT_PORTRAIT;
pDC = new CAGDC(pszDriver, pszDevice, pszOutput, pDevMode);
di = pDC->GetDeviceInfo();
}
RECT DestRect;
RECT SrcRect;
SIZE sizePage;
CAGMatrix ViewMatrix;
bool bFlip;
if (! pDC->StartDoc("Create and Print"))
{
delete pDC;
return (false);
}
if (PrintSide == PRINT_OUTSIDE || PrintSide == PRINT_BOTH)
{
if (! pDC->StartPage())
{
pDC->AbortDoc();
delete pDC;
return (false);
}
//------------------------------------------------------------------//
// Front //
//------------------------------------------------------------------//
CAGPage *pPage = GetPage(1);
pPage->GetPageSize(&sizePage);
::SetRect(&SrcRect, 0, 0, sizePage.cx, sizePage.cy);
GetSFPageRect(1, bPortrait, false, pDC, di, DestRect, bFlip, bRotated);
ViewMatrix.ScaleAndCenter(DestRect, SrcRect, bFlip);
pDC->SetViewingMatrix(ViewMatrix);
pPage->Draw(*pDC);
//------------------------------------------------------------------//
// Back //
//------------------------------------------------------------------//
pPage = GetPage(4);
pPage->GetPageSize(&sizePage);
::SetRect(&SrcRect, 0, 0, sizePage.cx, sizePage.cy);
GetSFPageRect(4, bPortrait, false, pDC, di, DestRect, bFlip, bRotated);
ViewMatrix.ScaleAndCenter(DestRect, SrcRect, bFlip);
pDC->SetViewingMatrix(ViewMatrix);
pPage->Draw(*pDC);
//------------------------------------------------------------------//
// BatchPrint filename. //
//------------------------------------------------------------------//
if (pszFileName)
{
LOGFONT Font;
memset(&Font, 0, sizeof(Font));
Font.lfHeight = -(12 * APP_RESOLUTION / 72);
lstrcpy(Font.lfFaceName, "Times New Roman");
pDC->SetFont(&Font);
pDC->SetTextColor(RGB (0, 0, 0));
pDC->ExtTextOut(APP_RESOLUTION / 8,
SrcRect.bottom - (APP_RESOLUTION / 8), 0, NULL, pszFileName,
lstrlen(pszFileName), NULL);
}
if (! pDC->EndPage())
{
pDC->AbortDoc();
delete pDC;
return (false);
}
}
if (PrintSide == PRINT_INSIDE || PrintSide == PRINT_BOTH)
{
if (! pDC->StartPage())
{
pDC->AbortDoc();
delete pDC;
return (false);
}
bool bPage2Empty = GetPage(2)->IsEmpty();
bool bPage3Empty = GetPage(3)->IsEmpty();
//------------------------------------------------------------------//
// Inside Left / Top //
//------------------------------------------------------------------//
CAGPage *pPage = GetPage(2);
pPage->GetPageSize(&sizePage);
::SetRect(&SrcRect, 0, 0, sizePage.cx, sizePage.cy);
GetSFPageRect(2, bPortrait, ! bPage3Empty, pDC, di, DestRect, bFlip,
bRotated);
ViewMatrix.ScaleAndCenter(DestRect, SrcRect, bFlip);
pDC->SetViewingMatrix(ViewMatrix);
pPage->Draw(*pDC);
//------------------------------------------------------------------//
// BatchPrint filename. //
//------------------------------------------------------------------//
if (pszFileName)
{
LOGFONT Font;
memset(&Font, 0, sizeof(Font));
Font.lfHeight = -(12 * APP_RESOLUTION / 72);
lstrcpy(Font.lfFaceName, "Times New Roman");
pDC->SetFont(&Font);
pDC->SetTextColor(RGB(0, 0, 0));
pDC->ExtTextOut(APP_RESOLUTION / 8,
SrcRect.bottom - (APP_RESOLUTION / 8), 0, NULL, pszFileName,
lstrlen(pszFileName), NULL);
}
//------------------------------------------------------------------//
// Inside Right / Bottom //
//------------------------------------------------------------------//
pPage = GetPage(3);
pPage->GetPageSize(&sizePage);
::SetRect(&SrcRect, 0, 0, sizePage.cx, sizePage.cy);
GetSFPageRect(3, bPortrait, ! bPage2Empty, pDC, di, DestRect, bFlip,
bRotated);
ViewMatrix.ScaleAndCenter(DestRect, SrcRect, bFlip);
pDC->SetViewingMatrix(ViewMatrix);
pPage->Draw(*pDC);
if (! pDC->EndPage())
{
pDC->AbortDoc();
delete pDC;
return (false);
}
}
if (! pDC->EndDoc())
{
pDC->AbortDoc();
delete pDC;
return (false);
}
delete pDC;
return (true);
}
bool CFYSPrintDoc::CreateXmlDoc(CString& strOrderId, CString& strCorrId, CString& strFYSInfo, bool bUnpackFiles)
{
if (!m_pAGDoc)
return false;
CWaitCursor Wait;
Initialize();
if (!CreateDirAndSubDirs())
return false;
// Documents element
CString strDocFileName;
{
// strip the last "\"
int nLen = m_strFYSTempPath.GetLength();
CString strTempPath = m_strFYSTempPath.Left(nLen-1);
strDocFileName = TempFileName(strTempPath, "4YS", "txt");
strDocFileName = m_strFYSTempPath + strDocFileName;
FILE* docout = NULL;
errno_t err = fopen_s(&docout, strDocFileName, "wb");
if (!docout || err != 0)
{
SetError(String("Failed to open %s", strDocFileName));
return false;
}
SIZE PageSize = {0,0};
m_pAGDoc->GetPageSize(PageSize);
double dx = DINCHES(PageSize.cx);
double dy = DINCHES(PageSize.cy);
fprintf(docout, " <Documents Count='1'>\r\n");
fprintf(docout, " <Document CLT_CorrelationID='%s' FYS_CorrelationID='%s'>\r\n", strOrderId, strCorrId);
fprintf(docout, " <GreetingCard PageWidth='%0.5G' PageHeight='%0.5G' />\r\n", dx, dy);
int nPages = m_pAGDoc->GetNumPages();
for (int nPage = 0; nPage < nPages; nPage++)
{
CAGPage* pPage = m_pAGDoc->GetPage(nPage);
if (!pPage)
continue;
if (!PageHasSymbols(pPage))
continue;
fprintf(docout, "\t\t\t<Page PageNumber='%d'>\r\n", nPage+1);
int nLayers = pPage->GetNumLayers();
for (int nLayer = 0; nLayer < nLayers; nLayer++)
{
CAGLayer* pLayer = pPage->GetLayer(nLayer);
if (!pLayer)
continue;
int nSymbols = pLayer->GetNumSymbols();
for (int nSymbol = nSymbols - 1; nSymbol >= 0; nSymbol--)
{
bool bRetVal = true;
CAGSym* pSym = pLayer->GetSymbol(nSymbol);
if (!pSym || pSym->IsHidden())
continue;
pSym->RegisterFileSpecsCallback(fnFileSpecs, (LPARAM)this);
int idSym = pSym->GetID();
bool bReposition = (idSym == IDR_AGLOGO || idSym == IDR_CARDBACK_COPYRIGHT);
if (bReposition)
{
// Move these symbols up to make room for the FYS logo
CAGMatrix Matrix = pSym->GetMatrix();
Matrix.Translate(0, -(INCHES(0.5)));
pSym->SetMatrix(Matrix);
}
pSym->WriteFYSXml(docout, 4);
if (bReposition)
{
CAGMatrix Matrix = pSym->GetMatrix();
Matrix.Translate(0, INCHES(0.5));
pSym->SetMatrix(Matrix);
}
if (pSym->IsImage())
{
CAGSymImage* pSymImage = (CAGSymImage*)pSym;
CString strSep("\\");
CString strImagePath = m_strFYSTempPath + IMAGES_PATH + strSep;
bRetVal = DumpImageFile(pSymImage, strImagePath);
if (bRetVal)
{
SIZE PageSize;
pPage->GetPageSize(PageSize);
if (pSymImage->DoCoverDraw() && pSymImage->IsCoverAllowed())
pSymImage->WriteXmlRects(docout, PageSize, 4);
}
}
pSym->UnregisterFileSpecsCallback();
if (!bRetVal)
return false;
}
}
fprintf(docout, "\t\t\t</Page>\r\n");
}
fprintf(docout, " </Document>\r\n");
fprintf(docout, " </Documents>\r\n");
fclose(docout);
}
CString strSep("\\");
CString strFontsPath = m_strFYSTempPath + FONTS_PATH + strSep;
DumpFontFiles(strFontsPath);
// Get Configuration element
if (!GetConfigurationElement(strFYSInfo))
{
CleanUpEx(strDocFileName);
return false;
}
// Get Resources element
if (!GetResourcesElement())
{
CleanUpEx(strDocFileName);
return false;
}
// Write CreateAndPrint.xml file
CString strXmlPath = m_strFYSTempPath + XML_PATH + strSep;
if (!WriteCreatePrintXml(strDocFileName, strXmlPath))
{
CleanUpEx(strDocFileName);
return false;
}
// Write StreamHdr.xml file
if (!WriteXmlStreamHeader(strXmlPath))
{
CleanUp();
return false;
}
// Write 4YourSoul.txt file
if (!CreateSendFile())
{
CleanUp();
return false;
}
if (bUnpackFiles)
UnpackFiles();
CleanUp();
return true;
}
