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); }