void touchmind::view::linkedge::impl::ArrowLinkEdgeView::CreateDeviceDependentResources(
touchmind::Context *pContext, ID2D1RenderTarget *pRenderTarget) {
if (GetLinkModel().expired()) {
return;
}
auto link = GetLinkModel().lock();
if (!link->IsValid()) {
return;
}
auto linkEdge = link->GetEdge(GetEdgeId());
auto node = link->GetNode(GetEdgeId());
if (linkEdge->IsRepaintRequired(GetRepaintCounter()) || m_pArrowGeometry == nullptr || m_pBrush == nullptr) {
ID2D1Factory *pD2DFactory = pContext->GetD2DFactory();
D2D1_POINT_2F point0 = link->GetEdgePoint(GetEdgeId());
std::vector<D2D1_POINT_2F> points;
view::GeometryBuilder::CalculateArrowPoints(point0, linkEdge->GetMarkerSize() + link->GetLineWidth(),
linkEdge->GetMarkerSize() + link->GetLineWidth(), linkEdge->GetAngle(),
node->GetAncestorPosition(), points);
m_pArrowGeometry = nullptr;
CHK_RES(m_pArrowGeometry,
view::GeometryBuilder::CreatePathGeometryFromPoints(pD2DFactory, points, &m_pArrowGeometry));
m_pBrush = nullptr;
CHK_RES(m_pBrush, pRenderTarget->CreateSolidColorBrush(link->GetLineColor(), D2D1::BrushProperties(), &m_pBrush));
SetRepaintCounter(linkEdge);
}
}
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::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::view::node::NodeFigureHelper::DrawPlate(const D2D1_RECT_F &rect, FLOAT r, ID2D1Factory *pD2DFactory,
ID2D1RenderTarget *pRenderTarget) {
if (rect.left != m_rect.left || rect.top != m_rect.top || rect.right != m_rect.right
|| rect.bottom != m_rect.bottom) {
m_pPlateOutlinePathGeometry = nullptr;
m_pPlateBrush = nullptr;
m_pTrianglePathGeometry = nullptr;
m_pTriangleBrush = nullptr;
}
if (m_pStrokeColorBrush == nullptr) {
CHK_RES(m_pStrokeColorBrush, pRenderTarget->CreateSolidColorBrush(m_strokeColor, &m_pStrokeColorBrush));
}
if (m_pPlateOutlinePathGeometry == nullptr) {
CHK_RES(m_pPlateOutlinePathGeometry, GeometryBuilder::CreateRoundedRectangleGeometry(
pD2DFactory, rect, r, false, true, &m_pPlateOutlinePathGeometry));
}
if (m_pPlateBrush == nullptr) {
std::vector<D2D1_GRADIENT_STOP> plateOutlineGradientStops;
plateOutlineGradientStops.push_back(D2D1::GradientStop(0.0f, m_plateStartColor));
plateOutlineGradientStops.push_back(D2D1::GradientStop(1.0f, m_plateEndColor));
CHK_RES(m_pPlateBrush, GeometryBuilder::CreateDiagonalGradientBrush(pRenderTarget, rect, plateOutlineGradientStops,
&m_pPlateBrush));
}
// Outer frame
if (m_pPlateBrush != nullptr && m_pStrokeColorBrush != nullptr) {
pRenderTarget->FillGeometry(m_pPlateOutlinePathGeometry, m_pPlateBrush);
pRenderTarget->DrawGeometry(m_pPlateOutlinePathGeometry, m_pStrokeColorBrush);
}
// Triangle
D2D1_RECT_F triangleRect
= D2D1::RectF(rect.right - m_triangleSize - m_triangleMergin, rect.bottom - m_triangleSize - m_triangleMergin,
rect.right - m_triangleMergin, rect.bottom - m_triangleMergin);
if (m_pTrianglePathGeometry == nullptr) {
CHK_RES(m_pTrianglePathGeometry,
GeometryBuilder::CreateTriangleMoverGeometry(pD2DFactory, triangleRect, TRIANGLE_VERTEX_BOTTOM_RIGHT,
&m_pTrianglePathGeometry));
}
if (m_pTriangleBrush == nullptr) {
std::vector<D2D1_GRADIENT_STOP> triangleGradientStops;
triangleGradientStops.push_back(D2D1::GradientStop(0.0f, D2D1::ColorF(0xd45500, 1.0f)));
triangleGradientStops.push_back(D2D1::GradientStop(1.0f, D2D1::ColorF(0xff9249, 1.0f)));
CHK_RES(m_pTriangleBrush, GeometryBuilder::CreateVerticalGradientBrush(pRenderTarget, triangleRect,
triangleGradientStops, &m_pTriangleBrush));
}
if (m_pTrianglePathGeometry != nullptr && m_pTriangleBrush != nullptr) {
pRenderTarget->FillGeometry(m_pTrianglePathGeometry, m_pTriangleBrush);
}
m_rect.left = rect.left;
m_rect.top = rect.top;
m_rect.right = rect.right;
m_rect.bottom = rect.bottom;
}
HRESULT touchmind::ribbon::handler::LineColorCommandHandler::_CreateUIImage(D2D1_COLOR_F color, IUIImage **ppUIImage) {
LOG_ENTER;
const static FLOAT width = 48;
const static FLOAT height = 48;
const static FLOAT drawHeight = 32.0f;
const static FLOAT strokeWidth = 5.0f;
HRESULT hr = S_OK;
if (m_pContext->GetWICImagingFactory() == nullptr || m_pContext->GetD2DFactory() == nullptr
|| m_pRibbonFramework->GetUIImageFromBitmap() == nullptr) {
return E_FAIL;
}
CComPtr<IWICBitmap> pWICBitmap = nullptr;
CHK_RES(pWICBitmap,
touchmind::util::BitmapHelper::CreateBitmap(m_pContext->GetWICImagingFactory(), static_cast<UINT>(width),
static_cast<UINT>(height), &pWICBitmap));
CComPtr<ID2D1RenderTarget> pRenderTarget = nullptr;
CHK_RES(pRenderTarget, touchmind::util::BitmapHelper::CreateBitmapRenderTarget(
pWICBitmap, m_pContext->GetD2DFactory(), &pRenderTarget));
model::CurvePoints curvePoints;
curvePoints.SetX(0, 0.0f);
curvePoints.SetY(0, 0.0f + strokeWidth / 2.0f);
curvePoints.SetX(1, width / 2.0f);
curvePoints.SetY(1, 0.0f);
curvePoints.SetX(2, width / 2.0f);
curvePoints.SetY(2, drawHeight - strokeWidth / 2.0f);
curvePoints.SetX(3, width);
curvePoints.SetY(3, drawHeight - strokeWidth / 2.0f);
CComPtr<ID2D1PathGeometry> pGeometry = nullptr;
CHK_RES(pGeometry,
view::GeometryBuilder::CreateCurvePathGeometry(m_pContext->GetD2DFactory(), curvePoints, &pGeometry));
pRenderTarget->BeginDraw();
CComPtr<ID2D1SolidColorBrush> pBrush = nullptr;
CHK_RES(pBrush, pRenderTarget->CreateSolidColorBrush(color, &pBrush));
pRenderTarget->DrawGeometry(pGeometry, pBrush, strokeWidth);
pRenderTarget->EndDraw();
HBITMAP hBitmap = nullptr;
touchmind::util::BitmapHelper::CreateBitmapFromWICBitmapSource(pWICBitmap, &hBitmap);
hr = m_pRibbonFramework->GetUIImageFromBitmap()->CreateImage(hBitmap, UI_OWNERSHIP_TRANSFER, ppUIImage);
LOG_LEAVE;
return hr;
}
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::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::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));
}
/*
Get items from current auc page
IN:
out - collection reference
OUT:
out - enumerated items
RETURN:
Error code
*/
DWORD CAuction::GetItems( vecAHItems &out )
{
AHList list;
DWORD dwBaseOffset = 0;
dwBaseOffset = CProcess::Instance().Core.Read<DWORD>(AUC_BASE);
dwBaseOffset = CProcess::Instance().Core.Read<DWORD>(dwBaseOffset);
CHK_RES(CProcess::Instance().Core.Read(dwBaseOffset, sizeof(list), &list));
m_Items.clear();
for(DWORD i=0; i< list.count; i++)
{
AHUIHoverHeader dps;
char name[64] = {0};
char stats[1024] = {0};
char sockets[3][96] = {0};
//Get some info from UI elements
UIComponent* pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_NAME_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(name), name);
pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_DPS_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(dps), &dps);
pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_ATTRIBS_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(stats), stats);
pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_SOCKET_0_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(sockets[0]), sockets[0]);
pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_SOCKET_1_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(sockets[1]), sockets[1]);
pElement = CUIManager::Instance().GetUIElementByHash(UI_SELECTED_ITEM_SOCKET_2_HASH);
if(pElement)
CProcess::Instance().Core.Read(pElement->text_ptr, sizeof(sockets[2]), sockets[2]);
//Add item to collection
m_Items.push_back(CAHItem(list.addr_items + i*sizeof(AHItemRaw), name, dps, stats, sockets));
}
out = m_Items;
return ERROR_SUCCESS;
}
touchmind::ribbon::RibbonFramework::RibbonFramework() :
m_pFramework(nullptr),
m_pRibbonCommandHandler(new touchmind::ribbon::RibbonCommandHandler()),
m_resourceName(L"APPLICATION_RIBBON"),
m_hWnd(0),
m_pifbFactory(nullptr)
{
CHK_RES(m_pRibbonCommandHandler, S_OK);
}
/*
Inject Dll into process
RETURN:
Error code
*/
DWORD CMemDll::Inject()
{
HANDLE hThread = NULL;
HANDLE hFile = INVALID_HANDLE_VALUE;
DWORD dwBytesWritten = 0;
LPVOID pCode = NULL;
DWORD* pfnThreadRtn = NULL;
char DllName[255];
if(!CMemCore::Instance().m_hProcess)
return ERROR_INVALID_HANDLE;
//Already loaded
if(GetModuleAddress(GetProcessId(CMemCore::Instance().m_hProcess), TEXT(DLL_NAME)) !=0 )
return ERROR_SUCCESS;
hFile = CreateFileA(DLL_NAME, GENERIC_READ, NULL, NULL, OPEN_EXISTING, NULL, NULL);
if(hFile == INVALID_HANDLE_VALUE)
return GetLastError();
else
CloseHandle(hFile);
GetFullPathNameA(DLL_NAME, sizeof(DllName), DllName, NULL);
CHK_RES(CMemCore::Instance().Allocate(0x200, pCode));
if(!WriteProcessMemory(CMemCore::Instance(). m_hProcess, pCode, (LPCVOID)DllName, strlen(DllName)+1, &dwBytesWritten))
{
CMemCore::Instance().Free(pCode);
return GetLastError();
}
pfnThreadRtn = (DWORD*)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "LoadLibraryA");
if(pfnThreadRtn==NULL)
{
CMemCore::Instance().Free(pCode);
return GetLastError();
}
hThread = CreateRemoteThread(CMemCore::Instance().m_hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pfnThreadRtn, pCode, 0, NULL);
if(hThread == NULL)
{
CMemCore::Instance().Free(pCode);
return GetLastError();
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CMemCore::Instance().Free(pCode);
return ERROR_SUCCESS;
}
void touchmind::print::XPSPrint::Initialize()
{
CHK_RES(m_pXpsFactory,
CoCreateInstance(
__uuidof(XpsOMObjectFactory),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IXpsOMObjectFactory),
reinterpret_cast<LPVOID*>(&m_pXpsFactory)
));
}
HRESULT touchmind::view::node::NodeViewManager::CreateSharedDeviceResources(touchmind::Context *pContext,
ID2D1RenderTarget *pRenderTarget) {
UNREFERENCED_PARAMETER(pContext);
if (m_pNodeShadowBrush == nullptr || m_pSelectedNodeShadowBrush1 == nullptr
|| m_pSelectedNodeShadowBrush2 == nullptr) {
m_pNodeShadowBrush = nullptr;
CHK_RES(m_pNodeShadowBrush,
pRenderTarget->CreateSolidColorBrush(m_pConfiguration->GetDefaultShadowColor(), &m_pNodeShadowBrush));
m_pSelectedNodeShadowBrush1 = nullptr;
CHK_RES(m_pSelectedNodeShadowBrush1,
pRenderTarget->CreateSolidColorBrush(m_pConfiguration->GetDefaultSelectedColor1(),
&m_pSelectedNodeShadowBrush1));
m_pSelectedNodeShadowBrush2 = nullptr;
CHK_RES(m_pSelectedNodeShadowBrush2,
pRenderTarget->CreateSolidColorBrush(m_pConfiguration->GetDefaultSelectedColor2(),
&m_pSelectedNodeShadowBrush2));
m_pEditControlManager->InitializeDeviceResources(pRenderTarget);
}
return S_OK;
}
IFACEMETHODIMP touchmind::ribbon::handler::LineColorCommandHandler::UpdateProperty(
UINT cmdID, REFPROPERTYKEY key, const PROPVARIANT *pPropvarCurrentValue, PROPVARIANT *pPropvarNewValue) {
LOG_ENTER;
UNREFERENCED_PARAMETER(cmdID);
UNREFERENCED_PARAMETER(key);
UNREFERENCED_PARAMETER(pPropvarCurrentValue);
UNREFERENCED_PARAMETER(pPropvarNewValue);
HRESULT hr = E_FAIL;
if (key == UI_PKEY_Enabled) {
BOOL enabled = m_pRibbonRequestDispatcher->UpdateProperty_IsLineColorChangeable() ? TRUE : FALSE;
m_pRibbonFramework->GetFramework()->InvalidateUICommand(cmdLineColor, UI_INVALIDATIONS_PROPERTY,
&UI_PKEY_ColorType);
m_pRibbonFramework->GetFramework()->InvalidateUICommand(cmdLineColor, UI_INVALIDATIONS_PROPERTY, &UI_PKEY_Color);
m_pRibbonFramework->GetFramework()->InvalidateUICommand(cmdLineColor, UI_INVALIDATIONS_PROPERTY,
&UI_PKEY_LargeImage);
hr = UIInitPropertyFromBoolean(UI_PKEY_BooleanValue, enabled, pPropvarNewValue);
} else if (key == UI_PKEY_ColorType) {
hr = UIInitPropertyFromUInt32(key, UI_SWATCHCOLORTYPE_RGB, pPropvarNewValue);
} else if (key == UI_PKEY_Color) {
if (pPropvarCurrentValue == nullptr) {
hr = UIInitPropertyFromUInt32(key, RGB(0, 0, 0), pPropvarNewValue);
} else {
D2D1_COLOR_F colorF = m_pRibbonRequestDispatcher->UpdateProperty_GetLineColor();
COLORREF colorref = touchmind::util::ColorUtil::ToColorref(colorF);
hr = UIInitPropertyFromUInt32(key, colorref, pPropvarNewValue);
}
} else if (key == UI_PKEY_LargeImage) {
if (pPropvarCurrentValue != nullptr) {
CComPtr<IUIImage> uiImage = nullptr;
D2D1_COLOR_F colorF = m_pRibbonRequestDispatcher->UpdateProperty_GetLineColor();
hr = _CreateUIImage(colorF, &uiImage);
CHK_RES(uiImage, S_OK);
if (SUCCEEDED(hr)) {
hr = UIInitPropertyFromImage(key, uiImage, pPropvarNewValue);
}
}
}
LOG_LEAVE;
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));
}
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()));
}
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::view::path::impl::DefaultPathView::_CreateDeviceDependentResources(
touchmind::Context *pContext,
ID2D1RenderTarget *pRenderTarget,
std::shared_ptr<touchmind::model::node::NodeModel> node)
{
std::shared_ptr<model::node::NodeModel> parent = node->GetParent();
ID2D1Factory *pD2DFactory = pContext->GetD2DFactory();
PATH_DIRECTION pathDirection;
touchmind::NODE_SIDE nodePosition = node->GetAncestorPosition();
switch (nodePosition) {
case touchmind::NODE_SIDE_RIGHT:
pathDirection = PATH_DIRECTION_RIGHT;
break;
case touchmind::NODE_SIDE_LEFT:
pathDirection = PATH_DIRECTION_LEFT;
break;
case touchmind::NODE_SIDE_UNDEFINED:
pathDirection = PATH_DIRECTION_AUTO;
break;
default:
pathDirection = PATH_DIRECTION_AUTO;
}
touchmind::model::CurvePoints curvePoints;
view::GeometryBuilder::CalculatePath(
parent,
node,
pathDirection,
GetConfiguration()->GetNodeJustification(),
GetConfiguration()->GetLevelSeparation(),
curvePoints);
m_pathGeometry = nullptr;
CHK_RES(
m_pathGeometry,
view::GeometryBuilder::CreateCurvePathGeometry(pD2DFactory, curvePoints, &m_pathGeometry));
curvePoints.GetBounds(m_bounds);
m_pathBrush = nullptr;
CHK_RES(m_pathBrush,
pRenderTarget->CreateSolidColorBrush(
node->GetPathModel()->GetColor(),
D2D1::BrushProperties(),
&m_pathBrush));
// style
m_pathStyle = nullptr;
switch (node->GetPathModel()->GetStyle()) {
case LINE_STYLE_DASHED:
CHK_RES(m_pathStyle,
pD2DFactory->CreateStrokeStyle(D2D1::StrokeStyleProperties(
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_LINE_JOIN_MITER,
node->GetPathModel()->GetWidthAsValue(),
D2D1_DASH_STYLE_DASH,
0.0f),
nullptr, 0,
&m_pathStyle));
break;
case LINE_STYLE_DOTTED:
CHK_RES(m_pathStyle,
pD2DFactory->CreateStrokeStyle(D2D1::StrokeStyleProperties(
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_LINE_JOIN_MITER,
node->GetPathModel()->GetWidthAsValue(),
D2D1_DASH_STYLE_DOT,
0.0f),
nullptr, 0,
&m_pathStyle));
break;
case LINE_STYLE_SOLID:
default:
CHK_RES(m_pathStyle,
pD2DFactory->CreateStrokeStyle(D2D1::StrokeStyleProperties(
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_CAP_STYLE_ROUND,
D2D1_LINE_JOIN_MITER,
node->GetPathModel()->GetWidthAsValue(),
D2D1_DASH_STYLE_SOLID,
0.0f),
nullptr, 0,
&m_pathStyle));
break;
}
}
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);
}
