void touchmind::print::XPSGeometryBuilder::CreateRectangleGeometry(
IXpsOMObjectFactory *pXpsFactory,
const XPS_RECT &rect,
OUT IXpsOMGeometryFigure **ppXpsFigure )
{
XPS_POINT startPoint;
startPoint.x = rect.x;
startPoint.y = rect.y;
XPS_SEGMENT_TYPE segmentTypes[4] = {
XPS_SEGMENT_TYPE_LINE,
XPS_SEGMENT_TYPE_LINE,
XPS_SEGMENT_TYPE_LINE,
XPS_SEGMENT_TYPE_LINE,
};
FLOAT segmentData[4 * 2] = {
rect.x + rect.width, rect.y,
rect.x + rect.width, rect.y + rect.height,
rect.x, rect.y + rect.height,
rect.x, rect.y
};
BOOL segmentStrokes[4] = {
TRUE, TRUE, TRUE, TRUE,
};
CHK_RES(*ppXpsFigure, pXpsFactory->CreateGeometryFigure(&startPoint, ppXpsFigure));
// one of the pdf converter software have a problem when set SetISClosed to TRUE
CHK_HR((*ppXpsFigure)->SetIsClosed(FALSE));
CHK_HR((*ppXpsFigure)->SetIsFilled(TRUE));
CHK_HR((*ppXpsFigure)->SetSegments(
ARRAYSIZE(segmentTypes),
ARRAYSIZE(segmentData),
segmentTypes,
segmentData,
segmentStrokes));
}
void touchmind::view::path::impl::DefaultPathView::_CreateTexture(
touchmind::Context *pContext,
ID2D1RenderTarget *pRenderTarget,
std::shared_ptr<touchmind::model::node::NodeModel> node)
{
FLOAT shadowOffset = GetNodeViewManager()->GetGaussFilter()->GetOffset();
D2D1_RECT_F bounds;
CHK_HR(m_pathGeometry->GetBounds(nullptr, &bounds));
UINT width = static_cast<UINT>((bounds.right - bounds.left) + shadowOffset * 2);
UINT height = static_cast<UINT>((bounds.bottom - bounds.top) + shadowOffset * 2);
CComPtr<ID3D10Texture2D> pSourceTexutre2D = nullptr;
CHK_RES(pSourceTexutre2D,
pContext->CreateTexture2D(width, height, &pSourceTexutre2D));
CComPtr<ID2D1RenderTarget> pSourceTexture2DRenderTarget = nullptr;
CHK_RES(pSourceTexture2DRenderTarget,
pContext->CreateD2DRenderTargetFromTexture2D(
pSourceTexutre2D,
&pSourceTexture2DRenderTarget));
pSourceTexture2DRenderTarget->BeginDraw();
pSourceTexture2DRenderTarget->Clear(D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.0f));
pSourceTexture2DRenderTarget->SetTransform(D2D1::Matrix3x2F::Translation(-m_bounds.left + shadowOffset, -m_bounds.top + shadowOffset));
pSourceTexture2DRenderTarget->DrawGeometry(m_pathGeometry, GetNodeViewManager()->GetSelectedShadowBrush1(), node->GetPathModel()->GetWidthAsValue() + 2.0f);
pSourceTexture2DRenderTarget->DrawGeometry(m_pathGeometry, GetNodeViewManager()->GetSelectedShadowBrush2(), node->GetPathModel()->GetWidthAsValue());
CHK_HR(pSourceTexture2DRenderTarget->EndDraw());
CComPtr<ID3D10Texture2D> pTexture2D = nullptr;
CHK_RES(pTexture2D,
GetNodeViewManager()->GetGaussFilter()->ApplyFilter(pContext, pSourceTexutre2D, &pTexture2D));
m_pBitmap = nullptr;
CHK_RES(m_pBitmap,
pContext->CreateD2DSharedBitmapFromTexture2D(pRenderTarget, pTexture2D, &m_pBitmap));
ASSERT(m_pBitmap != nullptr);
}
void touchmind::print::XPSGeometryBuilder::CreateCurvePathGeometry(
IXpsOMObjectFactory *pXpsFactory,
const touchmind::model::CurvePoints &curvePoints,
IXpsOMGeometryFigure **ppXpsFigure )
{
XPS_POINT startPoint;
startPoint.x = curvePoints.GetX(0);
startPoint.y = curvePoints.GetY(0);
XPS_SEGMENT_TYPE segmentTypes[1] = {
XPS_SEGMENT_TYPE_BEZIER
};
FLOAT segmentData[6] = {
curvePoints.GetX(1), curvePoints.GetY(1),
curvePoints.GetX(2), curvePoints.GetY(2),
curvePoints.GetX(3), curvePoints.GetY(3)
};
BOOL segmentStrokes[1] = {
TRUE
};
CHK_RES(*ppXpsFigure, pXpsFactory->CreateGeometryFigure(&startPoint, ppXpsFigure)) ;
CHK_HR((*ppXpsFigure)->SetIsClosed(FALSE));
CHK_HR((*ppXpsFigure)->SetIsFilled(FALSE));
CHK_HR((*ppXpsFigure)->SetSegments(
1, 6,
segmentTypes,
segmentData,
segmentStrokes));
}
HRESULT XMLHelper::GetAttributeFromNode(IXMLDOMNode *pNode, BSTR bstrAttrName, VARIANT * varAttrValue)
{
HRESULT hr = S_OK;
IXMLDOMNamedNodeMap *pAttributes = NULL;
IXMLDOMNode *pAttrNode = NULL;
CHK_HR(pNode->get_attributes(&pAttributes));
if (pAttributes)
{
CHK_HR(pAttributes->getNamedItem(bstrAttrName, &pAttrNode));
if (pAttrNode)
{
CHK_HR(pAttrNode->get_nodeValue(varAttrValue));
}
}
else
{
hr = S_FALSE;
}
CleanUp:
SAFE_RELEASE(pAttributes);
SAFE_RELEASE(pAttrNode);
return hr;
}
// Helper function to create and add an attribute to a parent node.
HRESULT XMLHelper::CreateAndAddAttributeNode(IXMLDOMDocument *pDom, PCWSTR wszName, PCWSTR wszValue, IXMLDOMElement *pParent)
{
HRESULT hr = S_OK;
IXMLDOMAttribute *pAttribute = NULL;
IXMLDOMAttribute *pAttributeOut = NULL; // Out param that is not used
BSTR bstrName = NULL;
VARIANT varValue;
VariantInit(&varValue);
bstrName = SysAllocString(wszName);
CHK_ALLOC(bstrName);
CHK_HR(VariantFromString(wszValue, varValue));
CHK_HR(pDom->createAttribute(bstrName, &pAttribute));
CHK_HR(pAttribute->put_value(varValue));
CHK_HR(pParent->setAttributeNode(pAttribute, &pAttributeOut));
CleanUp:
SAFE_RELEASE(pAttribute);
SAFE_RELEASE(pAttributeOut);
SysFreeString(bstrName);
VariantClear(&varValue);
return hr;
}
void touchmind::win::CanvasPanel::OnRender() {
UI_ANIMATION_SECONDS secondsNow;
CHK_HR(m_pContext->GetAnimationTimer()->GetTime(&secondsNow));
CHK_HR(m_pContext->GetAnimationManager()->Update(secondsNow));
CHK_HR(m_pContext->OnRender());
UI_ANIMATION_MANAGER_STATUS status;
CHK_HR(m_pContext->GetAnimationManager()->GetStatus(&status));
if (status == UI_ANIMATION_MANAGER_BUSY) {
Invalidate();
}
}
int DicomImageSet::parseFolder(QString folderName)
{
QStringList fileList = getAllFiles(folderName);
HRESULT hr = CoInitialize(NULL);
if (!SUCCEEDED(hr))
{
return NULL;
}
hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMElement *pRoot = NULL;
BSTR bstrXML = NULL;
VARIANT varFileName;
VariantInit(&varFileName);
QProgressDialog progress (QString("Parsing all files in %1").arg(folderName), QString("Cancel"), 0, fileList.count());
CHK_HR(CreateAndInitDOM(&pXMLDom));
// Create a processing instruction element.
CHK_HR(CreateAndAddPINode(pXMLDom, L"xml", L"version='1.0'"));
// Create the root element.
CHK_HR(CreateElement(pXMLDom, L"root", &pRoot));
// Create an attribute for the <root> element, with name "created" and value "using dom".
CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"path", folderName.toStdWString().c_str(), pRoot));
// Add NEWLINE for identation before </root>.
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pRoot));
// add <root> to document
CHK_HR(AppendChildToParent(pRoot, pXMLDom));
progress.show();
for (int i=0; i<fileList.count(); ++i)
{
insertFileItem(pXMLDom, pRoot, folderName, fileList[i]);
progress.setValue(i);
}
CHK_HR(VariantFromString(QDir(folderName).filePath(DATASET_FILE_NAME).toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->save(varFileName));
CleanUp:
SAFE_RELEASE(pRoot);
SysFreeString(bstrXML);
VariantClear(&varFileName);
CoUninitialize();
if (FAILED(hr))
{
SAFE_RELEASE(pXMLDom);
return 0;
}
return 1;
}
// Helper function to create and add a comment to a document node.
HRESULT XMLHelper::CreateAndAddCommentNode(IXMLDOMDocument *pDom, PCWSTR wszComment)
{
HRESULT hr = S_OK;
IXMLDOMComment *pComment = NULL;
BSTR bstrComment = SysAllocString(wszComment);
CHK_ALLOC(bstrComment);
CHK_HR(pDom->createComment(bstrComment, &pComment));
CHK_HR(AppendChildToParent(pComment, pDom));
CleanUp:
SAFE_RELEASE(pComment);
SysFreeString(bstrComment);
return hr;
}
// Helper function to create and append a CDATA node to a parent node.
HRESULT XMLHelper::CreateAndAddCDATANode(IXMLDOMDocument *pDom, PCWSTR wszCDATA, IXMLDOMNode *pParent)
{
HRESULT hr = S_OK;
IXMLDOMCDATASection *pCDATA = NULL;
BSTR bstrCDATA = SysAllocString(wszCDATA);
CHK_ALLOC(bstrCDATA);
CHK_HR(pDom->createCDATASection(bstrCDATA, &pCDATA));
CHK_HR(AppendChildToParent(pCDATA, pParent));
CleanUp:
SAFE_RELEASE(pCDATA);
SysFreeString(bstrCDATA);
return hr;
}
HRESULT XMLHelper::CreateAndAddTextNodeBefore(IXMLDOMDocument *pDom, PCWSTR wszText, IXMLDOMNode *pParent, IXMLDOMNode *pPosition)
{
HRESULT hr = S_OK;
IXMLDOMText *pText = NULL;
BSTR bstrText = SysAllocString(wszText);
CHK_ALLOC(bstrText);
CHK_HR(pDom->createTextNode(bstrText, &pText));
CHK_HR(InsertChildToParent(pText, pPosition, pParent));
CleanUp:
SAFE_RELEASE(pText);
SysFreeString(bstrText);
return hr;
}
// Helper function to display parse error.
// It returns error code of the parse error.
HRESULT XMLHelper::ReportParseError(IXMLDOMDocument *pDoc, char *szDesc)
{
HRESULT hr = S_OK;
HRESULT hrRet = E_FAIL; // Default error code if failed to get from parse error.
IXMLDOMParseError *pXMLErr = NULL;
BSTR bstrReason = NULL;
CHK_HR(pDoc->get_parseError(&pXMLErr));
CHK_HR(pXMLErr->get_errorCode(&hrRet));
CHK_HR(pXMLErr->get_reason(&bstrReason));
printf("%s\n%S\n", szDesc, bstrReason);
CleanUp:
SAFE_RELEASE(pXMLErr);
SysFreeString(bstrReason);
return hrRet;
}
// Helper function to create and add a processing instruction to a document node.
HRESULT XMLHelper::CreateAndAddPINode(IXMLDOMDocument *pDom, PCWSTR wszTarget, PCWSTR wszData)
{
HRESULT hr = S_OK;
IXMLDOMProcessingInstruction *pPI = NULL;
BSTR bstrTarget = SysAllocString(wszTarget);
BSTR bstrData = SysAllocString(wszData);
CHK_ALLOC(bstrTarget && bstrData);
CHK_HR(pDom->createProcessingInstruction(bstrTarget, bstrData, &pPI));
CHK_HR(AppendChildToParent(pPI, pDom));
CleanUp:
SAFE_RELEASE(pPI);
SysFreeString(bstrTarget);
SysFreeString(bstrData);
return hr;
}
int DicomImageSet::insertDTIFileItem(const QString &datasetFolderName, const QString &queryString, const QString &dtiFileName)
{
HRESULT hr = CoInitialize(NULL);
if (!SUCCEEDED(hr))
{
return 0;
}
QString datasetFileName = datasetFolderName+DATASET_FILE_NAME;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMElement *pNode = NULL, *pParent = NULL;
BSTR bstrQuery = NULL;
VARIANT varFileName;
VARIANT_BOOL varStatus;
QString queryDTIFile;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
/*queryDTIFile = queryString+QString("/DTI[@file_name = '%1']").arg(dtiFileName);
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pNode));
SysFreeString(bstrQuery);
if (pNode)
{
return 1;
}*/
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pParent));
SysFreeString(bstrQuery);
if (pParent)
{
CHK_HR(CreateElement(pXMLDom, L"DTI", &pNode));
CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"file_name", dtiFileName.toStdWString().c_str(), pNode));
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pParent));
CHK_HR(AppendChildToParent(pNode, pParent));
CHK_HR(pXMLDom->save(varFileName));
return 1;
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pNode);
return 0;
}
// Helper function to append a child to a parent node.
HRESULT XMLHelper::AppendChildToParent(IXMLDOMNode *pChild, IXMLDOMNode *pParent)
{
HRESULT hr = S_OK;
IXMLDOMNode *pChildOut = NULL;
CHK_HR(pParent->appendChild(pChild, &pChildOut));
CleanUp:
SAFE_RELEASE(pChildOut);
return hr;
}
// Helper function to create and append an element node to a parent node, and pass the newly created
// element node to caller if it wants.
HRESULT XMLHelper::CreateAndAddElementNode(IXMLDOMDocument *pDom, PCWSTR wszName, PCWSTR wszNewline, IXMLDOMNode *pParent, IXMLDOMElement **ppElement)
{
HRESULT hr = S_OK;
IXMLDOMElement* pElement = NULL;
CHK_HR(CreateElement(pDom, wszName, &pElement));
// Add NEWLINE+TAB for identation before this element.
CHK_HR(CreateAndAddTextNode(pDom, wszNewline, pParent));
// Append this element to parent.
CHK_HR(AppendChildToParent(pElement, pParent));
CleanUp:
if (ppElement)
*ppElement = pElement; // Caller is repsonsible to release this element.
else
SAFE_RELEASE(pElement); // Caller is not interested on this element, so release it.
return hr;
}
HRESULT XMLHelper::SetAttribute(PCWSTR wszName, PCWSTR wszValue, IXMLDOMElement *pParent)
{
HRESULT hr = S_OK;
BSTR bstrName = NULL;
VARIANT varValue;
VariantInit(&varValue);
bstrName = SysAllocString(wszName);
CHK_ALLOC(bstrName);
CHK_HR(VariantFromString(wszValue, varValue));
CHK_HR(pParent->setAttribute(bstrName, varValue));
CleanUp:
SysFreeString(bstrName);
VariantClear(&varValue);
return hr;
}
// Helper function to append a child to a parent node.
HRESULT XMLHelper::InsertChildToParent(IXMLDOMNode *pChild, IXMLDOMNode *pRefChild, IXMLDOMNode *pParent)
{
HRESULT hr = S_OK;
IXMLDOMNode *pChildOut = NULL;
_variant_t varSiblingNodeRef = pRefChild;
CHK_HR(pParent->insertBefore(pChild, varSiblingNodeRef, &pChildOut));
CleanUp:
SAFE_RELEASE(pChildOut);
return hr;
}
void touchmind::print::XPSGeometryBuilder::CreateCircleGeometry(
IXpsOMObjectFactory *pXpsFactory,
const D2D1_POINT_2F &point,
FLOAT r,
OUT IXpsOMGeometryFigure** ppXpsFigure )
{
XPS_POINT startPoint = {
point.x + r,
point.y
};
XPS_SEGMENT_TYPE segmentTypes[] = {
XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE,
XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE,
XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE,
XPS_SEGMENT_TYPE_ARC_SMALL_CLOCKWISE,
};
FLOAT segmentData[] = {
point.x, point.y + r, r, r, 90.0f,
point.x - r, point.y, r, r, 90.0f,
point.x, point.y - r, r, r, 90.0f,
point.x + r, point.y, r, r, 90.0f,
};
BOOL segmentStrokes[] = {
TRUE,
TRUE,
TRUE,
TRUE,
};
CHK_RES(*ppXpsFigure, pXpsFactory->CreateGeometryFigure(&startPoint, ppXpsFigure));
// one of the pdf converter software have a problem when set SetISClosed to TRUE
CHK_HR((*ppXpsFigure)->SetIsClosed(FALSE));
CHK_HR((*ppXpsFigure)->SetIsFilled(TRUE));
CHK_HR((*ppXpsFigure)->SetSegments(
ARRAYSIZE(segmentTypes),
ARRAYSIZE(segmentData),
segmentTypes,
segmentData,
segmentStrokes));
}
// Helper that allocates the BSTR param for the caller.
HRESULT XMLHelper::CreateElement(IXMLDOMDocument *pXMLDom, PCWSTR wszName, IXMLDOMElement **ppElement)
{
HRESULT hr = S_OK;
*ppElement = NULL;
BSTR bstrName = SysAllocString(wszName);
CHK_ALLOC(bstrName);
CHK_HR(pXMLDom->createElement(bstrName, ppElement));
CleanUp:
SysFreeString(bstrName);
return hr;
}
void touchmind::print::XPSGeometryBuilder::CreatePathGeometryFromPoints(
IXpsOMObjectFactory *pXpsFactory,
const std::vector<D2D1_POINT_2F> &points,
OUT IXpsOMGeometryFigure** ppXpsFigure)
{
XPS_POINT startPoint = {points[0].x, points[0].y};
std::vector<XPS_SEGMENT_TYPE> segmentTypes(points.size());
std::vector<FLOAT> segmentData(segmentTypes.size() * 2);
std::vector<BOOL> segmentStrokes(segmentTypes.size());
for (size_t i = 1; i < points.size(); ++i) {
size_t j = i - 1;
segmentTypes[j] = XPS_SEGMENT_TYPE_LINE;
segmentData[j * 2] = points[i].x;
segmentData[j * 2 + 1] = points[i].y;
segmentStrokes[j] = TRUE;
}
size_t i = 0;
size_t j = points.size() - 1;
segmentTypes[j] = XPS_SEGMENT_TYPE_LINE;
segmentData[j * 2] = points[i].x;
segmentData[j * 2 + 1] = points[i].y;
segmentStrokes[j] = TRUE;
CHK_RES(*ppXpsFigure, pXpsFactory->CreateGeometryFigure(&startPoint, ppXpsFigure));
// one of the pdf converter software have a problem when set SetISClosed to TRUE
CHK_HR((*ppXpsFigure)->SetIsClosed(FALSE));
CHK_HR((*ppXpsFigure)->SetIsFilled(TRUE));
CHK_HR((*ppXpsFigure)->SetSegments(
static_cast<UINT32>(segmentTypes.size()),
static_cast<UINT32>(segmentData.size()),
&segmentTypes.front(),
&segmentData.front(),
&segmentStrokes.front()));
}
QStringList DicomImageSet::getOrderedDcmFiles(const QString &datasetFileName, const QString & queryString)
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNodeList *pFileNodes = NULL;
VARIANT_BOOL varStatus;
VARIANT varFileName;
BSTR bstrQuery;
QStringList fileList;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectNodes(bstrQuery, &pFileNodes));
if (pFileNodes)
{
long nFiles;
CHK_HR(pFileNodes->get_length(&nFiles));
for (long i=0; i<nFiles; ++i)
{
VARIANT varValue;
IXMLDOMNode * pFile = NULL;
CHK_HR(pFileNodes->get_item(i, &pFile));
CHK_HR(GetAttributeFromNode(pFile, L"path", &varValue));
fileList <<QString::fromWCharArray(_bstr_t(varValue));
SAFE_RELEASE(pFile);
}
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pFileNodes);
return fileList;
}
void touchmind::print::XPSPrint::_PrintNode(const std::shared_ptr<touchmind::model::node::NodeModel> &node)
{
CComPtr<IXpsOMVisualCollection> canvasVisuals = nullptr;
CHK_RES(canvasVisuals, m_pXpsCanvas->GetVisuals(&canvasVisuals));
CComPtr<IXpsOMSolidColorBrush> fillBrush = nullptr;
COLORREF bgColor = touchmind::util::ColorUtil::ToColorref(node->GetBackgroundColor());
XPS_COLOR bodyColor;
bodyColor.colorType = XPS_COLOR_TYPE_SRGB;
bodyColor.value.sRGB.alpha = 0xff;
bodyColor.value.sRGB.red = GetRValue(bgColor);
bodyColor.value.sRGB.green = GetGValue(bgColor);
bodyColor.value.sRGB.blue = GetBValue(bgColor);
CHK_RES(fillBrush,
m_pXpsFactory->CreateSolidColorBrush(&bodyColor, nullptr, &fillBrush));
CComPtr<IXpsOMSolidColorBrush> strokeBrush = nullptr;
ZeroMemory(&bodyColor, sizeof(bodyColor));
bodyColor.colorType = XPS_COLOR_TYPE_SRGB;
bodyColor.value.sRGB.alpha = 0xff;
bodyColor.value.sRGB.red = 0;
bodyColor.value.sRGB.green = 0;
bodyColor.value.sRGB.blue = 0;
CHK_RES(strokeBrush,
m_pXpsFactory->CreateSolidColorBrush(&bodyColor, nullptr, &strokeBrush));
XPS_RECT rect = {node->GetX(), node->GetY(), node->GetWidth(), node->GetHeight()};
CComPtr<IXpsOMGeometryFigure> xpsFigure = nullptr;
if (node->GetNodeShape() == NODE_SHAPE_RECTANGLE) {
XPSGeometryBuilder::CreateRectangleGeometry(m_pXpsFactory, rect, &xpsFigure);
} else {
XPSGeometryBuilder::CreateRoundedRectangleGeometry(m_pXpsFactory, rect, 10.0f, &xpsFigure);
}
CComPtr<IXpsOMGeometry> xpsGeometry = nullptr;
CHK_RES(xpsGeometry, m_pXpsFactory->CreateGeometry(&xpsGeometry));
CComPtr<IXpsOMGeometryFigureCollection> xpsFigureCollection = nullptr;
CHK_HR(xpsGeometry->GetFigures(&xpsFigureCollection));
CHK_HR(xpsFigureCollection->Append(xpsFigure));
CComPtr<IXpsOMPath> path = nullptr;
CHK_RES(path, m_pXpsFactory->CreatePath(&path));
CHK_HR(path->SetFillBrushLocal(fillBrush));
CHK_HR(path->SetStrokeBrushLocal(strokeBrush));
CHK_HR(path->SetGeometryLocal(xpsGeometry));
CHK_HR(canvasVisuals->Append(path));
}
void touchmind::print::XPSPrint::_ShowPrintDlg()
{
CHK_FATAL_NULL(
m_pPDX = static_cast<LPPRINTDLGEX>(GlobalAlloc(GPTR, sizeof(PRINTDLGEX))));
CHK_FATAL_NULL(
m_pPageRanges = static_cast<LPPRINTPAGERANGE>(GlobalAlloc(GPTR, 10 * sizeof(PRINTPAGERANGE))));
m_pPDX->lStructSize = sizeof(PRINTDLGEX);
m_pPDX->hwndOwner = m_parentHWnd;
m_pPDX->hDevMode = nullptr;
m_pPDX->hDevNames = nullptr;
m_pPDX->hDC = nullptr;
m_pPDX->Flags = PD_RETURNDC | PD_COLLATE;
m_pPDX->Flags2 = 0;
m_pPDX->ExclusionFlags = 0;
m_pPDX->nPageRanges = 0;
m_pPDX->nMaxPageRanges = 10;
m_pPDX->lpPageRanges = m_pPageRanges;
m_pPDX->nMinPage = 1;
m_pPDX->nMaxPage = 1000;
m_pPDX->nCopies = 1;
m_pPDX->hInstance = 0;
m_pPDX->lpPrintTemplateName = nullptr;
m_pPDX->lpCallback = nullptr;
m_pPDX->nPropertyPages = 0;
m_pPDX->lphPropertyPages = nullptr;
m_pPDX->nStartPage = START_PAGE_GENERAL;
m_pPDX->dwResultAction = 0;
CHK_HR(::PrintDlgEx(m_pPDX));
if (m_pPDX->dwResultAction == PD_RESULT_PRINT || m_pPDX->dwResultAction == PD_RESULT_APPLY) {
LPDEVNAMES devnames = (LPDEVNAMES)GlobalLock(m_pPDX->hDevNames);
m_deviceName = (wchar_t*)devnames + devnames->wDeviceOffset;
GlobalUnlock(m_pPDX->hDevNames);
}
}
QString DicomImageSet::getDTIFileName(const QString &datasetFolderName, const QString &queryString)
{
QString datasetFileName = datasetFolderName+DATASET_FILE_NAME;
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNode *pFileNode = NULL;
VARIANT_BOOL varStatus;
VARIANT varFileName;
BSTR bstrQuery;
QStringList fileList;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
bstrQuery = SysAllocString(QString(queryString+"/DTI").toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, &pFileNode));
if (pFileNode)
{
VARIANT varValue;
CHK_HR(GetAttributeFromNode(pFileNode, L"file_name", &varValue));
return QString::fromWCharArray(_bstr_t(varValue));
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pFileNode);
return QString();
}
int DicomImageSet::readDatasetFile(const QString &datasetFileName, QTreeWidget *treeWidget)
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNodeList *pPatients = NULL;
IXMLDOMNode *pPatient = NULL;
DOMNodeType nodeType;
VARIANT_BOOL varStatus;
VARIANT varFileName;
VARIANT varValue;
BSTR bstrQuery;
VariantInit(&varFileName);
VariantInit(&varValue);
QString queryPatient, queryDate, queryProtocol, queryCollection;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
treeWidget->clear();
treeWidget->setColumnCount(1);
CHK_HR(pXMLDom->getElementsByTagName(L"Patient", &pPatients));
if (pPatients)
{
long nPatients;
CHK_HR(pPatients->get_length(&nPatients));
for (long i=0; i<nPatients; ++i)
{
CHK_HR(pPatients->get_item(i, &pPatient));
CHK_HR(GetAttributeFromNode(pPatient, L"patients_name", &varValue));
queryPatient = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * patientItem = new QTreeWidgetItem(treeWidget, QStringList(queryPatient));
patientItem->setExpanded(true);
IXMLDOMNodeList * pDates = NULL;
CHK_HR(pPatient->get_childNodes(&pDates));
long nDates;
CHK_HR(pDates->get_length(&nDates));
for (long j=0; j<nDates; ++j)
{
IXMLDOMNode * pDate = NULL;
CHK_HR(pDates->get_item(j, &pDate));
CHK_HR(pDate->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pDate, L"acquisition_date", &varValue));
queryDate = QString::fromWCharArray(_bstr_t(varValue));
int intDate = queryDate.toInt();
QDate date = (QDate::fromString("1900-01-01", "yyyy-MM-dd")).addDays(intDate-693962);
QTreeWidgetItem * dateItem = new QTreeWidgetItem(patientItem, QStringList(date.toString("yyyy-MM-dd")));
dateItem->setExpanded(true);
IXMLDOMNodeList * pProtocols = NULL;
CHK_HR(pDate->get_childNodes(&pProtocols));
long nProtocols;
CHK_HR(pProtocols->get_length(&nProtocols));
for (long j=0; j<nProtocols; ++j)
{
IXMLDOMNode * pProtocol = NULL;
CHK_HR(pProtocols->get_item(j, &pProtocol));
CHK_HR(pProtocol->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pProtocol, L"protocol_name", &varValue));
queryProtocol = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * protocolItem = new QTreeWidgetItem(dateItem, QStringList(queryProtocol));
protocolItem->setExpanded(true);
IXMLDOMNodeList * pCollections = NULL;
CHK_HR(pProtocol->get_childNodes(&pCollections));
long nCollections;
CHK_HR(pCollections->get_length(&nCollections));
for (long j=0; j<nCollections; ++j)
{
IXMLDOMNode * pCollection = NULL;
CHK_HR(pCollections->get_item(j, &pCollection));
CHK_HR(pCollection->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pCollection, L"acquisition_number", &varValue));
queryCollection = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * collectionItem = new QTreeWidgetItem(protocolItem);
QString queryStr = QString("root/Patient[@patients_name = '%1']/Date[@acquisition_date = '%2']/Protocol[@protocol_name = '%3']/Collection[@acquisition_number = '%4']")
.arg(queryPatient).arg(queryDate).arg(queryProtocol).arg(queryCollection);
IXMLDOMElement * pDtiNode = NULL;
bstrQuery = SysAllocString(QString(queryStr+"/DTI").toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pDtiNode));
SysFreeString(bstrQuery);
if (pDtiNode)
{
collectionItem->setText(0,queryCollection+"*");
} else
{
collectionItem->setText(0, queryCollection);
}
collectionItem->setData(0, Qt::UserRole, queryStr);
collectionItem->setExpanded(true);
protocolItem->addChild(collectionItem);
SAFE_RELEASE(pCollection);
}
dateItem->addChild(protocolItem);
SAFE_RELEASE(pProtocol);
}
patientItem->addChild(dateItem);
SAFE_RELEASE(pDate);
}
treeWidget->insertTopLevelItem(i, patientItem);
SAFE_RELEASE(pPatient);
}
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pPatients);
SAFE_RELEASE(pPatient);
VariantClear(&varFileName);
return SUCCEEDED(hr);
}
int DicomImageSet::insertFileItem(IXMLDOMDocument *pDom, IXMLDOMNode * pRoot, const QString &folderName, const QString &fileName)
{
DicomImage * dicomImage = new DicomImage ();
if (!dicomImage->readHeader((QDir(folderName).absoluteFilePath(fileName)).toStdString().c_str()))
{
//fail to resolve header information
return 0;
}
int nElement;
char * patientsName = dicomImage->getCharTag(DicomImage::TAG_PATIENTS_NAME, nElement);
char * patientsId = dicomImage->getCharTag(DicomImage::TAG_PATIENT_ID, nElement);
char * protocolName = dicomImage->getCharTag(DicomImage::TAG_PROTOCOL_NAME, nElement);
double * pInstanceNumber = dicomImage->getNumericTag(DicomImage::TAG_INSTANCE_NUMBER, nElement);
double * pAcquisitionNumber = dicomImage->getNumericTag(DicomImage::TAG_ACQUISITION_NUMBER, nElement);
double * pAcquisitionDate = dicomImage->getNumericTag(DicomImage::TAG_ACQUISITION_DATE, nElement);
int instanceNumber = pInstanceNumber?(int)pInstanceNumber[0]:-1;
int acquisitionNumber = pAcquisitionNumber?(int)pAcquisitionNumber[0]:-1;
int acquisitionDate = pAcquisitionDate?(int)pAcquisitionDate[0]:0;
IXMLDOMNode * pParent = findParentNode(pDom, pRoot, patientsName, patientsId, acquisitionDate, protocolName, acquisitionNumber);
if (!pParent)
{
return 0;
}
HRESULT hr = S_OK;
IXMLDOMElement *pNode = NULL;
CHK_HR(CreateElement(pDom, L"File", &pNode));
CHK_HR(CreateAndAddAttributeNode(pDom, L"path", fileName.toStdWString().c_str(), pNode));
CHK_HR(CreateAndAddAttributeNode(pDom, L"instance_number", QString::number(instanceNumber).toStdWString().c_str(), pNode));
IXMLDOMNode * pSibling = NULL;
CHK_HR(pParent->get_firstChild(&pSibling));
int sibInstanceNumber = -1;
VARIANT varInstanceNumber;
DOMNodeType nodeType;
while (pSibling && instanceNumber >= sibInstanceNumber)
{
CHK_HR(pSibling->get_nodeType(&nodeType));
if(nodeType == NODE_ELEMENT)
{
CHK_HR(GetAttributeFromNode(pSibling, L"instance_number", &varInstanceNumber));
sibInstanceNumber = QString::fromWCharArray(_bstr_t(varInstanceNumber)).toInt();
if (instanceNumber < sibInstanceNumber)
{
break;
}
}
IXMLDOMNode * tmpNode = NULL;
CHK_HR(pSibling->get_nextSibling(&tmpNode));
SAFE_RELEASE(pSibling);
pSibling = tmpNode;
}
if (pSibling)
{
IXMLDOMNode * tmpNode = NULL;
CHK_HR(pSibling->get_previousSibling(&tmpNode));
SAFE_RELEASE(pSibling);
pSibling = tmpNode;
}
CHK_HR(CreateAndAddTextNodeBefore(pDom, L"\n", pParent, pSibling));
CHK_HR(InsertChildToParent(pNode, pSibling, pParent));
CleanUp:
SAFE_RELEASE(pNode);
return 1;
}
void touchmind::print::XPSPrint::_PrintLinkEdge(
const std::shared_ptr<touchmind::model::link::LinkModel> &link,
EDGE_ID edgeId )
{
auto linkEdge = link->GetEdge(edgeId);
if (linkEdge->GetStyle() == EDGE_STYLE_NORMAL) {
return;
}
FLOAT markerSize = linkEdge->GetMarkerSize();
auto node = link->GetNode(edgeId);
D2D1_POINT_2F point0 = link->GetEdgePoint(edgeId);
NODE_SIDE nodeSide = link->GetNode(edgeId)->GetAncestorPosition();
CComPtr<IXpsOMVisualCollection> canvasVisuals = nullptr;
CHK_HR(m_pXpsCanvas->GetVisuals(&canvasVisuals));
COLORREF colorref = util::ColorUtil::ToColorref(link->GetLineColor());
CComPtr<IXpsOMSolidColorBrush> strokeBrush = nullptr;
XPS_COLOR bodyColor;
bodyColor.colorType = XPS_COLOR_TYPE_SRGB;
bodyColor.value.sRGB.alpha = 0xFF;
bodyColor.value.sRGB.red = GetRValue(colorref);
bodyColor.value.sRGB.green = GetGValue(colorref);
bodyColor.value.sRGB.blue = GetBValue(colorref);
CHK_RES(strokeBrush,
m_pXpsFactory->CreateSolidColorBrush(&bodyColor, nullptr, &strokeBrush));
CComPtr<IXpsOMGeometryFigure> xpsFigure = nullptr;
if (linkEdge->GetStyle() == EDGE_STYLE_CIRCLE) {
FLOAT shift = (nodeSide == NODE_SIDE_RIGHT ? markerSize / 2.0f : -markerSize / 2.0f);
XPSGeometryBuilder::CreateCircleGeometry(
m_pXpsFactory,
D2D1::Point2F(point0.x + shift, point0.y),
markerSize / 2.0f,
&xpsFigure);
} else {
std::vector<D2D1_POINT_2F> points;
view::GeometryBuilder::CalculateArrowPoints(
point0,
linkEdge->GetMarkerSize() + link->GetLineWidth(),
linkEdge->GetMarkerSize() + link->GetLineWidth(),
linkEdge->GetAngle(),
node->GetAncestorPosition(),
points);
XPSGeometryBuilder::CreatePathGeometryFromPoints(
m_pXpsFactory,
points,
&xpsFigure);
}
CComPtr<IXpsOMGeometry> xpsGeometry = nullptr;
CHK_RES(xpsGeometry, m_pXpsFactory->CreateGeometry(&xpsGeometry));
CComPtr<IXpsOMGeometryFigureCollection> xpsFigureCollection = nullptr;
CHK_HR(xpsGeometry->GetFigures(&xpsFigureCollection));
CHK_HR(xpsFigureCollection->Append(xpsFigure));
CComPtr<IXpsOMPath> xpsPath = nullptr;
CHK_RES(xpsPath, m_pXpsFactory->CreatePath(&xpsPath));
CHK_HR(xpsPath->SetFillBrushLocal(strokeBrush));
CHK_HR(xpsPath->SetGeometryLocal(xpsGeometry));
CHK_HR(canvasVisuals->Append(xpsPath));
}
void touchmind::print::XPSPrint::_PrintLink(const std::shared_ptr<touchmind::model::link::LinkModel> &link)
{
CComPtr<IXpsOMVisualCollection> canvasVisuals = nullptr;
CHK_HR(m_pXpsCanvas->GetVisuals(&canvasVisuals));
COLORREF colorref = util::ColorUtil::ToColorref(link->GetLineColor());
CComPtr<IXpsOMSolidColorBrush> strokeBrush = nullptr;
XPS_COLOR bodyColor;
bodyColor.colorType = XPS_COLOR_TYPE_SRGB;
bodyColor.value.sRGB.alpha = 0xFF;
bodyColor.value.sRGB.red = GetRValue(colorref);
bodyColor.value.sRGB.green = GetGValue(colorref);
bodyColor.value.sRGB.blue = GetBValue(colorref);
CHK_RES(strokeBrush,
m_pXpsFactory->CreateSolidColorBrush(&bodyColor, nullptr, &strokeBrush));
model::CurvePoints curvePoints;
view::GeometryBuilder::CalculateLink(link, curvePoints);
CComPtr<IXpsOMGeometryFigure> xpsFigure = nullptr;
XPSGeometryBuilder::CreateCurvePathGeometry(m_pXpsFactory, curvePoints, &xpsFigure);
CComPtr<IXpsOMGeometry> xpsGeometry = nullptr;
CHK_RES(xpsGeometry, m_pXpsFactory->CreateGeometry(&xpsGeometry));
CComPtr<IXpsOMGeometryFigureCollection> xpsFigureCollection = nullptr;
CHK_HR(xpsGeometry->GetFigures(&xpsFigureCollection));
CHK_HR(xpsFigureCollection->Append(xpsFigure));
CComPtr<IXpsOMPath> xpsPath = nullptr;
CHK_RES(xpsPath, m_pXpsFactory->CreatePath(&xpsPath));
CHK_HR(xpsPath->SetStrokeBrushLocal(strokeBrush));
CHK_HR(xpsPath->SetGeometryLocal(xpsGeometry));
CHK_HR(xpsPath->SetStrokeThickness(link->GetLineWidthAsValue()));
if (link->GetLineStyle() == LINE_STYLE_DOTTED) {
xpsPath->SetStrokeDashCap(XPS_DASH_CAP_ROUND);
xpsPath->SetStrokeDashOffset(0.25f);
CComPtr<IXpsOMDashCollection> pDashCollection = nullptr;
CHK_HR(xpsPath->GetStrokeDashes(&pDashCollection));
XPS_DASH dash;
dash.length = 0.0f;
dash.gap = 2.0f;
CHK_HR(pDashCollection->Append(&dash));
} else if (link->GetLineStyle() == LINE_STYLE_DASHED) {
xpsPath->SetStrokeDashCap(XPS_DASH_CAP_ROUND);
xpsPath->SetStrokeDashOffset(1.0f);
CComPtr<IXpsOMDashCollection> pDashCollection = nullptr;
CHK_HR(xpsPath->GetStrokeDashes(&pDashCollection));
XPS_DASH dash;
dash.length = 2.0f;
dash.gap = 2.0f;
CHK_HR(pDashCollection->Append(&dash));
}
CHK_HR(canvasVisuals->Append(xpsPath));
_PrintLinkEdge(link, EDGE_ID_1);
_PrintLinkEdge(link, EDGE_ID_2);
}
void touchmind::print::XPSPrint::_CreateCanvas()
{
// create a package
CHK_RES(m_pXpsPackage,
m_pXpsFactory->CreatePackage(&m_pXpsPackage));
// create a document sequence
CComPtr<IOpcPartUri> opcPartUri = nullptr;
CHK_RES(opcPartUri,
m_pXpsFactory->CreatePartUri(L"/FixedDocumentSequence.fdseq", &opcPartUri));
CComPtr<IXpsOMDocumentSequence> xpsFDS = nullptr;
CHK_RES(xpsFDS,
m_pXpsFactory->CreateDocumentSequence(opcPartUri, &xpsFDS));
// create a document
opcPartUri = nullptr;
CHK_RES(opcPartUri,
m_pXpsFactory->CreatePartUri(L"/Documents/1/FixedDocument.fdoc", &opcPartUri));
CComPtr<IXpsOMDocument> xpsFD = nullptr;
CHK_RES(xpsFD,
m_pXpsFactory->CreateDocument(opcPartUri, &xpsFD));
// create a page reference
CComPtr<IXpsOMPageReference> xpsPageRef = nullptr;
CHK_RES(xpsPageRef,
m_pXpsFactory->CreatePageReference(&m_pageSize, &xpsPageRef));
// create a page
opcPartUri = nullptr;
CHK_RES(opcPartUri,
m_pXpsFactory->CreatePartUri( L"/Documents/1/Pages/1.fpage", &opcPartUri));
CComPtr<IXpsOMPage> xpsPage = nullptr;
CHK_RES(xpsPage,
m_pXpsFactory->CreatePage(
&m_pageSize,
nullptr,
opcPartUri,
&xpsPage
));
opcPartUri = nullptr;
CHK_HR(m_pXpsPackage->SetDocumentSequence(xpsFDS));
CComPtr<IXpsOMDocumentCollection> fixedDocuments = nullptr;
CHK_HR(xpsFDS->GetDocuments(&fixedDocuments));
CHK_HR(fixedDocuments->Append(xpsFD));
CComPtr<IXpsOMPageReferenceCollection> pageRefs = nullptr;
CHK_HR(xpsFD->GetPageReferences(&pageRefs));
CHK_HR(pageRefs->Append(xpsPageRef));
CHK_HR(xpsPageRef->SetPage(xpsPage));
CHK_HR(xpsPage->SetLanguage(m_language.c_str()));
CComPtr<IXpsOMVisualCollection> pageVisuals = nullptr;
CHK_HR(xpsPage->GetVisuals(&pageVisuals));
CHK_HR(m_pXpsFactory->CreateCanvas(&m_pXpsCanvas));
CHK_HR(pageVisuals->Append(m_pXpsCanvas));
CHK_HR(m_pXpsFactory->CreatePartResources(&m_pXpsResources));
// Create dictionary and add to canvas
CHK_HR(m_pXpsFactory->CreateDictionary(&m_pXpsDictionary));
CHK_HR(m_pXpsCanvas->SetDictionaryLocal(m_pXpsDictionary));
CComPtr<IXpsOMMatrixTransform> pMatrixTransform = nullptr;
CHK_RES(pMatrixTransform,
m_pXpsFactory->CreateMatrixTransform(&m_xpsMatrix, &pMatrixTransform));
m_pXpsCanvas->SetTransformLocal(pMatrixTransform);
}
void touchmind::print::XPSPrint::_PrintMapModel(const touchmind::model::MapModel *pMapModel)
{
HRESULT hr = S_OK;
auto node = pMapModel->GetRootNodeModel();
XPSGeometryBuilder::CalculateTransformMatrix(m_pageSize, m_xpsMargin, node, m_xpsMatrix, m_scale);
_CreateCanvas();
m_pTextRenderer = nullptr;
CHK_HR(XpsDWriteTextRenderer::CreateInstance(m_pXpsFactory, &m_pTextRenderer));
m_pTextRenderer->SetXpsCanvas(m_pXpsCanvas);
m_pTextRenderer->SetXpsDictionary(m_pXpsDictionary);
m_pTextRenderer->SetXpsResources(m_pXpsResources);
_PrintNodes(node);
_PrintLinks(pMapModel);
HANDLE completionEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
CHK_FATAL_NULL(completionEvent);
IXpsPrintJob *job = nullptr;
IXpsPrintJobStream *jobStream = nullptr;
#ifdef PRINT_TICKET_SUPPORT
IXpsPrintJobStream *printTicketStream = nullptr;
#endif
hr = StartXpsPrintJob(
m_deviceName.c_str(),
pMapModel->HasFileName() ? pMapModel->GetFileName().c_str() : nullptr,
nullptr,
nullptr,
completionEvent,
nullptr,
0,
&job,
&jobStream,
#ifdef PRINT_TICKET_SUPPORT
& printTicketStream
#else
nullptr
#endif
);
if (FAILED(hr)) {
LOG(SEVERITY_LEVEL_ERROR) << L"StartXpsPrintJob failed, hr = " << std::hex << hr;
}
if (SUCCEEDED(hr)) {
hr = m_pXpsPackage->WriteToStream(jobStream, FALSE);
if (FAILED(hr)) {
LOG(SEVERITY_LEVEL_ERROR) << L"IXpsOMPackage::WriteToStream failed, hr = " << std::hex << hr;
}
}
#ifdef PRINT_TICKET_SUPPORT
if (SUCCEEDED(hr)) {
PrintTicketHelper::CreatePrintTicket(m_deviceName, m_pPDX, printTicketStream);
}
#endif
hr = jobStream->Close();
#ifdef PRINT_TICKET_SUPPORT
hr = printTicketStream->Close();
#endif
if (WaitForSingleObject(completionEvent, INFINITE) == WAIT_OBJECT_0) {
XPS_JOB_STATUS jobStatus;
hr = job->GetJobStatus(&jobStatus);
switch (jobStatus.completion) {
case XPS_JOB_COMPLETED:
hr = S_OK;
break;
case XPS_JOB_CANCELLED:
hr = E_FAIL;
break;
case XPS_JOB_FAILED:
hr = E_FAIL;
break;
default:
hr = E_UNEXPECTED;
break;
}
CloseHandle(completionEvent);
} else {
hr = HRESULT_FROM_WIN32(GetLastError());
}
m_pTextRenderer->DiscardResources();
m_pTextRenderer->DeleteTemporaryFiles();
m_pTextRenderer = nullptr;
}
