IFACEMETHODIMP CanvasSwapChain::PresentWithSyncInterval(int32_t syncInterval) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); auto& resource = GetResource(); DXGI_PRESENT_PARAMETERS presentParameters = { 0 }; ThrowIfFailed(resource->Present1(syncInterval, 0, &presentParameters)); }); }
IFACEMETHODIMP CanvasSwapChain::put_Rotation(CanvasSwapChainRotation value) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); auto& resource = GetResource(); ThrowIfFailed(resource->SetRotation(ToDxgiRotation(value))); }); }
IFACEMETHODIMP CanvasSwapChain::get_Device(ICanvasDevice** value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto& device = m_device.EnsureNotClosed(); ThrowIfFailed(device.CopyTo(value)); }); }
IFACEMETHODIMP CanvasSwapChain::get_Format(DirectXPixelFormat* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); *value = static_cast<DirectXPixelFormat>(desc.Format); }); }
IFACEMETHODIMP CanvasSwapChain::get_BufferCount(int32_t* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); *value = desc.BufferCount; }); }
IFACEMETHODIMP CanvasSwapChain::get_AlphaMode(CanvasAlphaMode* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); *value = FromDxgiAlphaMode(desc.AlphaMode); }); }
virtual IFACEMETHODIMP get_Dpi(float* value) { return ExceptionBoundary( [&] { EnsureValidResource(); float pixelsPerDip; ThrowIfFailed(m_dwriteTextRenderer->GetPixelsPerDip(nullptr, &pixelsPerDip)); *value = pixelsPerDip * DEFAULT_DPI; }); }
virtual IFACEMETHODIMP get_PixelSnappingDisabled(boolean* value) { return ExceptionBoundary( [&] { EnsureValidResource(); BOOL isPixelSnappingDisabled; ThrowIfFailed(m_dwriteTextRenderer->IsPixelSnappingDisabled(nullptr, &isPixelSnappingDisabled)); *value = !!isPixelSnappingDisabled; }); }
IFACEMETHODIMP CanvasSwapChain::put_TransformMatrix(Matrix3x2 value) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); // Insert additional scaling to account for display DPI. auto swapChain = As<IDXGISwapChain2>(GetResource()); SetMatrixInternal(lock, swapChain, ReinterpretAs<DXGI_MATRIX_3X2_F*>(&value)); }); }
virtual IFACEMETHODIMP get_Transform(Matrix3x2* value) { return ExceptionBoundary( [&] { EnsureValidResource(); DWRITE_MATRIX transform; ThrowIfFailed(m_dwriteTextRenderer->GetCurrentTransform(nullptr, &transform)); *value = *(ReinterpretAs<Matrix3x2*>(&transform)); }); }
IFACEMETHODIMP CanvasSwapChain::get_SizeInPixels(BitmapSize* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); *value = BitmapSize{ desc.Width, desc.Height }; }); }
IFACEMETHODIMP DrawGlyphRun( Vector2 baselineOrigin, ICanvasFontFace* fontFace, float fontSize, uint32_t glyphCount, CanvasGlyph* glyphs, boolean isSideways, uint32_t bidiLevel, IInspectable* brush, CanvasTextMeasuringMode measuringMode, HSTRING locale, HSTRING text, uint32_t clusterMapIndicesCount, int* clusterMapIndices, unsigned int characterIndex, CanvasGlyphOrientation glyphOrientation) override { return ExceptionBoundary( [&] { EnsureValidResource(); auto deviceContextLease = As<ICanvasDeviceInternal>(m_device)->GetResourceCreationDeviceContext(); DrawGlyphRunHelper helper( fontFace, fontSize, glyphCount, glyphs, isSideways, bidiLevel, brush, measuringMode, locale, text, clusterMapIndicesCount, clusterMapIndices, characterIndex, deviceContextLease.Get()); ThrowIfFailed(m_dwriteTextRenderer->DrawGlyphRun( nullptr, baselineOrigin.X, baselineOrigin.Y, ToDWriteGlyphOrientationAngle(glyphOrientation), helper.MeasuringMode, &helper.DWriteGlyphRun, &helper.DWriteGlyphRunDescription, helper.ClientDrawingEffect.Get())); }); }
HRESULT __declspec(nothrow) CanvasTextFormat::PropertyGet(T* value, ST const& shadowValue, FN realizedGetter) { return ExceptionBoundary( [&] { CheckInPointer(value); ThrowIfClosed(); if (m_format) SetFrom(value, realizedGetter()); else SetFrom(value, shadowValue); }); }
IFACEMETHODIMP CanvasSwapChain::get_Size(Size* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); *value = Size{ PixelsToDips(desc.Width, m_dpi), PixelsToDips(desc.Height, m_dpi) }; }); }
IFACEMETHODIMP CanvasTextFormatFactory::GetOrCreate( IUnknown* resource, IInspectable** wrapper) { return ExceptionBoundary( [&] { ComPtr<IDWriteTextFormat> dwriteTextFormat; ThrowIfFailed(resource->QueryInterface(dwriteTextFormat.GetAddressOf())); auto newCanvasTextFormat = Make<CanvasTextFormat>(dwriteTextFormat.Get()); CheckMakeResult(newCanvasTextFormat); ThrowIfFailed(newCanvasTextFormat.CopyTo(wrapper)); }); }
IFACEMETHODIMP CanvasSwapChain::put_SourceSize(Size value) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); uint32_t width = SizeDipsToPixels(value.Width, m_dpi); uint32_t height = SizeDipsToPixels(value.Height, m_dpi); auto swapChain = As<IDXGISwapChain2>(GetResource()); ThrowIfFailed(swapChain->SetSourceSize(width, height)); }); }
IFACEMETHODIMP AddStreamSink( DWORD /*streamSinkIdentifier*/, _In_ IMFMediaType * /*mediaType*/, _COM_Outptr_ IMFStreamSink **streamSink ) { return ExceptionBoundary([this, streamSink]() { _VerifyNotShutdown(); CHKNULL(streamSink); *streamSink = nullptr; CHK(MF_E_STREAMSINKS_FIXED); }); }
IFACEMETHODIMP CanvasCommandListFactory::Create( ICanvasResourceCreator* resourceCreator, ICanvasCommandList** commandList) { return ExceptionBoundary( [&] { CheckInPointer(resourceCreator); ComPtr<ICanvasDevice> device; ThrowIfFailed(resourceCreator->get_Device(&device)); auto cl = CanvasCommandList::CreateNew(device.Get()); ThrowIfFailed(cl.CopyTo(commandList)); }); }
IFACEMETHODIMP CanvasSwapChain::get_TransformMatrix(Matrix3x2* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto swapChain = As<IDXGISwapChain2>(GetResource()); DXGI_MATRIX_3X2_F matrix = GetMatrixInternal(lock, swapChain); *value = *ReinterpretAs<Matrix3x2*>(&matrix); }); }
IFACEMETHODIMP CanvasSwapChain::get_Rotation(CanvasSwapChainRotation* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto& resource = GetResource(); DXGI_MODE_ROTATION rotation; ThrowIfFailed(resource->GetRotation(&rotation)); *value = FromDxgiRotation(rotation); }); }
IFACEMETHODIMP ImageControlMixIn::ArrangeOverride( Size finalSize, Size* returnValue) { return ExceptionBoundary( [&] { // // Call Arrange on our children (in this case just the image control). // ThrowIfFailed(As<IUIElement>(m_imageControl)->Arrange(Rect{ 0, 0, finalSize.Width, finalSize.Height })); // // Reply that we're happy to accept the size chosen by the layout engine. // *returnValue = finalSize; }); }
IFACEMETHODIMP CanvasTextFormat::put_Options(CanvasDrawTextOptions value) { return ExceptionBoundary( [&] { ThrowIfClosed(); auto validOptions = CanvasDrawTextOptions::NoSnap | CanvasDrawTextOptions::Clip | CanvasDrawTextOptions::EnableColorFont; if ((value & ~validOptions) != CanvasDrawTextOptions::Default) ThrowHR(E_INVALIDARG); m_drawTextOptions = value; }); }
IFACEMETHODIMP CanvasSwapChain::ResizeBuffersWithWidthAndHeight( float newWidth, float newHeight) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); auto desc = GetSwapChainDesc(lock); ResizeBuffersImpl( lock, newWidth, newHeight, m_dpi, static_cast<DirectXPixelFormat>(desc.Format), desc.BufferCount); }); }
IFACEMETHODIMP CanvasSwapChain::get_SourceSize(Size* value) { return ExceptionBoundary( [&] { CheckInPointer(value); auto lock = GetResourceLock(); auto swapChain = As<IDXGISwapChain2>(GetResource()); uint32_t width; uint32_t height; ThrowIfFailed(swapChain->GetSourceSize(&width, &height)); *value = Size{ PixelsToDips(width, m_dpi), PixelsToDips(height, m_dpi) }; }); }
IFACEMETHODIMP DrawUnderline( Vector2 baselineOrigin, float width, float thickness, float offset, float runHeight, CanvasTextDirection textDirection, IInspectable* brush, CanvasTextMeasuringMode measuringMode, HSTRING locale, CanvasGlyphOrientation glyphOrientation) { return ExceptionBoundary( [&] { EnsureValidResource(); DWRITE_UNDERLINE underline{}; underline.width = width; underline.thickness = thickness; underline.offset = offset; underline.runHeight = runHeight; auto textDirectionLookup = DWriteToCanvasTextDirection::Lookup(textDirection); underline.flowDirection = textDirectionLookup->FlowDirection; underline.readingDirection = textDirectionLookup->ReadingDirection; underline.measuringMode = ToDWriteMeasuringMode(measuringMode); auto deviceContextLease = As<ICanvasDeviceInternal>(m_device)->GetResourceCreationDeviceContext(); if (locale) underline.localeName = WindowsGetStringRawBuffer(locale, nullptr); ThrowIfFailed(m_dwriteTextRenderer->DrawUnderline( nullptr, baselineOrigin.X, baselineOrigin.Y, ToDWriteGlyphOrientationAngle(glyphOrientation), &underline, DrawGlyphRunHelper::GetClientDrawingEffect(brush, deviceContextLease.Get()).Get())); }); }
IFACEMETHODIMP InternalDWriteTextRenderer::DrawInlineObject( void*, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_GLYPH_ORIENTATION_ANGLE orientationAngle, IDWriteInlineObject* inlineObject, BOOL isSideways, BOOL isRightToLeft, IUnknown* brush) { return ExceptionBoundary( [&] { auto canvasInlineObject = GetCanvasInlineObjectFromDWriteInlineObject(inlineObject, false); auto customDrawingObjectInspectable = GetCustomDrawingObjectInspectable(m_device.Get(), brush); if (canvasInlineObject) { ThrowIfFailed(m_textRenderer->DrawInlineObject( Vector2{ baselineOriginX, baselineOriginY }, canvasInlineObject.Get(), !!isSideways, !!isRightToLeft, customDrawingObjectInspectable.Get(), ToCanvasGlyphOrientation(orientationAngle))); } else { // // Inline objects may be implemented by the app. Or, they may be implemented by // DWrite, an important example of which being an ellipsis trimming sign. // We've reached this spot if it's the latter. // // In this case, we don't call into the app's custom renderer callback since // it doesn't know anything about the DWrite-implemented inline object. // We forward the Draw call along. // ThrowIfFailed(inlineObject->Draw(nullptr, this, baselineOriginX, baselineOriginY, isSideways, isRightToLeft, brush)); } }); }
IFACEMETHODIMP CanvasSwapChain::ResizeBuffersWithAllOptions( float newWidth, float newHeight, float newDpi, DirectXPixelFormat newFormat, int32_t bufferCount) { return ExceptionBoundary( [&] { auto lock = GetResourceLock(); ResizeBuffersImpl( lock, newWidth, newHeight, newDpi, newFormat, bufferCount); }); }
IFACEMETHODIMP SetPresentationClock(_In_ IMFPresentationClock *clock) { return ExceptionBoundary([this, clock]() { auto lock = _lock.LockExclusive(); _VerifyNotShutdown(); if (_clock != nullptr) { CHK(_clock->RemoveClockStateSink(this)); _clock = nullptr; } if (clock != nullptr) { CHK(clock->AddClockStateSink(this)); _clock = clock; } }); }
IFACEMETHODIMP GetStreamSinkByIndex(DWORD index, _COM_Outptr_ IMFStreamSink **streamSink) { return ExceptionBoundary([this, index, streamSink]() { auto lock = _lock.LockExclusive(); CHKNULL(streamSink); *streamSink = nullptr; _VerifyNotShutdown(); switch (index) { case 0: if (_audioStreamSink != nullptr) { CHK(_audioStreamSink.CopyTo(streamSink)); } else { CHK(_videoStreamSink.CopyTo(streamSink)); } break; case 1: if ((_audioStreamSink != nullptr) && (_videoStreamSink != nullptr)) { CHK(_videoStreamSink.CopyTo(streamSink)); } else { CHK(E_INVALIDARG); } break; default: CHK(E_INVALIDARG); } }); }
IFACEMETHODIMP ImageControlMixIn::MeasureOverride( Size availableSize, Size* returnValue) { UNREFERENCED_PARAMETER(availableSize); return ExceptionBoundary( [&] { Size zeroSize{ 0, 0 }; // // Call Measure on our children (in this case just the image control). // ThrowIfFailed(As<IUIElement>(m_imageControl)->Measure(zeroSize)); // // Reply that we're happy to be sized however the layout engine wants to size us. // *returnValue = zeroSize; }); }