/// <summary>
///
/// </summary>
/// <param name="filenameList"></param>
public static void PlayAsync(IEnumerable <string> filenameList)
{
var path = Application.StartupPath + "\\Config\\Wave\\";
UnmanagedCode.Assert();
try
{
foreach (var fileName in filenameList)
{
var filefullname = path + fileName;
if (!_fileNames.Contains(filefullname))
{
if (!File.Exists(filefullname))
{
continue;
}
_fileNames.Enqueue(filefullname);
}
sndPlaySound(filefullname,
(int)(SoundFlags.SND_FILENAME | SoundFlags.SND_NODEFAULT | SoundFlags.SND_ASYNC));
// PlaySound(path + fileName, IntPtr.Zero, (int)(SoundFlags.SND_FILENAME | SoundFlags.SND_NODEFAULT | SoundFlags.SND_ASYNC));
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
ReEncodeImage(BitmapSource bitmapSource, BitmapEncoder encoder, Stream stream)
{
BitmapFrame bitmapFrame = null;
//
// The uri the BitmapFrame.Create will use is null since it is accessing metadata at
// construction and its uri is still null
//
CodeAccessPermission mediaAccessPermission = SecurityHelper.CreateMediaAccessPermission(null);
if (mediaAccessPermission != null)
{
mediaAccessPermission.Assert(); //BlessedAssert
}
try
{
// DevDiv bug 213320
// If bitmapSource is indexed, has a color palette and transparency (e.g. transparent GIF)
// PNG conversion may lose color or transparency or both information
// To avoid this we convert all paletted bitmapSources to the 32 bit per pixel bgra format
if (bitmapSource != null &&
bitmapSource.Palette != null &&
bitmapSource.Palette.Colors != null &&
bitmapSource.Palette.Colors.Count > 0)
{
bitmapSource = new FormatConvertedBitmap(bitmapSource, PixelFormats.Bgra32, null, 0.0);
}
bitmapFrame = BitmapFrame.Create(bitmapSource);
}
finally
{
if (mediaAccessPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
encoder.Frames.Add(bitmapFrame);
if (mediaAccessPermission != null)
{
mediaAccessPermission.Assert(); //BlessedAssert
}
try
{
encoder.Save(stream);
}
finally
{
if (mediaAccessPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
}
protected override bool ProcessMnemonic(char charCode)
{
if (FocusControl == null)
{
return(base.ProcessMnemonic(charCode));
}
if ((!this.UseMnemonic || !Control.IsMnemonic(charCode, this.Text) ||
!FocusControl.CanFocus)
/*|| !this.CanProcessMnemonic()*/) // some day check this also? but have to use reflection to do so!
{
return(false);
}
_ModifyFocus.Assert();
try
{
FocusControl.Focus();
}
finally
{
CodeAccessPermission.RevertAssert();
}
return(true);
}
AcquireCacheItem(
GlyphTypeface glyphTypeface
)
{
FEMCacheItem manager = null;
Uri fontUri;
CodeAccessPermission uriDiscoveryPermission = glyphTypeface.CriticalUriDiscoveryPermission;
if (uriDiscoveryPermission != null)
{
uriDiscoveryPermission.Assert();
}
try
{
fontUri = glyphTypeface.FontUri;
}
finally
{
if (uriDiscoveryPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
if (!_fontEmbeddingManagerCache.TryGetValue(fontUri, out manager))
{
manager = new FEMCacheItem(glyphTypeface, _packagingPolicy);
_fontEmbeddingManagerCache.Add(fontUri, manager);
}
return(manager);
}
private static Rect GetImageableRect(PrintDialog dialog)
{
Rect empty = Rect.Empty;
Invariant.Assert(dialog != null, "Dialog should not be null.");
PrintCapabilities printCapabilities = null;
CodeAccessPermission codeAccessPermission = SystemDrawingHelper.NewDefaultPrintingPermission();
codeAccessPermission.Assert();
try
{
PrintQueue printQueue = dialog.PrintQueue;
if (printQueue != null)
{
printCapabilities = printQueue.GetPrintCapabilities();
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (printCapabilities != null)
{
PageImageableArea pageImageableArea = printCapabilities.PageImageableArea;
if (pageImageableArea != null)
{
empty = new Rect(pageImageableArea.OriginWidth, pageImageableArea.OriginHeight, pageImageableArea.ExtentWidth, pageImageableArea.ExtentHeight);
}
}
if (empty == Rect.Empty)
{
empty = new Rect(15.0, 15.0, dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);
}
return(empty);
}
FEMCacheItem(
GlyphTypeface glyphTypeface,
BasePackagingPolicy packagingPolicy
)
{
if (null == packagingPolicy)
{
throw new ArgumentNullException("packagingPolicy");
}
if (null == glyphTypeface)
{
throw new ArgumentNullException("glyphTypeface");
}
_packagingPolicy = packagingPolicy;
_streamWritten = false;
//
// Acquire the stream that will be used to save the font.
// if the font is Image only we do not need a font stream
// since each glyph run will be saved in its own image stream
//
_fontEmbeddingManager = new FontEmbeddingManager();
_glyphTypeface = glyphTypeface;
CodeAccessPermission uriDiscoveryPermission = glyphTypeface.CriticalUriDiscoveryPermission;
if (uriDiscoveryPermission != null)
{
uriDiscoveryPermission.Assert();
}
try
{
_fontUri = glyphTypeface.FontUri;
}
finally
{
if (uriDiscoveryPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
Uri fontUri = new Uri(_fontUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.SafeUnescaped), UriKind.RelativeOrAbsolute);
string fontUriAsString = fontUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
_fontResourceStream = packagingPolicy.AcquireResourceStreamForXpsFont(fontUriAsString);
//
// Aquiring the Resource stream will instantiate the font
// and add the require resource relationship
//
_curPageRelAdded = true;
}
private static Rect GetImageableRect(PrintDialog dialog)
{
Rect imageableRect = Rect.Empty;
Invariant.Assert(dialog != null, "Dialog should not be null.");
System.Printing.PrintQueue queue = null;
System.Printing.PrintCapabilities capabilities = null;
System.Printing.PageImageableArea imageableArea = null;
// This gets the PringDocumentImageableArea.OriginWidth/OriginHeight
// of the PrintQueue the user chose in the dialog.
CodeAccessPermission printp = SystemDrawingHelper.NewDefaultPrintingPermission();
printp.Assert();//Blessed Assert to get PrintQueue and call GetPrintCapabilities
try
{
queue = dialog.PrintQueue;
if (queue != null)
{
capabilities = queue.GetPrintCapabilities();
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (capabilities != null)
{
imageableArea = capabilities.PageImageableArea;
if (imageableArea != null)
{
imageableRect = new Rect(imageableArea.OriginWidth,
imageableArea.OriginHeight,
imageableArea.ExtentWidth,
imageableArea.ExtentHeight);
}
}
// If for any reason we couldn't get the actual printer's values
// we fallback to a constant and the values available from the
// PrintDialog.
if (imageableRect == Rect.Empty)
{
imageableRect = new Rect(NON_PRINTABLE_MARGIN,
NON_PRINTABLE_MARGIN,
dialog.PrintableAreaWidth,
dialog.PrintableAreaHeight);
}
return(imageableRect);
}
CopyFontStream()
{
Uri sourceUri = _fontUri;
Uri destUri = _fontResourceStream.Uri;
Stream destStream = _fontResourceStream.Stream;
Stream sourceStream = null;
byte [] memoryFont;
GlyphTypeface glyphTypeface = new GlyphTypeface(sourceUri);
CodeAccessPermission fontReadPermission = glyphTypeface.CriticalFileReadPermission;
if (fontReadPermission != null)
{
fontReadPermission.Assert();
}
try
{
sourceStream = glyphTypeface.GetFontStream();
}
finally
{
if (fontReadPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
memoryFont = new byte[_readBlockSize];
Guid guid = ParseGuidFromUri(destUri);
int bytesRead = PackagingUtilities.ReliableRead(sourceStream, memoryFont, 0, _readBlockSize);
if (bytesRead > 0)
{
// Obfuscate the first block
ObfuscateData(memoryFont, guid);
}
while (bytesRead > 0)
{
destStream.Write(memoryFont, 0, bytesRead);
bytesRead = PackagingUtilities.ReliableRead(sourceStream, memoryFont, 0, _readBlockSize);
}
Uri fontUri = new Uri(_fontUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.SafeUnescaped), UriKind.RelativeOrAbsolute);
string fontUriAsString = fontUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
_packagingPolicy.ReleaseResourceStreamForXpsFont(fontUriAsString);
_streamWritten = true;
return(destUri);
}
private static void DoUserInitiatedNavigation(object sender)
{
CodeAccessPermission codeAccessPermission = SecurityHelper.CreateUserInitiatedNavigationPermission();
codeAccessPermission.Assert();
try
{
Hyperlink.DispatchNavigation(sender);
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
internal override object GetBitmapFromBitmapSource(object source)
{
BitmapSource contentImage = (BitmapSource)source;
int imageWidth = (int)contentImage.Width;
int imageHeight = (int)contentImage.Height;
Bitmap bitmapFinal = new Bitmap(
imageWidth,
imageHeight,
System.Drawing.Imaging.PixelFormat.Format32bppRgb);
BitmapData bmData = bitmapFinal.LockBits(
new Rectangle(0, 0, imageWidth, imageHeight),
ImageLockMode.WriteOnly,
System.Drawing.Imaging.PixelFormat.Format32bppRgb);
FormatConvertedBitmap formatConverter = new FormatConvertedBitmap();
formatConverter.BeginInit();
formatConverter.Source = contentImage;
formatConverter.DestinationFormat = System.Windows.Media.PixelFormats.Bgr32;
formatConverter.EndInit();
CodeAccessPermission mediaAccessPermission = SecurityHelper.CreateMediaAccessPermission(null);
if (mediaAccessPermission != null)
{
mediaAccessPermission.Assert(); //BlessedAssert
}
try
{
formatConverter.CopyPixels(
new Int32Rect(0, 0, imageWidth, imageHeight),
bmData.Scan0,
bmData.Stride * (bmData.Height - 1) + (bmData.Width * 4),
bmData.Stride);
}
finally
{
if (mediaAccessPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
bitmapFinal.UnlockBits(bmData);
return(bitmapFinal);
}
AddGlyphRunUsage(
GlyphRun glyphRun
)
{
Uri fontUri = null;
FontEmbeddingAction action = XpsFontSubsetter.DetermineEmbeddingAction(_glyphTypeface);
switch (action)
{
//
// Provide an empty image stream. The Glyphs serializer
// will check content type and render adn serialize an
// image into this stream based on content type
//
case FontEmbeddingAction.ImageOnlyFont:
break;
case FontEmbeddingAction.ObfuscateOnlyFont:
fontUri = _fontResourceStream.Uri;
// nothing to do here since the entire font will be added
break;
case FontEmbeddingAction.ObfuscateSubsetFont:
CodeAccessPermission uriDiscoveryPermission = glyphRun.GlyphTypeface.CriticalUriDiscoveryPermission;
if (uriDiscoveryPermission != null)
{
uriDiscoveryPermission.Assert();
}
try
{
_fontEmbeddingManager.RecordUsage(glyphRun);
}
finally
{
if (uriDiscoveryPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
fontUri = _fontResourceStream.Uri;
break;
}
return(fontUri);
}
IsRestrictedFont(GlyphTypeface glyphTypeface)
{
FontEmbeddingRight fsType = FontEmbeddingRight.RestrictedLicense;
CodeAccessPermission fontReadPermission = glyphTypeface.CriticalFileReadPermission;
if (fontReadPermission != null)
{
fontReadPermission.Assert();
}
try
{
fsType = glyphTypeface.EmbeddingRights;
}
finally
{
if (fontReadPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
return(IsRestrictedFont(fsType));
}
ComputeFontSubset(
GlyphRun glyphRun
)
{
FontEmbeddingRight embeddingRights = FontEmbeddingRight.RestrictedLicense;
if (null == glyphRun)
{
throw new ArgumentNullException("glyphRun");
}
Uri fontUri = null;
CodeAccessPermission fontReadPermission = glyphRun.GlyphTypeface.CriticalFileReadPermission;
if (fontReadPermission != null)
{
fontReadPermission.Assert();
}
try
{
embeddingRights = glyphRun.GlyphTypeface.EmbeddingRights;
}
finally
{
if (fontReadPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
if (DetermineEmbeddingAction(embeddingRights) ==
FontEmbeddingAction.ImageOnlyFont)
{
//
// Aquire a bit map stream to embedd the Glyph Run image
//
fontUri = _packagingPolicy.AcquireResourceStreamForXpsImage(XpsS0Markup.ImageUriPlaceHolder).Uri;
}
else
{
FEMCacheItem cacheItem = AcquireCacheItem(
glyphRun.GlyphTypeface
);
if (cacheItem != null)
{
cacheItem.CurrentPageReferences = true;
if (_commitPolicy == FontSubsetterCommitPolicies.None &&
!cacheItem.IsStreamWritten)
{
fontUri = cacheItem.CopyFontStream();
}
else
{
fontUri = cacheItem.AddGlyphRunUsage(glyphRun);
}
}
}
return(fontUri);
}
