internal void OnPageBreakRecordCreated(SecurityCriticalDataForSet <IntPtr> br) { Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); Invariant.Assert(!this.Disposed, "PtsContext is already disposed."); Invariant.Assert(!this._pageBreakRecords.Contains(br.Value), "Break record already exists."); this._pageBreakRecords.Add(br.Value); }
internal void OnPageCreated(SecurityCriticalDataForSet <IntPtr> ptsPage) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); Invariant.Assert(!this.Disposed, "PtsContext is already disposed."); Invariant.Assert(!this._pages.Contains(ptsPage.Value), "Page already exists."); this._pages.Add(ptsPage.Value); }
private void OnDestroyPage(SecurityCriticalDataForSet <IntPtr> ptsPage, bool enterContext) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); if (!this.Disposed) { Invariant.Assert(this._pages != null, "Collection of pages does not exist."); Invariant.Assert(this._pages.Contains(ptsPage.Value), "Page does not exist."); try { if (enterContext) { this.Enter(); } PTS.Validate(PTS.FsDestroyPage(this._ptsHost.Context, ptsPage.Value)); } finally { if (enterContext) { this.Leave(); } this._pages.Remove(ptsPage.Value); } } }
// Token: 0x06006927 RID: 26919 RVA: 0x001DC11C File Offset: 0x001DA31C private object OnDestroyPage(object args) { SecurityCriticalDataForSet <IntPtr> ptsPage = (SecurityCriticalDataForSet <IntPtr>)args; this.OnDestroyPage(ptsPage, true); return(null); }
static BaseUriHelper() { _baseUri = new SecurityCriticalDataForSet <Uri>(_packAppBaseUri); // Add an instance of the ResourceContainer to PreloadedPackages so that PackWebRequestFactory can find it // and mark it as thread-safe so PackWebResponse won't protect returned streams with a synchronizing wrapper PreloadedPackages.AddPackage(PackUriHelper.GetPackageUri(SiteOfOriginBaseUri), new SiteOfOriginContainer(), true); }
/// <summary> /// Destroys PTS page break record. /// </summary> /// <param name="args">Pointer to PTS Page BreakRecord object that should be destroyed.</param> private object OnDestroyBreakRecord(object args) { SecurityCriticalDataForSet <IntPtr> br = (SecurityCriticalDataForSet <IntPtr>)args; Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); // Dispatcher may invoke this operation when PtsContext is already explicitly // disposed. if (!this.Disposed) { Invariant.Assert(_pageBreakRecords != null, "Collection of break records does not exist."); Invariant.Assert(_pageBreakRecords.Contains(br.Value), "Break record does not exist."); // Destroy given page break record. // It is necessary to enter PTS Context when executing any PTS methods. try { Enter(); PTS.Validate(PTS.FsDestroyPageBreakRecord(_ptsHost.Context, br.Value)); } finally { Leave(); _pageBreakRecords.Remove(br.Value); } } return(null); }
/// <summary> /// Destroys PTS page. /// </summary> /// <param name="ptsPage">Pointer to PTS Page object that should be destroyed.</param> /// <param name="enterContext">Whether needs to enter PTS Context.</param> private void OnDestroyPage(SecurityCriticalDataForSet <IntPtr> ptsPage, bool enterContext) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); // Dispatcher may invoke this operation when PtsContext is already explicitly // disposed. if (!this.Disposed) { Invariant.Assert(_pages != null, "Collection of pages does not exist."); Invariant.Assert(_pages.Contains(ptsPage.Value), "Page does not exist."); // Destroy given page. // It is necessary to enter PTS Context when executing any PTS methods. try { if (enterContext) { Enter(); } PTS.Validate(PTS.FsDestroyPage(_ptsHost.Context, ptsPage.Value)); } finally { if (enterContext) { Leave(); } _pages.Remove(ptsPage.Value); } } }
static BaseUriHelper() { _baseUri = new SecurityCriticalDataForSet<Uri>(_packAppBaseUri); // Add an instance of the ResourceContainer to PreloadedPackages so that PackWebRequestFactory can find it // and mark it as thread-safe so PackWebResponse won't protect returned streams with a synchronizing wrapper PreloadedPackages.AddPackage(PackUriHelper.GetPackageUri(SiteOfOriginBaseUri), new SiteOfOriginContainer(), true); }
/// <summary> /// Loads color profile given by profileUri /// </summary> private void Initialize(Uri profileUri, bool isStandardProfileUriNotFromUser) { bool tryProfileFromResource = false; if (profileUri == null) { throw new ArgumentNullException("profileUri"); } if (!profileUri.IsAbsoluteUri) { throw new ArgumentException(SR.Get(SRID.UriNotAbsolute), "profileUri"); } _profileUri = new SecurityCriticalData <Uri>(profileUri); _isProfileUriNotFromUser = new SecurityCriticalDataForSet <bool>(isStandardProfileUriNotFromUser); Stream profileStream = null; try { profileStream = WpfWebRequestHelper.CreateRequestAndGetResponseStream(profileUri); } catch (WebException) { // // If we couldn't load the system's default color profile (e.g. in partial trust), load a color profile from // a resource so the image shows up at least. If the user specified a color profile and we weren't // able to load it, we'll fail to avoid letting the user use this resource fallback as a way to discover // files on disk. // if (isStandardProfileUriNotFromUser) { tryProfileFromResource = true; } } if (profileStream == null) { if (tryProfileFromResource) { ResourceManager resourceManager = new ResourceManager(_colorProfileResources, Assembly.GetAssembly(typeof(ColorContext))); byte[] sRGBProfile = (byte[])resourceManager.GetObject(_sRGBProfileName); profileStream = new MemoryStream(sRGBProfile); } else { // // SECURITY WARNING: This exception includes the profile URI which may contain sensitive information. However, as of right now, // this is safe because it can only happen when the URI is given to us by the user. // Invariant.Assert(!isStandardProfileUriNotFromUser); throw new FileNotFoundException(SR.Get(SRID.FileNotFoundExceptionWithFileName, profileUri.AbsolutePath), profileUri.AbsolutePath); } } FromStream(profileStream, profileUri.AbsolutePath); }
internal PixelFormat(PixelFormatEnum format) { _format = format; _flags = GetPixelFormatFlagsFromEnum(format); _bitsPerPixel = GetBitsPerPixelFromEnum(format); _guidFormat = new SecurityCriticalDataForSet <Guid> (PixelFormat.GetGuidFromFormat(format)); }
// Token: 0x060068EB RID: 26859 RVA: 0x001D9960 File Offset: 0x001D7B60 internal PageBreakRecord(PtsContext ptsContext, SecurityCriticalDataForSet <IntPtr> br, int pageNumber) { Invariant.Assert(ptsContext != null, "Invalid PtsContext object."); Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); this._br = br; this._pageNumber = pageNumber; this._ptsContext = new WeakReference(ptsContext); ptsContext.OnPageBreakRecordCreated(this._br); }
internal ByteStream(object underlyingStream, FileAccess openAccess) { SecuritySuppressedIStream stream = underlyingStream as SecuritySuppressedIStream; Debug.Assert(stream != null); _securitySuppressedIStream = new SecurityCriticalDataForSet<SecuritySuppressedIStream>(stream); _access = openAccess; // we only work for reading. Debug.Assert(_access == FileAccess.Read); }
internal TextPenaltyModule(SecurityCriticalDataForSet<IntPtr> ploc) { IntPtr ploPenaltyModule; LsErr lserr = UnsafeNativeMethods.LoAcquirePenaltyModule(ploc.Value, out ploPenaltyModule); if (lserr != LsErr.None) { TextFormatterContext.ThrowExceptionFromLsError(SR.Get(SRID.AcquirePenaltyModuleFailure, lserr), lserr); } _ploPenaltyModule.Value = ploPenaltyModule; }
internal TextPenaltyModule(SecurityCriticalDataForSet <IntPtr> ploc) { IntPtr ploPenaltyModule; LsErr lserr = UnsafeNativeMethods.LoAcquirePenaltyModule(ploc.Value, out ploPenaltyModule); if (lserr != LsErr.None) { TextFormatterContext.ThrowExceptionFromLsError(SR.Get(SRID.AcquirePenaltyModuleFailure, lserr), lserr); } _ploPenaltyModule.Value = ploPenaltyModule; }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// Constructs a ByteStream class from a supplied unmanaged stream with the specified access. /// </summary> /// <param name="underlyingStream"></param> /// <param name="openAccess"></param> internal ByteStream(object underlyingStream, FileAccess openAccess) { SecuritySuppressedIStream stream = underlyingStream as SecuritySuppressedIStream; Debug.Assert(stream != null); _securitySuppressedIStream = new SecurityCriticalDataForSet <SecuritySuppressedIStream>(stream); _access = openAccess; // we only work for reading. Debug.Assert(_access == FileAccess.Read); }
private void Initialize(bool fTrusted) { _fTrusted = new SecurityCriticalDataForSet <bool> (fTrusted); _hwndSubclassHook = new HwndWrapperHook(SubclassWndProc); _handlerLayoutUpdated = new EventHandler(OnLayoutUpdated); _handlerEnabledChanged = new DependencyPropertyChangedEventHandler(OnEnabledChanged); _handlerVisibleChanged = new DependencyPropertyChangedEventHandler(OnVisibleChanged); PresentationSource.AddSourceChangedHandler(this, new SourceChangedEventHandler(OnSourceChanged)); _weakEventDispatcherShutdown = new WeakEventDispatcherShutdown(this, this.Dispatcher); }
// Token: 0x0600691B RID: 26907 RVA: 0x001DBEE8 File Offset: 0x001DA0E8 internal void OnPageDisposed(SecurityCriticalDataForSet <IntPtr> ptsPage, bool disposing, bool enterContext) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); if (disposing) { this.OnDestroyPage(ptsPage, enterContext); return; } if (!this.Disposed && !base.Dispatcher.HasShutdownStarted) { base.Dispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(this.OnDestroyPage), ptsPage); } }
// Token: 0x0600691D RID: 26909 RVA: 0x001DBFC8 File Offset: 0x001DA1C8 internal void OnPageBreakRecordDisposed(SecurityCriticalDataForSet <IntPtr> br, bool disposing) { Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); if (disposing) { this.OnDestroyBreakRecord(br); return; } if (!this.Disposed && !base.Dispatcher.HasShutdownStarted) { base.Dispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(this.OnDestroyBreakRecord), br); } }
//-------------------------------------------------------------------------- // Constructors //------------------------------------------------------------------------- /// <summary> /// Requires an existing open Package; and returns a package which will /// capture changes with out applying them to the original. /// See the class description for details. /// </summary> /// <exception cref="System.ArgumentNullException" /> /// <example> /// Package package = new TransactionalPackage( /// Package.Open(source, FileMode.Open, FileAccess.Read)); /// </example> /// <param name="originalPackage">An open package.</param> internal TransactionalPackage(Stream original) : base(FileAccess.ReadWrite) { if (original == null) { throw new ArgumentNullException("original"); } Package originalPackage = Package.Open(original); _originalPackage = new SecurityCriticalDataForSet <Package>(originalPackage); _tempPackage = new SecurityCriticalDataForSet <Package>(null); }
/// <summary> /// Internallly construct the line break /// </summary> internal TextLineBreak( TextModifierScope currentScope, SecurityCriticalDataForSet<IntPtr> breakRecord ) { _currentScope = currentScope; _breakRecord = breakRecord; if (breakRecord.Value == IntPtr.Zero) { // this object does not hold unmanaged resource, // remove it from the finalizer queue. GC.SuppressFinalize(this); } }
/// <summary> /// Internallly construct the line break /// </summary> internal TextLineBreak( TextModifierScope currentScope, SecurityCriticalDataForSet <IntPtr> breakRecord ) { _currentScope = currentScope; _breakRecord = breakRecord; if (breakRecord.Value == IntPtr.Zero) { // this object does not hold unmanaged resource, // remove it from the finalizer queue. GC.SuppressFinalize(this); } }
private FullTextBreakpoint( FullTextState fullText, int firstCharIndex, int maxLineWidth, ref LsBreaks lsbreaks, int breakIndex ) : this() { // According to antons: PTS only uses the width of a feasible break to avoid // clipping in subpage. At the moment, there is no good solution as of how // PTS client would be able to compute this width efficiently using LS. // The work around - although could be conceived would simply be too slow. // The width should therefore be set to the paragraph width for the time being. // // Client of text formatter would simply pass the value of TextBreakpoint.Width // back to PTS pfnFormatLineVariants call. LsLineWidths lineWidths = new LsLineWidths(); lineWidths.upLimLine = maxLineWidth; lineWidths.upStartMainText = fullText.TextStore.Settings.TextIndent; lineWidths.upStartMarker = lineWidths.upStartMainText; lineWidths.upStartTrailing = lineWidths.upLimLine; lineWidths.upMinStartTrailing = lineWidths.upStartTrailing; // construct the correspondent text metrics unsafe { _metrics.Compute( fullText, firstCharIndex, maxLineWidth, null, // collapsingSymbol ref lineWidths, &lsbreaks.plslinfoArray[breakIndex] ); _ploline = new SecurityCriticalDataForSet <IntPtr>(lsbreaks.pplolineArray[breakIndex]); // keep the line penalty handle _penaltyResource = new SecurityCriticalDataForSet <IntPtr>(lsbreaks.plinepenaltyArray[breakIndex]); if (lsbreaks.plslinfoArray[breakIndex].fForcedBreak != 0) { _isLineTruncated = true; } } }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Constructor. /// </summary> /// <param name="ptsContext">Current PTS Context.</param> /// <param name="br">PTS page break record.</param> /// <param name="pageNumber">Page number.</param> internal PageBreakRecord(PtsContext ptsContext, SecurityCriticalDataForSet<IntPtr> br, int pageNumber) { Invariant.Assert(ptsContext != null, "Invalid PtsContext object."); Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); _br = br; _pageNumber = pageNumber; // In the finalizer we may need to reference an object instance // to do the right cleanup. For this reason store a WeakReference // to such object. _ptsContext = new WeakReference(ptsContext); // BreakRecord contains unmanaged resources that need to be released when // BreakRecord is destroyed or Dispatcher is closing. For this reason keep // track of this BreakRecord in PtsContext. ptsContext.OnPageBreakRecordCreated(_br); }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Constructor. /// </summary> /// <param name="ptsContext">Current PTS Context.</param> /// <param name="br">PTS page break record.</param> /// <param name="pageNumber">Page number.</param> internal PageBreakRecord(PtsContext ptsContext, SecurityCriticalDataForSet <IntPtr> br, int pageNumber) { Invariant.Assert(ptsContext != null, "Invalid PtsContext object."); Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); _br = br; _pageNumber = pageNumber; // In the finalizer we may need to reference an object instance // to do the right cleanup. For this reason store a WeakReference // to such object. _ptsContext = new WeakReference(ptsContext); // BreakRecord contains unmanaged resources that need to be released when // BreakRecord is destroyed or Dispatcher is closing. For this reason keep // track of this BreakRecord in PtsContext. ptsContext.OnPageBreakRecordCreated(_br); }
/// <summary> /// Initializes the interaction engine /// </summary> /// <param name="stylusDevice"></param> /// <param name="configuration"></param> internal PointerInteractionEngine(PointerStylusDevice stylusDevice, List <UnsafeNativeMethods.INTERACTION_CONTEXT_CONFIGURATION> configuration = null) { _stylusDevice = stylusDevice; // Only create a flick engine for Pen devices if (_stylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) { // Currently disabled pending decision about flick support in Windows 10 RS3 //_flickEngine = new PointerFlickEngine(_stylusDevice); } // Create our interaction context for gesture recognition IntPtr interactionContext = IntPtr.Zero; UnsafeNativeMethods.CreateInteractionContext(out interactionContext); _interactionContext = new SecurityCriticalDataForSet <IntPtr>(interactionContext); if (configuration == null) { configuration = DefaultConfiguration; } if (_interactionContext.Value != IntPtr.Zero) { // We do not want to filter specific pointers UnsafeNativeMethods.SetPropertyInteractionContext(_interactionContext.Value, UnsafeNativeMethods.INTERACTION_CONTEXT_PROPERTY.INTERACTION_CONTEXT_PROPERTY_FILTER_POINTERS, Convert.ToUInt32(false)); // Use screen measurements here as this makes certain math easier for us UnsafeNativeMethods.SetPropertyInteractionContext(_interactionContext.Value, UnsafeNativeMethods.INTERACTION_CONTEXT_PROPERTY.INTERACTION_CONTEXT_PROPERTY_MEASUREMENT_UNITS, (UInt32)UnsafeNativeMethods.InteractionMeasurementUnits.Screen); // Configure the context UnsafeNativeMethods.SetInteractionConfigurationInteractionContext(_interactionContext.Value, (uint)configuration.Count, configuration.ToArray()); // Store the delegate so it can be accessed over time _callbackDelegate = Callback; // Register for interaction notifications UnsafeNativeMethods.RegisterOutputCallbackInteractionContext(_interactionContext.Value, _callbackDelegate); } }
//------------------------------------------------------------------------- // Internal Methods //------------------------------------------------------------------------- /// <exception cref="System.ArgumentNullException" /> internal void EnableEditMode(Stream workspace) { if (workspace == null) { throw new ArgumentNullException("workspace"); } if (!workspace.CanWrite) { throw new ArgumentException( SR.Get(SRID.PackagingWriteNotSupported), "workspace"); } Package temporaryPackage = Package.Open( workspace, FileMode.Create, FileAccess.ReadWrite); _tempPackage = new SecurityCriticalDataForSet <Package>(temporaryPackage); }
/// <summary> /// Destroys PTS break record. /// </summary> /// <param name="br">Pointer to PTS Page BR object that should be destroyed.</param> /// <param name="disposing">Whether dispose is caused by explicit call to Dispose.</param> internal void OnPageBreakRecordDisposed(SecurityCriticalDataForSet <IntPtr> br, bool disposing) { Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); // If explicitly disposing (not called during finalization), synchronously // destroy the page break record. if (disposing) { OnDestroyBreakRecord((object)br); } else { // If PtsContext has been already disposed, ignore this call. if (!this.Disposed && !this.Dispatcher.HasShutdownStarted) { // Schedule background operation to destroy the page. this.Dispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(OnDestroyBreakRecord), br); } } }
internal PixelFormat(Guid guidPixelFormat) { unsafe { Guid guidWicPixelFormat = WICPixelFormatGUIDs.WICPixelFormatDontCare; byte *pGuidPixelFormat = (byte *)&guidPixelFormat; byte *pGuidBuiltIn = (byte *)&guidWicPixelFormat; // Compare only the first 15 bytes of the GUID. If the first // 15 bytes match the WIC pixel formats, then the 16th byte // will be the format enum value. Debug.Assert(Marshal.SizeOf(typeof(Guid)) == 16); int compareCount = 15; bool fBuiltIn = true; for (int i = 0; i < compareCount; ++i) { if (pGuidPixelFormat[i] != pGuidBuiltIn[i]) { fBuiltIn = false; break; } } // If it looks like a built-in WIC pixel format, verify that // the format enum value is known to us. if (fBuiltIn && pGuidPixelFormat[compareCount] <= (byte)PixelFormatEnum.Cmyk32) { _format = (PixelFormatEnum)pGuidPixelFormat[compareCount]; } else { _format = PixelFormatEnum.Extended; } } _flags = GetPixelFormatFlagsFromEnum(_format) | GetPixelFormatFlagsFromGuid(guidPixelFormat); _bitsPerPixel = GetBitsPerPixelFromEnum(_format); _guidFormat = new SecurityCriticalDataForSet <Guid> (guidPixelFormat); }
private object OnDestroyBreakRecord(object args) { SecurityCriticalDataForSet <IntPtr> securityCriticalDataForSet = (SecurityCriticalDataForSet <IntPtr>)args; Invariant.Assert(securityCriticalDataForSet.Value != IntPtr.Zero, "Invalid break record object."); if (!this.Disposed) { Invariant.Assert(this._pageBreakRecords != null, "Collection of break records does not exist."); Invariant.Assert(this._pageBreakRecords.Contains(securityCriticalDataForSet.Value), "Break record does not exist."); try { this.Enter(); PTS.Validate(PTS.FsDestroyPageBreakRecord(this._ptsHost.Context, securityCriticalDataForSet.Value)); } finally { this.Leave(); this._pageBreakRecords.Remove(securityCriticalDataForSet.Value); } } return(null); }
internal PtsHost() { _context = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero); }
public TextFormatterContext() { _ploc = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero); Init(); }
/// <summary> /// Serialization constructor. Marked Protected so derived classes can be deserialized correctly /// The base implementation needs to be called if this class is overridden /// </summary> protected JournalEntryPageFunctionType(SerializationInfo info, StreamingContext context) : base(info, context) { _typeName = new SecurityCriticalDataForSet <string>(info.GetString("_typeName")); }
private void Initialize( bool fTrusted ) { _fTrusted = new SecurityCriticalDataForSet<bool> ( fTrusted ) ; _hwndSubclassHook = new HwndWrapperHook(SubclassWndProc); _handlerLayoutUpdated = new EventHandler(OnLayoutUpdated); _handlerEnabledChanged = new DependencyPropertyChangedEventHandler(OnEnabledChanged); _handlerVisibleChanged = new DependencyPropertyChangedEventHandler(OnVisibleChanged); PresentationSource.AddSourceChangedHandler(this, new SourceChangedEventHandler(OnSourceChanged)); _weakEventDispatcherShutdown = new WeakEventDispatcherShutdown(this, this.Dispatcher); }
private static void DemandIfImageBlocked() { if(!isImageDisabledInitialized) { // a performance optimization to ensure we hit the registry only once in the lifetime of the application isImageDisabled = new SecurityCriticalDataForSet<bool>(SafeSecurityHelper.IsFeatureDisabled(SafeSecurityHelper.KeyToRead.MediaImageDisable)); isImageDisabledInitialized = true; } if (isImageDisabled.Value) { // in case the registry key is '1' then demand MediaPermissionImage.AllImage - not granted in Partial Trust SecurityHelper.DemandMediaPermission(MediaPermissionAudio.NoAudio, MediaPermissionVideo.NoVideo, MediaPermissionImage.AllImage); } else { // Images are enabled. Then, demand permissions for safe imaging - granted in Partial Trust by default SecurityHelper.DemandMediaPermission(MediaPermissionAudio.NoAudio, MediaPermissionVideo.NoVideo, MediaPermissionImage.SafeImage); } }
/// <summary> /// Destroys PTS break record. /// </summary> /// <param name="br">Pointer to PTS Page BR object that should be destroyed.</param> /// <param name="disposing">Whether dispose is caused by explicit call to Dispose.</param> internal void OnPageBreakRecordDisposed(SecurityCriticalDataForSet<IntPtr> br, bool disposing) { Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); // If explicitly disposing (not called during finalization), synchronously // destroy the page break record. if (disposing) { OnDestroyBreakRecord((object)br); } else { // If PtsContext has been already disposed, ignore this call. if (!this.Disposed && !this.Dispatcher.HasShutdownStarted) { // Schedule background operation to destroy the page. this.Dispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(OnDestroyBreakRecord), br); } } }
private void OnDestroyPage(SecurityCriticalDataForSet<IntPtr> ptsPage, bool enterContext) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); // Dispatcher may invoke this operation when PtsContext is already explicitly // disposed. if (!this.Disposed) { Invariant.Assert(_pages != null, "Collection of pages does not exist."); Invariant.Assert(_pages.Contains(ptsPage.Value), "Page does not exist."); // Destroy given page. // It is necessary to enter PTS Context when executing any PTS methods. try { if (enterContext) { Enter(); } PTS.Validate(PTS.FsDestroyPage(_ptsHost.Context, ptsPage.Value)); } finally { if (enterContext) { Leave(); } _pages.Remove(ptsPage.Value); } } }
private FullTextLine(TextFormattingMode textFormattingMode, bool justify) { _textFormattingMode = textFormattingMode; if (justify) { _statusFlags |= StatusFlags.IsJustified; } _metrics = new TextMetrics(); _ploline = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero); }
/// <summary> /// Construct a pixel format from a string that represents the format. /// The purpose of this method is only for deserialization of PixelFormat. /// The preferred way to construct a PixelFormat is with the PixelFormats class. /// </summary> /// <param name="pixelFormatString"></param> internal PixelFormat(string pixelFormatString) { PixelFormatEnum format = PixelFormatEnum.Default; if (pixelFormatString == null) { throw new System.ArgumentNullException("pixelFormatString"); } string upperPixelFormatString = pixelFormatString.ToUpper(System.Globalization.CultureInfo.InvariantCulture); switch (upperPixelFormatString) { case "DEFAULT": format = PixelFormatEnum.Default; break; case "EXTENDED": format = PixelFormatEnum.Extended; break; case "INDEXED1": format = PixelFormatEnum.Indexed1; break; case "INDEXED2": format = PixelFormatEnum.Indexed2; break; case "INDEXED4": format = PixelFormatEnum.Indexed4; break; case "INDEXED8": format = PixelFormatEnum.Indexed8; break; case "BLACKWHITE": format = PixelFormatEnum.BlackWhite; break; case "GRAY2": format = PixelFormatEnum.Gray2; break; case "GRAY4": format = PixelFormatEnum.Gray4; break; case "GRAY8": format = PixelFormatEnum.Gray8; break; case "BGR555": format = PixelFormatEnum.Bgr555; break; case "BGR565": format = PixelFormatEnum.Bgr565; break; case "BGR24": format = PixelFormatEnum.Bgr24; break; case "RGB24": format = PixelFormatEnum.Rgb24; break; case "BGR101010": format = PixelFormatEnum.Bgr101010; break; case "BGR32": format = PixelFormatEnum.Bgr32; break; case "BGRA32": format = PixelFormatEnum.Bgra32; break; case "PBGRA32": format = PixelFormatEnum.Pbgra32; break; case "RGB48": format = PixelFormatEnum.Rgb48; break; case "RGBA64": format = PixelFormatEnum.Rgba64; break; case "PRGBA64": format = PixelFormatEnum.Prgba64; break; case "GRAY16": format = PixelFormatEnum.Gray16; break; case "GRAY32FLOAT": format = PixelFormatEnum.Gray32Float; break; case "RGB128FLOAT": format = PixelFormatEnum.Rgb128Float; break; case "RGBA128FLOAT": format = PixelFormatEnum.Rgba128Float; break; case "PRGBA128FLOAT": format = PixelFormatEnum.Prgba128Float; break; case "CMYK32": format = PixelFormatEnum.Cmyk32; break; default: throw new System.ArgumentException(SR.Get(SRID.Image_BadPixelFormat, pixelFormatString), "pixelFormatString"); } _format = format; _flags = GetPixelFormatFlagsFromEnum(format); _bitsPerPixel = GetBitsPerPixelFromEnum(format); _guidFormat = new SecurityCriticalDataForSet <Guid> (PixelFormat.GetGuidFromFormat(format)); }
internal void OnPageCreated(SecurityCriticalDataForSet<IntPtr> ptsPage) { Invariant.Assert(ptsPage.Value != IntPtr.Zero, "Invalid page object."); Invariant.Assert(!this.Disposed, "PtsContext is already disposed."); Invariant.Assert(!_pages.Contains(ptsPage.Value), "Page already exists."); _pages.Add(ptsPage.Value); }
private FullTextBreakpoint( FullTextState fullText, int firstCharIndex, int maxLineWidth, ref LsBreaks lsbreaks, int breakIndex ) : this() { // According to antons: PTS only uses the width of a feasible break to avoid // clipping in subpage. At the moment, there is no good solution as of how // PTS client would be able to compute this width efficiently using LS. // The work around - although could be conceived would simply be too slow. // The width should therefore be set to the paragraph width for the time being. // // Client of text formatter would simply pass the value of TextBreakpoint.Width // back to PTS pfnFormatLineVariants call. LsLineWidths lineWidths = new LsLineWidths(); lineWidths.upLimLine = maxLineWidth; lineWidths.upStartMainText = fullText.TextStore.Settings.TextIndent; lineWidths.upStartMarker = lineWidths.upStartMainText; lineWidths.upStartTrailing = lineWidths.upLimLine; lineWidths.upMinStartTrailing = lineWidths.upStartTrailing; // construct the correspondent text metrics unsafe { _metrics.Compute( fullText, firstCharIndex, maxLineWidth, null, // collapsingSymbol ref lineWidths, &lsbreaks.plslinfoArray[breakIndex] ); _ploline = new SecurityCriticalDataForSet<IntPtr>(lsbreaks.pplolineArray[breakIndex]); // keep the line penalty handle _penaltyResource = new SecurityCriticalDataForSet<IntPtr>(lsbreaks.plinepenaltyArray[breakIndex]); if (lsbreaks.plslinfoArray[breakIndex].fForcedBreak != 0) _isLineTruncated = true; } }
protected JournalEntryPageFunctionType(SerializationInfo info, StreamingContext context) : base(info, context) { _typeName = new SecurityCriticalDataForSet<string>(info.GetString("_typeName")); }
internal void OnPageBreakRecordCreated(SecurityCriticalDataForSet<IntPtr> br) { Invariant.Assert(br.Value != IntPtr.Zero, "Invalid break record object."); Invariant.Assert(!this.Disposed, "PtsContext is already disposed."); Invariant.Assert(!_pageBreakRecords.Contains(br.Value), "Break record already exists."); _pageBreakRecords.Add(br.Value); }
public CommandWithArgument(RoutedCommand command, object argument) { _command = new SecurityCriticalDataForSet <RoutedCommand>(command); _argument = argument; }
public CommandWithArgument(RoutedCommand command, object argument) { _command = new SecurityCriticalDataForSet<RoutedCommand>(command); _argument = argument; }
internal TraceProvider() { _registrationHandle = new SecurityCriticalDataForSet<ulong>(0); }
/// <summary> /// /// </summary> internal AccessKeyEventArgs(string key, bool isMultiple, bool userInitiated) { _key = key; _isMultiple = isMultiple; _userInitiated = new SecurityCriticalDataForSet <bool>(userInitiated); }
private void FormatLine( FullTextState fullText, int cpFirst, int lineLength, int formatWidth, int finiteFormatWidth, int paragraphWidth, LineFlags lineFlags, FormattedTextSymbols collapsingSymbol ) { _metrics._formatter = fullText.Formatter; Debug.Assert(_metrics._formatter != null); TextStore store = fullText.TextStore; TextStore markerStore = fullText.TextMarkerStore; FormatSettings settings = store.Settings; ParaProp pap = settings.Pap; _paragraphTextDecorations = pap.TextDecorations; if (_paragraphTextDecorations != null) { if (_paragraphTextDecorations.Count != 0) { _defaultTextDecorationsBrush = pap.DefaultTextDecorationsBrush; } else { _paragraphTextDecorations = null; } } // acquiring LS context TextFormatterContext context = _metrics._formatter.AcquireContext(fullText, IntPtr.Zero); LsLInfo plslineInfo = new LsLInfo(); LsLineWidths lineWidths = new LsLineWidths(); fullText.SetTabs(context); int lscpLineLength = 0; // line length in LSCP if (lineLength > 0) { // line length is previously known (e.g. during optimal paragraph formatting), // prefetch lsruns up to the specified line length. lscpLineLength = PrefetchLSRuns(store, cpFirst, lineLength); } IntPtr ploline; LsErr lserr = context.CreateLine( cpFirst, lscpLineLength, formatWidth, lineFlags, IntPtr.Zero, // single-line formatting does not require break record out ploline, out plslineInfo, out _depthQueryMax, out lineWidths ); // Did we exceed the LineServices maximum line width? if (lserr == LsErr.TooLongParagraph) { // Determine where to insert a fake line break. FullTextState.CpMeasured // is a reasonable estimate since we know the nominal widths up to that // point fit within the margin. int cpLimit = fullText.CpMeasured; int subtract = 1; for (;;) { // The line must contain at least one character position. if (cpLimit < 1) { cpLimit = 1; } store.InsertFakeLineBreak(cpLimit); lserr = context.CreateLine( cpFirst, lscpLineLength, formatWidth, lineFlags, IntPtr.Zero, // single-line formatting does not require break record out ploline, out plslineInfo, out _depthQueryMax, out lineWidths ); if (lserr != LsErr.TooLongParagraph || cpLimit == 1) { // We're done or can't chop off any more text. break; } else { // Chop off more text and try again. Double the amount of // text we chop off each time so we retry too many times. cpLimit = fullText.CpMeasured - subtract; subtract *= 2; } } } _ploline.Value = ploline; // get the exception in context before it is released Exception callbackException = context.CallbackException; // release the context context.Release(); if(lserr != LsErr.None) { GC.SuppressFinalize(this); if(callbackException != null) { // rethrow exception thrown in callbacks throw WrapException(callbackException); } else { // throw with LS error codes TextFormatterContext.ThrowExceptionFromLsError(SR.Get(SRID.CreateLineFailure, lserr), lserr); } } // keep context alive at least till here GC.KeepAlive(context); unsafe { // construct text metrics for the line _metrics.Compute( fullText, cpFirst, paragraphWidth, collapsingSymbol, ref lineWidths, &plslineInfo ); } // keep record for min width as we may be formatting min/max _textMinWidthAtTrailing = lineWidths.upMinStartTrailing - _metrics._textStart; if (collapsingSymbol != null) { _collapsingSymbol = collapsingSymbol; _textMinWidthAtTrailing += TextFormatterImp.RealToIdeal(collapsingSymbol.Width); } else { // overflow detection for potential collapsible line if (_metrics._textStart + _metrics._textWidthAtTrailing > finiteFormatWidth) { bool hasOverflowed = true; if (_textFormattingMode == TextFormattingMode.Display) { // apply display-mode rounding before checking for overflow double realWidth = Width; double realFormatWidth = _metrics._formatter.IdealToReal(finiteFormatWidth); hasOverflowed = (TextFormatterImp.CompareReal(realWidth, realFormatWidth, _textFormattingMode) > 0); } if (hasOverflowed) { // line has overflowed _statusFlags |= StatusFlags.HasOverflowed; // let's keep the full text state around. We'll need it later for collapsing _fullText = fullText; } } } if ( fullText != null && ( fullText.KeepState || (_statusFlags & StatusFlags.KeepState) != 0 ) ) { // the state of full text is to be kept after formatting is done _fullText = fullText; } // retain all line properties for interactive operations _ploc = context.Ploc; _cpFirst = cpFirst; _paragraphWidth = paragraphWidth; if (pap.RightToLeft) _statusFlags |= StatusFlags.RightToLeft; if (plslineInfo.fForcedBreak != 0) _statusFlags |= StatusFlags.IsTruncated; // retain the state of plsruns _plsrunVector = store.PlsrunVector; _lsrunsMainText = store.LsrunList; if (markerStore != null) _lsrunsMarkerText = markerStore.LsrunList; // we store the text source in the line in case drawing code calls // the TextSource to find out the text effect index. // _textSource = settings.TextSource; }
[SecurityCritical] private void Initialize(Uri profileUri, bool isStandardProfileUriNotFromUser) { bool tryProfileFromResource = false; if (profileUri == null) { throw new ArgumentNullException("profileUri"); } if (!profileUri.IsAbsoluteUri) { throw new ArgumentException(SR.Get(SRID.UriNotAbsolute), "profileUri"); } _profileUri = new SecurityCriticalData<Uri>(profileUri); _isProfileUriNotFromUser = new SecurityCriticalDataForSet<bool>(isStandardProfileUriNotFromUser); Stream profileStream = null; try { profileStream = WpfWebRequestHelper.CreateRequestAndGetResponseStream(profileUri); } catch (WebException) { // // If we couldn't load the system's default color profile (e.g. in partial trust), load a color profile from // a resource so the image shows up at least. If the user specified a color profile and we weren't // able to load it, we'll fail to avoid letting the user use this resource fallback as a way to discover // files on disk. // if (isStandardProfileUriNotFromUser) { tryProfileFromResource = true; } } if (profileStream == null) { if (tryProfileFromResource) { ResourceManager resourceManager = new ResourceManager(_colorProfileResources, Assembly.GetAssembly(typeof(ColorContext))); byte[] sRGBProfile = (byte[])resourceManager.GetObject(_sRGBProfileName); profileStream = new MemoryStream(sRGBProfile); } else { // // SECURITY WARNING: This exception includes the profile URI which may contain sensitive information. However, as of right now, // this is safe because it can only happen when the URI is given to us by the user. // Invariant.Assert(!isStandardProfileUriNotFromUser); throw new FileNotFoundException(SR.Get(SRID.FileNotFoundExceptionWithFileName, profileUri.AbsolutePath), profileUri.AbsolutePath); } } FromStream(profileStream, profileUri.AbsolutePath);
protected BaseParaClient(BaseParagraph paragraph) : base(paragraph.PtsContext) { _paraHandle = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero); _paragraph = paragraph; }
public HwndWrapper( int classStyle, int style, int exStyle, int x, int y, int width, int height, string name, IntPtr parent, HwndWrapperHook[] hooks) { _ownerThreadID = new SecurityCriticalDataForSet <int>(Thread.CurrentThread.ManagedThreadId); // First, add the set of hooks. This allows the hooks to receive the // messages sent to the window very early in the process. if (hooks != null) { for (int i = 0, iEnd = hooks.Length; i < iEnd; i++) { if (null != hooks[i]) { AddHook(hooks[i]); } } } _wndProc = new SecurityCriticalData <HwndWrapperHook>(new HwndWrapperHook(WndProc)); // We create the HwndSubclass object so that we can use its // window proc directly. We will not be "subclassing" the // window we create. HwndSubclass hwndSubclass = new HwndSubclass(_wndProc.Value); // Register a unique window class for this instance. NativeMethods.WNDCLASSEX_D wc_d = new NativeMethods.WNDCLASSEX_D(); IntPtr hNullBrush = UnsafeNativeMethods.CriticalGetStockObject(NativeMethods.NULL_BRUSH); if (hNullBrush == IntPtr.Zero) { throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error()); } IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle(null); // We need to keep the Delegate object alive through the call to CreateWindowEx(). // Subclass.WndProc will install a better delegate (to the same function) when it // processes the first message. // But this first delegate needs be held alive until then. NativeMethods.WndProc initialWndProc = new NativeMethods.WndProc(hwndSubclass.SubclassWndProc); // The class name is a concat of AppName, ThreadName, and RandomNumber. // Register will fail if the string gets over 255 in length. // So limit each part to a reasonable amount. string appName; if (null != AppDomain.CurrentDomain.FriendlyName && 128 <= AppDomain.CurrentDomain.FriendlyName.Length) { appName = AppDomain.CurrentDomain.FriendlyName.Substring(0, 128); } else { appName = AppDomain.CurrentDomain.FriendlyName; } string threadName; if (null != Thread.CurrentThread.Name && 64 <= Thread.CurrentThread.Name.Length) { threadName = Thread.CurrentThread.Name.Substring(0, 64); } else { threadName = Thread.CurrentThread.Name; } // Create a suitable unique class name. _classAtom = 0; string randomName = Guid.NewGuid().ToString(); string className = String.Format(CultureInfo.InvariantCulture, "HwndWrapper[{0};{1};{2}]", appName, threadName, randomName); wc_d.cbSize = Marshal.SizeOf(typeof(NativeMethods.WNDCLASSEX_D)); wc_d.style = classStyle; wc_d.lpfnWndProc = initialWndProc; wc_d.cbClsExtra = 0; wc_d.cbWndExtra = 0; wc_d.hInstance = hInstance; wc_d.hIcon = IntPtr.Zero; wc_d.hCursor = IntPtr.Zero; wc_d.hbrBackground = hNullBrush; wc_d.lpszMenuName = ""; wc_d.lpszClassName = className; wc_d.hIconSm = IntPtr.Zero; // Register the unique class for this instance. // Note we use a GUID in the name so we are confident that // the class name should be unique. And RegisterClassEx won't // fail (for that reason). _classAtom = UnsafeNativeMethods.RegisterClassEx(wc_d); // call CreateWindow _isInCreateWindow = true; try { _handle = new SecurityCriticalDataClass <IntPtr>(UnsafeNativeMethods.CreateWindowEx(exStyle, className, name, style, x, y, width, height, new HandleRef(null, parent), new HandleRef(null, IntPtr.Zero), new HandleRef(null, IntPtr.Zero), null)); } finally { _isInCreateWindow = false; if (_handle == null || _handle.Value == IntPtr.Zero) { // Because the HwndSubclass is pinned, but the HWND creation failed, // we need to manually clean it up. hwndSubclass.Dispose(); } } GC.KeepAlive(initialWndProc); }
public HwndWrapper( int classStyle, int style, int exStyle, int x, int y, int width, int height, string name, IntPtr parent, HwndWrapperHook[] hooks) { _ownerThreadID = new SecurityCriticalDataForSet<int>(Thread.CurrentThread.ManagedThreadId); // First, add the set of hooks. This allows the hooks to receive the // messages sent to the window very early in the process. if(hooks != null) { for(int i = 0, iEnd = hooks.Length; i < iEnd; i++) { if(null != hooks[i]) AddHook(hooks[i]); } } _wndProc = new SecurityCriticalData<HwndWrapperHook>(new HwndWrapperHook(WndProc)); // We create the HwndSubclass object so that we can use its // window proc directly. We will not be "subclassing" the // window we create. HwndSubclass hwndSubclass = new HwndSubclass(_wndProc.Value); // Register a unique window class for this instance. NativeMethods.WNDCLASSEX_D wc_d = new NativeMethods.WNDCLASSEX_D(); IntPtr hNullBrush = UnsafeNativeMethods.CriticalGetStockObject(NativeMethods.NULL_BRUSH); if (hNullBrush == IntPtr.Zero) { throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error()); } IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle( null ); // We need to keep the Delegate object alive through the call to CreateWindowEx(). // Subclass.WndProc will install a better delegate (to the same function) when it // processes the first message. // But this first delegate needs be held alive until then. NativeMethods.WndProc initialWndProc = new NativeMethods.WndProc(hwndSubclass.SubclassWndProc); // The class name is a concat of AppName, ThreadName, and RandomNumber. // Register will fail if the string gets over 255 in length. // So limit each part to a reasonable amount. string appName; if(null != AppDomain.CurrentDomain.FriendlyName && 128 <= AppDomain.CurrentDomain.FriendlyName.Length) appName = AppDomain.CurrentDomain.FriendlyName.Substring(0, 128); else appName = AppDomain.CurrentDomain.FriendlyName; string threadName; if(null != Thread.CurrentThread.Name && 64 <= Thread.CurrentThread.Name.Length) threadName = Thread.CurrentThread.Name.Substring(0, 64); else threadName = Thread.CurrentThread.Name; // Create a suitable unique class name. _classAtom = 0; string randomName = Guid.NewGuid().ToString(); string className = String.Format(CultureInfo.InvariantCulture, "HwndWrapper[{0};{1};{2}]", appName, threadName, randomName); wc_d.cbSize = Marshal.SizeOf(typeof(NativeMethods.WNDCLASSEX_D)); wc_d.style = classStyle; wc_d.lpfnWndProc = initialWndProc; wc_d.cbClsExtra = 0; wc_d.cbWndExtra = 0; wc_d.hInstance = hInstance; wc_d.hIcon = IntPtr.Zero; wc_d.hCursor = IntPtr.Zero; wc_d.hbrBackground = hNullBrush; wc_d.lpszMenuName = ""; wc_d.lpszClassName = className; wc_d.hIconSm = IntPtr.Zero; // Register the unique class for this instance. // Note we use a GUID in the name so we are confident that // the class name should be unique. And RegisterClassEx won't // fail (for that reason). _classAtom = UnsafeNativeMethods.RegisterClassEx(wc_d); // call CreateWindow _isInCreateWindow = true; try { _handle = new SecurityCriticalDataClass<IntPtr>(UnsafeNativeMethods.CreateWindowEx(exStyle, className, name, style, x, y, width, height, new HandleRef(null,parent), new HandleRef(null,IntPtr.Zero), new HandleRef(null,IntPtr.Zero), null)); } finally { _isInCreateWindow = false; if(_handle == null || _handle.Value == IntPtr.Zero) { new UIPermission(UIPermissionWindow.AllWindows).Assert(); //BlessedAssert to call Dispose try { // Because the HwndSubclass is pinned, but the HWND creation failed, // we need to manually clean it up. hwndSubclass.Dispose(); } finally { CodeAccessPermission.RevertAssert(); } } } GC.KeepAlive(initialWndProc); }
public TextFormatterContext() { _ploc = new SecurityCriticalDataForSet <IntPtr>(IntPtr.Zero); Init(); }
internal AccessKeyEventArgs(string key, bool isMultiple, bool userInitiated) { _key = key; _isMultiple = isMultiple; _userInitiated = new SecurityCriticalDataForSet<bool>(userInitiated); }
private PtsPage() { _ptsPage = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero); }
static AssemblyFilter() { _disallowedListExtracted = new SecurityCriticalDataForSet<bool>(false); _assemblyList = new SecurityCriticalDataForSet<System.Collections.Generic.List<string>>(new System.Collections.Generic.List<string>()); }