Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Core / CSharp / System / Windows / Media / Imaging / RenderTargetBitmap.cs / 1 / RenderTargetBitmap.cs
//------------------------------------------------------------------------------
// Microsoft Avalon
// Copyright (c) Microsoft Corporation. All Rights Reserved.
//
// File: BitmapImage.cs
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;
using MS.Internal;
using MS.Win32.PresentationCore;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Windows.Media;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Imaging
{
#region RenderTargetBitmap
///
/// RenderTargetBitmap provides caching functionality for a BitmapSource.
///
public sealed class RenderTargetBitmap : System.Windows.Media.Imaging.BitmapSource
{
///
/// RenderTargetBitmap - used in conjuction with BitmapVisualManager
///
/// The width of the Bitmap
/// The height of the Bitmap
/// Horizontal DPI of the Bitmap
/// Vertical DPI of the Bitmap
/// Format of the Bitmap.
///
/// Critical - access critical resources
/// PublicOK - All inputs verified
///
[SecurityCritical]
public RenderTargetBitmap(
int pixelWidth,
int pixelHeight,
double dpiX,
double dpiY,
PixelFormat pixelFormat
) : base(true)
{
if (pixelFormat.Format == PixelFormatEnum.Default)
{
pixelFormat = PixelFormats.Pbgra32;
}
else if (pixelFormat.Format != PixelFormatEnum.Pbgra32)
{
throw new System.ArgumentException(
SR.Get(SRID.Effect_PixelFormat, pixelFormat),
"pixelFormat"
);
}
if (pixelWidth <= 0)
{
throw new ArgumentOutOfRangeException("pixelWidth", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (pixelHeight <= 0)
{
throw new ArgumentOutOfRangeException("pixelHeight", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (dpiX < DoubleUtil.DBL_EPSILON)
{
dpiX = 96.0;
}
if (dpiY < DoubleUtil.DBL_EPSILON)
{
dpiY = 96.0;
}
_bitmapInit.BeginInit();
_pixelWidth = pixelWidth;
_pixelHeight = pixelHeight;
_dpiX = dpiX;
_dpiY = dpiY;
_format = pixelFormat;
_bitmapInit.EndInit();
FinalizeCreation();
}
///
/// Internal ctor
///
internal RenderTargetBitmap() :
base(true)
{
}
///
/// Implementation of Freezable.CreateInstanceCore .
///
/// The new Freezable.
protected override Freezable CreateInstanceCore()
{
return new RenderTargetBitmap();
}
///
/// Common Copy method used to implement CloneCore(), CloneCurrentValueCore(),
/// GetAsFrozenCore(), and GetCurrentValueAsFrozenCore()
///
///
/// Critical - access unmanaged resource
/// TreatAsSafe - making a clone which is safe
///
[SecurityCritical, SecurityTreatAsSafe]
private void CopyCommon(RenderTargetBitmap sourceBitmap)
{
_bitmapInit.BeginInit();
_pixelWidth = sourceBitmap._pixelWidth;
_pixelHeight = sourceBitmap._pixelHeight;
_dpiX = sourceBitmap._dpiX;
_dpiY = sourceBitmap._dpiY;
_format = sourceBitmap._format;
//
// In order to make a deep clone we need to
// create a new bitmap with the contents of the
// existing bitmap and then create a render target
// from the new bitmap.
//
using (FactoryMaker myFactory = new FactoryMaker())
{
BitmapSourceSafeMILHandle newBitmapHandle = null;
IntPtr pIMILBitmap = IntPtr.Zero;
SafeMILHandle milBitmapHandle = null;
// Create an IWICBitmap
HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateBitmapFromSource(
myFactory.ImagingFactoryPtr,
WicSourceHandle,
WICBitmapCreateCacheOptions.WICBitmapCacheOnLoad,
out newBitmapHandle));
lock (_syncObject)
{
WicSourceHandle = newBitmapHandle;
}
Guid guidMILBs = MILGuidData.IID_IMILBitmapSource;
// QI for IMILBitmapSource
HRESULT.Check(UnsafeNativeMethods.MILUnknown.QueryInterface(
newBitmapHandle,
ref guidMILBs,
out pIMILBitmap));
// Creating this will automatically do the garbage collection (and release)
milBitmapHandle = new SafeMILHandle(pIMILBitmap, 0);
// Now create a Render target from that Bitmap
HRESULT.Check(UnsafeNativeMethods.MILFactory2.CreateBitmapRenderTargetForBitmap(
myFactory.FactoryPtr,
pIMILBitmap,
out _renderTargetBitmap));
}
_bitmapInit.EndInit();
}
///
/// Implementation of Freezable.CloneCore .
///
protected override void CloneCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.CloneCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.CloneCurrentValueCore .
///
protected override void CloneCurrentValueCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.CloneCurrentValueCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.GetAsFrozenCore .
///
protected override void GetAsFrozenCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.GetAsFrozenCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.GetCurrentValueAsFrozenCore .
///
protected override void GetCurrentValueAsFrozenCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.GetCurrentValueAsFrozenCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Renders the specified Visual tree to the BitmapRenderTarget.
///
public void Render(Visual visual)
{
BitmapVisualManager bmv = new BitmapVisualManager(this);
bmv.Render(visual); // Render indirectly calls RenderTargetContentsChanged();
}
///
/// Renders the specified Visual tree to the BitmapRenderTarget
/// This renders the visual without transform, clip, offset and
/// guidelines applied to it.
///
internal void RenderForBitmapEffect(Visual visual, Matrix worldTransform, Rect windowClip)
{
// first clear the render target
Clear();
BitmapVisualManager bmv = new BitmapVisualManager(this);
bmv.Render(visual, worldTransform, windowClip, true); // Render indirectly calls RenderTargetContentsChanged();
}
///
/// Clears the render target and sets every pixel to black transparent
///
///
/// Critical - access unmanaged resource
/// PublicOk - Clear is safe (no inputs)
///
[SecurityCritical]
public void Clear()
{
HRESULT.Check(MILRenderTargetBitmap.Clear(_renderTargetBitmap));
RenderTargetContentsChanged();
}
///
/// Get the MIL RenderTarget
///
///
/// Critical - returns unmanaged resource
///
internal SafeMILHandle MILRenderTarget
{
[SecurityCritical]
get
{
return _renderTargetBitmap;
}
}
///
/// Notify that the contents of the render target have changed
///
///
/// Critical - access critical resource _convertedDUCEMILPtr
/// TreatAsSafe - Critical data is used internally and not exposed
///
[SecurityCritical, SecurityTreatAsSafe]
internal void RenderTargetContentsChanged()
{
// If the render target has changed, we need to update the UCE resource. We ensure
// this happens by throwing away our reference to the previous DUCE bitmap source
// and forcing the creation of a new one.
_isSourceCached = false;
if (_convertedDUCEMILPtr != null)
{
_convertedDUCEMILPtr.Close();
_convertedDUCEMILPtr = null;
}
// Register for update in the next render pass
RegisterForAsyncUpdateResource();
FireChanged();
}
///
/// Create the unmanaged resources
///
///
/// Critical - creates critical resource
///
[SecurityCritical]
internal override void FinalizeCreation()
{
try
{
using (FactoryMaker myFactory = new FactoryMaker())
{
SafeMILHandle renderTargetBitmap = null;
HRESULT.Check(UnsafeNativeMethods.MILFactory2.CreateBitmapRenderTarget(
myFactory.FactoryPtr,
(uint)_pixelWidth,
(uint)_pixelHeight,
_format.Format,
(float)_dpiX,
(float)_dpiY,
MILRTInitializationFlags.MIL_RT_INITIALIZE_DEFAULT,
out renderTargetBitmap));
Debug.Assert(renderTargetBitmap != null && !renderTargetBitmap.IsInvalid);
BitmapSourceSafeMILHandle bitmapSource = null;
HRESULT.Check(MILRenderTargetBitmap.GetBitmap(
renderTargetBitmap,
out bitmapSource));
Debug.Assert(bitmapSource != null && !bitmapSource.IsInvalid);
lock (_syncObject)
{
_renderTargetBitmap = renderTargetBitmap;
WicSourceHandle = bitmapSource;
// For the purpose of rendering a RenderTargetBitmap, we always treat it as if it's
// not cached. This is to ensure we never render and write to the same bitmap source
// by the UCE thread and managed thread.
_isSourceCached = false;
}
}
CreationCompleted = true;
UpdateCachedSettings();
}
catch
{
_bitmapInit.Reset();
throw;
}
}
///
/// Critical - unmanaged resource - not safe for handing out
///
[SecurityCritical]
private SafeMILHandle /* IMILRenderTargetBitmap */ _renderTargetBitmap;
}
#endregion // RenderTargetBitmap
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
// Microsoft Avalon
// Copyright (c) Microsoft Corporation. All Rights Reserved.
//
// File: BitmapImage.cs
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;
using MS.Internal;
using MS.Win32.PresentationCore;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Windows.Media;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Imaging
{
#region RenderTargetBitmap
///
/// RenderTargetBitmap provides caching functionality for a BitmapSource.
///
public sealed class RenderTargetBitmap : System.Windows.Media.Imaging.BitmapSource
{
///
/// RenderTargetBitmap - used in conjuction with BitmapVisualManager
///
/// The width of the Bitmap
/// The height of the Bitmap
/// Horizontal DPI of the Bitmap
/// Vertical DPI of the Bitmap
/// Format of the Bitmap.
///
/// Critical - access critical resources
/// PublicOK - All inputs verified
///
[SecurityCritical]
public RenderTargetBitmap(
int pixelWidth,
int pixelHeight,
double dpiX,
double dpiY,
PixelFormat pixelFormat
) : base(true)
{
if (pixelFormat.Format == PixelFormatEnum.Default)
{
pixelFormat = PixelFormats.Pbgra32;
}
else if (pixelFormat.Format != PixelFormatEnum.Pbgra32)
{
throw new System.ArgumentException(
SR.Get(SRID.Effect_PixelFormat, pixelFormat),
"pixelFormat"
);
}
if (pixelWidth <= 0)
{
throw new ArgumentOutOfRangeException("pixelWidth", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (pixelHeight <= 0)
{
throw new ArgumentOutOfRangeException("pixelHeight", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (dpiX < DoubleUtil.DBL_EPSILON)
{
dpiX = 96.0;
}
if (dpiY < DoubleUtil.DBL_EPSILON)
{
dpiY = 96.0;
}
_bitmapInit.BeginInit();
_pixelWidth = pixelWidth;
_pixelHeight = pixelHeight;
_dpiX = dpiX;
_dpiY = dpiY;
_format = pixelFormat;
_bitmapInit.EndInit();
FinalizeCreation();
}
///
/// Internal ctor
///
internal RenderTargetBitmap() :
base(true)
{
}
///
/// Implementation of Freezable.CreateInstanceCore .
///
/// The new Freezable.
protected override Freezable CreateInstanceCore()
{
return new RenderTargetBitmap();
}
///
/// Common Copy method used to implement CloneCore(), CloneCurrentValueCore(),
/// GetAsFrozenCore(), and GetCurrentValueAsFrozenCore()
///
///
/// Critical - access unmanaged resource
/// TreatAsSafe - making a clone which is safe
///
[SecurityCritical, SecurityTreatAsSafe]
private void CopyCommon(RenderTargetBitmap sourceBitmap)
{
_bitmapInit.BeginInit();
_pixelWidth = sourceBitmap._pixelWidth;
_pixelHeight = sourceBitmap._pixelHeight;
_dpiX = sourceBitmap._dpiX;
_dpiY = sourceBitmap._dpiY;
_format = sourceBitmap._format;
//
// In order to make a deep clone we need to
// create a new bitmap with the contents of the
// existing bitmap and then create a render target
// from the new bitmap.
//
using (FactoryMaker myFactory = new FactoryMaker())
{
BitmapSourceSafeMILHandle newBitmapHandle = null;
IntPtr pIMILBitmap = IntPtr.Zero;
SafeMILHandle milBitmapHandle = null;
// Create an IWICBitmap
HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateBitmapFromSource(
myFactory.ImagingFactoryPtr,
WicSourceHandle,
WICBitmapCreateCacheOptions.WICBitmapCacheOnLoad,
out newBitmapHandle));
lock (_syncObject)
{
WicSourceHandle = newBitmapHandle;
}
Guid guidMILBs = MILGuidData.IID_IMILBitmapSource;
// QI for IMILBitmapSource
HRESULT.Check(UnsafeNativeMethods.MILUnknown.QueryInterface(
newBitmapHandle,
ref guidMILBs,
out pIMILBitmap));
// Creating this will automatically do the garbage collection (and release)
milBitmapHandle = new SafeMILHandle(pIMILBitmap, 0);
// Now create a Render target from that Bitmap
HRESULT.Check(UnsafeNativeMethods.MILFactory2.CreateBitmapRenderTargetForBitmap(
myFactory.FactoryPtr,
pIMILBitmap,
out _renderTargetBitmap));
}
_bitmapInit.EndInit();
}
///
/// Implementation of Freezable.CloneCore .
///
protected override void CloneCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.CloneCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.CloneCurrentValueCore .
///
protected override void CloneCurrentValueCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.CloneCurrentValueCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.GetAsFrozenCore .
///
protected override void GetAsFrozenCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.GetAsFrozenCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Implementation of Freezable.GetCurrentValueAsFrozenCore .
///
protected override void GetCurrentValueAsFrozenCore(Freezable sourceFreezable)
{
RenderTargetBitmap sourceBitmap = (RenderTargetBitmap)sourceFreezable;
base.GetCurrentValueAsFrozenCore(sourceFreezable);
CopyCommon(sourceBitmap);
}
///
/// Renders the specified Visual tree to the BitmapRenderTarget.
///
public void Render(Visual visual)
{
BitmapVisualManager bmv = new BitmapVisualManager(this);
bmv.Render(visual); // Render indirectly calls RenderTargetContentsChanged();
}
///
/// Renders the specified Visual tree to the BitmapRenderTarget
/// This renders the visual without transform, clip, offset and
/// guidelines applied to it.
///
internal void RenderForBitmapEffect(Visual visual, Matrix worldTransform, Rect windowClip)
{
// first clear the render target
Clear();
BitmapVisualManager bmv = new BitmapVisualManager(this);
bmv.Render(visual, worldTransform, windowClip, true); // Render indirectly calls RenderTargetContentsChanged();
}
///
/// Clears the render target and sets every pixel to black transparent
///
///
/// Critical - access unmanaged resource
/// PublicOk - Clear is safe (no inputs)
///
[SecurityCritical]
public void Clear()
{
HRESULT.Check(MILRenderTargetBitmap.Clear(_renderTargetBitmap));
RenderTargetContentsChanged();
}
///
/// Get the MIL RenderTarget
///
///
/// Critical - returns unmanaged resource
///
internal SafeMILHandle MILRenderTarget
{
[SecurityCritical]
get
{
return _renderTargetBitmap;
}
}
///
/// Notify that the contents of the render target have changed
///
///
/// Critical - access critical resource _convertedDUCEMILPtr
/// TreatAsSafe - Critical data is used internally and not exposed
///
[SecurityCritical, SecurityTreatAsSafe]
internal void RenderTargetContentsChanged()
{
// If the render target has changed, we need to update the UCE resource. We ensure
// this happens by throwing away our reference to the previous DUCE bitmap source
// and forcing the creation of a new one.
_isSourceCached = false;
if (_convertedDUCEMILPtr != null)
{
_convertedDUCEMILPtr.Close();
_convertedDUCEMILPtr = null;
}
// Register for update in the next render pass
RegisterForAsyncUpdateResource();
FireChanged();
}
///
/// Create the unmanaged resources
///
///
/// Critical - creates critical resource
///
[SecurityCritical]
internal override void FinalizeCreation()
{
try
{
using (FactoryMaker myFactory = new FactoryMaker())
{
SafeMILHandle renderTargetBitmap = null;
HRESULT.Check(UnsafeNativeMethods.MILFactory2.CreateBitmapRenderTarget(
myFactory.FactoryPtr,
(uint)_pixelWidth,
(uint)_pixelHeight,
_format.Format,
(float)_dpiX,
(float)_dpiY,
MILRTInitializationFlags.MIL_RT_INITIALIZE_DEFAULT,
out renderTargetBitmap));
Debug.Assert(renderTargetBitmap != null && !renderTargetBitmap.IsInvalid);
BitmapSourceSafeMILHandle bitmapSource = null;
HRESULT.Check(MILRenderTargetBitmap.GetBitmap(
renderTargetBitmap,
out bitmapSource));
Debug.Assert(bitmapSource != null && !bitmapSource.IsInvalid);
lock (_syncObject)
{
_renderTargetBitmap = renderTargetBitmap;
WicSourceHandle = bitmapSource;
// For the purpose of rendering a RenderTargetBitmap, we always treat it as if it's
// not cached. This is to ensure we never render and write to the same bitmap source
// by the UCE thread and managed thread.
_isSourceCached = false;
}
}
CreationCompleted = true;
UpdateCachedSettings();
}
catch
{
_bitmapInit.Reset();
throw;
}
}
///
/// Critical - unmanaged resource - not safe for handing out
///
[SecurityCritical]
private SafeMILHandle /* IMILRenderTargetBitmap */ _renderTargetBitmap;
}
#endregion // RenderTargetBitmap
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TreeBuilderBamlTranslator.cs
- WebPartConnectionsCancelEventArgs.cs
- AuthenticatingEventArgs.cs
- InfoCardServiceInstallComponent.cs
- EntityDescriptor.cs
- ErrorFormatterPage.cs
- TcpProcessProtocolHandler.cs
- ComponentChangedEvent.cs
- SiteMapSection.cs
- Psha1DerivedKeyGenerator.cs
- OledbConnectionStringbuilder.cs
- DataBoundControlHelper.cs
- SortAction.cs
- DataGridCaption.cs
- FieldToken.cs
- StorageEndPropertyMapping.cs
- EventItfInfo.cs
- StringArrayConverter.cs
- ColumnMapCopier.cs
- UnsupportedPolicyOptionsException.cs
- NavigatorOutput.cs
- EditorZone.cs
- PackagePartCollection.cs
- TableItemProviderWrapper.cs
- QueueProcessor.cs
- RangeBase.cs
- ToolStripGripRenderEventArgs.cs
- InputManager.cs
- RegexWriter.cs
- SwitchElementsCollection.cs
- XmlWrappingWriter.cs
- CustomSignedXml.cs
- RegionData.cs
- ManifestResourceInfo.cs
- LinearQuaternionKeyFrame.cs
- ServicesExceptionNotHandledEventArgs.cs
- ContextProperty.cs
- MaskedTextBox.cs
- SortKey.cs
- BitmapEffect.cs
- BitmapVisualManager.cs
- OracleBinary.cs
- PersonalizationStateInfoCollection.cs
- ReliableSessionBindingElement.cs
- StringSource.cs
- EmptyEnumerator.cs
- XmlDocumentType.cs
- SmtpReplyReaderFactory.cs
- TextViewElement.cs
- EntityDataSourceSelectingEventArgs.cs
- ReaderWriterLockWrapper.cs
- OdbcCommandBuilder.cs
- Graphics.cs
- DbConnectionPoolIdentity.cs
- DataGridDefaultColumnWidthTypeConverter.cs
- HtmlTableRow.cs
- XmlQueryStaticData.cs
- DataGridPagerStyle.cs
- CodeLinePragma.cs
- HandlerFactoryWrapper.cs
- SoapInteropTypes.cs
- MetadataFile.cs
- ZipIOBlockManager.cs
- Point3DCollection.cs
- AppDomainEvidenceFactory.cs
- WebBrowserUriTypeConverter.cs
- Parallel.cs
- SingleAnimationBase.cs
- ManagementPath.cs
- UpdateException.cs
- Type.cs
- InternalConfigConfigurationFactory.cs
- SqlParameter.cs
- EdmToObjectNamespaceMap.cs
- Rotation3DAnimationUsingKeyFrames.cs
- DescendantQuery.cs
- SymbolEqualComparer.cs
- basemetadatamappingvisitor.cs
- WindowsSolidBrush.cs
- hebrewshape.cs
- XomlDesignerLoader.cs
- XmlIncludeAttribute.cs
- DataGridTableStyleMappingNameEditor.cs
- XsdSchemaFileEditor.cs
- DynamicQueryableWrapper.cs
- DataPagerCommandEventArgs.cs
- ScriptRef.cs
- StrongNameUtility.cs
- ThrowHelper.cs
- securitymgrsite.cs
- Pair.cs
- listitem.cs
- Root.cs
- WebPartTransformerCollection.cs
- DefaultObjectMappingItemCollection.cs
- MessageSecurityOverTcpElement.cs
- RC2.cs
- LookupNode.cs
- CustomTypeDescriptor.cs
- WebDescriptionAttribute.cs