internal static RuntimeConfig GetConfig(VirtualPath path) { if (!HttpConfigurationSystem.UseHttpConfigurationSystem) { return GetClientRuntimeConfig(); } return CachedPathData.GetVirtualPathData(path, true).RuntimeConfig; }
internal static RuntimeConfig GetRootWebConfig() { if (!HttpConfigurationSystem.UseHttpConfigurationSystem) { return GetClientRuntimeConfig(); } return CachedPathData.GetRootWebPathData().RuntimeConfig; }
// // GetMachineConfig() - returns the machine configuration. // // For config derived from ConfigurationSection, this will either // return a non-null object or throw an exception. // // For config implemented with IConfigurationSectionHandler, this // may return null, non-null, or throw an exception. // static internal RuntimeConfig GetMachineConfig() { if (!HttpConfigurationSystem.UseHttpConfigurationSystem) { return(GetClientRuntimeConfig()); } return(CachedPathData.GetMachinePathData().RuntimeConfig); }
// GetAppSection // // Get the Config for a specific path // static internal object GetApplicationSection(string sectionName) { Debug.Assert(UseHttpConfigurationSystem, "UseHttpConfigurationSystem"); CachedPathData pathData; pathData = CachedPathData.GetApplicationPathData(); return(pathData.ConfigRecord.GetSection(sectionName)); }
// GetSection // // Get the Config for a specific path // static internal object GetSection(string sectionName, VirtualPath path) { Debug.Assert(UseHttpConfigurationSystem, "UseHttpConfigurationSystem"); CachedPathData pathData; pathData = CachedPathData.GetVirtualPathData(path, true); return(pathData.ConfigRecord.GetSection(sectionName)); }
/// <summary> /// Calculates the paths and stores them into a structure given by the argument <paramref name="cachedPathData"/>. /// </summary> /// <param name="scatterSymbol">ScatterSymbol, already processed via <see cref="CalculateOverriddenScatterSymbol"/></param> /// <param name="symbolSize">The size of the symbol for which to calculate the paths.</param> /// <param name="cachedPathData">The cached path data.</param> /// <returns>True if new paths have been calculated; false if the previously cached data could be used.</returns> private bool CalculatePaths(IScatterSymbol scatterSymbol, double symbolSize, ref CachedPathData cachedPathData) { if (symbolSize == cachedPathData.SymbolSize) { return(false); // we assume that the structure already contains valid data. } cachedPathData.SymbolSize = symbolSize; cachedPathData.FillPath = cachedPathData.FramePath = cachedPathData.InsetPath = null; if (scatterSymbol is NoSymbol) { return(true); } double?overrideRelativeStructureWidth = null; if (_overrideStructureWidthOffset.HasValue || _overrideStructureWidthFactor.HasValue) { overrideRelativeStructureWidth = (_overrideStructureWidthFactor ?? 0) + (_overrideStructureWidthOffset ?? 0) / symbolSize; } scatterSymbol.CalculatePolygons(overrideRelativeStructureWidth, out var framePolygon, out var insetPolygon, out var fillPolygon); // calculate the path only once if (null != insetPolygon) { cachedPathData.InsetPath = new GraphicsPath(); foreach (var list in insetPolygon) { cachedPathData.InsetPath.AddPolygon(ToPointFArray(list, symbolSize)); } } if (null != fillPolygon) { cachedPathData.FillPath = new GraphicsPath(); foreach (var list in fillPolygon) { cachedPathData.FillPath.AddPolygon(ToPointFArray(list, symbolSize)); } } if (null != framePolygon) { cachedPathData.FramePath = new GraphicsPath(); foreach (var list in framePolygon) { cachedPathData.FramePath.AddPolygon(ToPointFArray(list, symbolSize)); } } return(true); }
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata, Processed2DPlotData prevItemData, Processed2DPlotData nextItemData) { // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) { _skipFreq = 1; } if (_scatterSymbol is NoSymbol) { return; } var cachedPathData = new CachedPathData(); var cachedBrushData = new CachedBrushData(); PlotRangeList rangeList = pdata.RangeList; PointF[] plotPositions = pdata.PlotPointsInAbsoluteLayerCoordinates; if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY)) { plotPositions = Processed2DPlotData.GetPlotPointsInAbsoluteLayerCoordinatesWithShift(pdata, layer, _cachedLogicalShiftX, _cachedLogicalShiftY); } // Calculate current scatterSymbol overridden with frame and inset var scatterSymbol = CalculateOverriddenScatterSymbol(); if (_ignoreMissingDataPoints) { // in case we ignore the missing points, all ranges can be plotted // as one range, i.e. continuously // for this, we create the totalRange, which contains all ranges var totalRange = new PlotRangeCompound(rangeList); PaintOneRange(g, layer, plotPositions, totalRange, scatterSymbol, ref cachedPathData, ref cachedBrushData); } else // we not ignore missing points, so plot all ranges separately { for (int i = 0; i < rangeList.Count; i++) { PaintOneRange(g, layer, plotPositions, rangeList[i], scatterSymbol, ref cachedPathData, ref cachedBrushData); } } cachedBrushData.Clear(); cachedPathData.Clear(); }
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds) { if (_scatterSymbol is NoSymbol) { return(bounds); } var cachedPathData = new CachedPathData(); var cachedBrushData = new CachedBrushData(); var scatterSymbol = CalculateOverriddenScatterSymbol(); CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); GraphicsState gs = g.Save(); g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height); if (null != cachedPathData.InsetPath) { g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); } if (null != cachedPathData.FillPath) { g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); } if (null != cachedPathData.FramePath) { g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); } cachedBrushData.Clear(); cachedPathData.Clear(); g.Restore(gs); if (SymbolSize > bounds.Height) { bounds.Inflate(0, (float)(SymbolSize - bounds.Height)); } return(bounds); }
private static NameValueCollection GetAppSettingsSection() { // DevDiv #353926 - Fall back to reading App.config if System.Web types are being consumed outside an ASP.NET application if (!HostingEnvironment.IsHosted) { return(ConfigurationManager.AppSettings); } // Check the app-level config. Ignore configuration errors CachedPathData appPathData = CachedPathData.GetApplicationPathData(); if (appPathData != null && appPathData.ConfigRecord != null) { return(appPathData.ConfigRecord.GetSection("appSettings") as NameValueCollection); } // nothing found return(null); }
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds) { if (_scatterSymbol is NoSymbol) return bounds; var cachedPathData = new CachedPathData(); var cachedBrushData = new CachedBrushData(); var scatterSymbol = CalculateOverriddenScatterSymbol(); CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); GraphicsState gs = g.Save(); g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height); if (null != cachedPathData.InsetPath) g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); if (null != cachedPathData.FillPath) g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); if (null != cachedPathData.FramePath) g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); cachedBrushData.Clear(); cachedPathData.Clear(); g.Restore(gs); if (this.SymbolSize > bounds.Height) bounds.Inflate(0, (float)(this.SymbolSize - bounds.Height)); return bounds; }
private static bool IsUserAllowedToFile(HttpContext context, string fileName) { //////////////////////////////////////////////////////////// // Step 1: Check if this is WindowsLogin // It's not a windows authenticated user: allow access if (!IsWindowsIdentity(context)) { return(true); } if (fileName == null) { fileName = context.Request.PhysicalPathInternal; } bool isAnonymousUser = (context.User == null || !context.User.Identity.IsAuthenticated); CachedPathData pathData = null; int iAccess = 3; HttpVerb verb = context.Request.HttpVerb; if (verb == HttpVerb.GET || verb == HttpVerb.POST || verb == HttpVerb.HEAD || context.Request.HttpMethod == "OPTIONS") { iAccess = 1; //////////////////////////////////////////////////////////// // iff it's a GET or POST or HEAD or OPTIONs verb, we can use the cached result if (!CachedPathData.DoNotCacheUrlMetadata) { pathData = context.GetConfigurationPathData(); // as a perf optimization, we cache results for annoymous access // to CachedPathData.PhysicalPath, and avoid doing the full check if (!StringUtil.EqualsIgnoreCase(fileName, pathData.PhysicalPath)) { // set to null so we don't attempt to update it after the full check below pathData = null; } else { if (pathData.AnonymousAccessAllowed) // fast path when everyone has access { Debug.Trace("FAM", "IsUserAllowedToFile: pathData.AnonymousAccessAllowed"); return(true); } if (pathData.AnonymousAccessChecked && isAnonymousUser) // fast path for anonymous user // another thread could be modifying CachedPathData, so return the // value of AnonymousAccessAllowed instead of assuming it is false { Debug.Trace("FAM", "IsUserAllowedToFile: pathData.AnonymousAccessChecked && isAnonymousUser"); return(pathData.AnonymousAccessAllowed); } } } } // Step 3: Check the cache for the file-security-descriptor // for the requested file bool freeDescriptor; FileSecurityDescriptorWrapper oSecDesc = GetFileSecurityDescriptorWrapper(fileName, out freeDescriptor); //////////////////////////////////////////////////////////// // Step 4: Check if access is allowed bool fAllowed; if (iAccess == 1) // iff it's a GET or POST or HEAD or OPTIONs verb, we can cache the result { if (oSecDesc._AnonymousAccessChecked && isAnonymousUser) { Debug.Trace("FAM", "IsUserAllowedToFile: oSecDesc._AnonymousAccessChecked && isAnonymousUser"); fAllowed = oSecDesc._AnonymousAccess; } else { Debug.Trace("FAM", "IsUserAllowedToFile: calling oSecDesc.IsAccessAllowed with iAccess == 1"); fAllowed = oSecDesc.IsAccessAllowed(context.WorkerRequest.GetUserToken(), iAccess); } if (!oSecDesc._AnonymousAccessChecked && isAnonymousUser) { oSecDesc._AnonymousAccess = fAllowed; oSecDesc._AnonymousAccessChecked = true; } // Cache results in CachedPathData if the file exists and annonymous access has been checked. // Note that if CachedPathData.Exists is false, then it does not have a dependency on the file path, // and won't be expunged if the file changes. if (pathData != null && pathData.Exists && oSecDesc._AnonymousAccessChecked) { Debug.Trace("FAM", "IsUserAllowedToFile: updating pathData"); pathData.AnonymousAccessAllowed = oSecDesc._AnonymousAccess; pathData.AnonymousAccessChecked = true; } } else { Debug.Trace("FAM", "IsUserAllowedToFile: calling oSecDesc.IsAccessAllowed with iAccess != 1"); fAllowed = oSecDesc.IsAccessAllowed(context.WorkerRequest.GetUserToken(), iAccess); // don't cache this anywhere } //////////////////////////////////////////////////////////// // Step 5: Free the security descriptor if adding to cache failed if (freeDescriptor) { oSecDesc.FreeSecurityDescriptor(); } if (fAllowed) { WebBaseEvent.RaiseSystemEvent(null, WebEventCodes.AuditFileAuthorizationSuccess); } else { if (!isAnonymousUser) { WebBaseEvent.RaiseSystemEvent(null, WebEventCodes.AuditFileAuthorizationFailure); } } return(fAllowed); }
/// <summary> /// Calculates the paths and stores them into a structure given by the argument <paramref name="cachedPathData"/>. /// </summary> /// <param name="scatterSymbol">ScatterSymbol, already processed via <see cref="CalculateOverriddenScatterSymbol"/></param> /// <param name="symbolSize">The size of the symbol for which to calculate the paths.</param> /// <param name="cachedPathData">The cached path data.</param> /// <returns>True if new paths have been calculated; false if the previously cached data could be used.</returns> private bool CalculatePaths(IScatterSymbol scatterSymbol, double symbolSize, ref CachedPathData cachedPathData) { if (symbolSize == cachedPathData.SymbolSize) return false; // we assume that the structure already contains valid data. cachedPathData.SymbolSize = symbolSize; cachedPathData.FillPath = cachedPathData.FramePath = cachedPathData.InsetPath = null; if (scatterSymbol is NoSymbol) { return true; } List<List<ClipperLib.IntPoint>> insetPolygon = null; List<List<ClipperLib.IntPoint>> framePolygon = null; List<List<ClipperLib.IntPoint>> fillPolygon = null; double? overrideRelativeStructureWidth = null; if (_overrideStructureWidthOffset.HasValue || _overrideStructureWidthFactor.HasValue) { overrideRelativeStructureWidth = (_overrideStructureWidthFactor ?? 0) + (_overrideStructureWidthOffset ?? 0) / symbolSize; } scatterSymbol.CalculatePolygons(overrideRelativeStructureWidth, out framePolygon, out insetPolygon, out fillPolygon); // calculate the path only once if (null != insetPolygon) { cachedPathData.InsetPath = new GraphicsPath(); foreach (var list in insetPolygon) cachedPathData.InsetPath.AddPolygon(ToPointFArray(list, symbolSize)); } if (null != fillPolygon) { cachedPathData.FillPath = new GraphicsPath(); foreach (var list in fillPolygon) cachedPathData.FillPath.AddPolygon(ToPointFArray(list, symbolSize)); } if (null != framePolygon) { cachedPathData.FramePath = new GraphicsPath(); foreach (var list in framePolygon) cachedPathData.FramePath.AddPolygon(ToPointFArray(list, symbolSize)); } return true; }
/// <summary> /// Calculates the brushes. /// </summary> /// <param name="scatterSymbol">ScatterSymbol, already processed via <see cref="CalculateOverriddenScatterSymbol"/></param> /// <param name="plotColor">The current plot color.</param> /// <param name="cachedPathData">The cached path data.</param> /// <param name="cachedBrushData">Cached brush data, which will be filled-in during this call..</param> /// <returns>True if new cached brush data were calculated; false if the cached data were up-to-date.</returns> private bool CalculateBrushes(IScatterSymbol scatterSymbol, NamedColor plotColor, CachedPathData cachedPathData, ref CachedBrushData cachedBrushData) { if (plotColor == cachedBrushData.PlotColor) { return(false); // cached data valid and could be reused; } cachedBrushData.Clear(); cachedBrushData.PlotColor = plotColor; var plotColorInfluence = _overridePlotColorInfluence ?? scatterSymbol.PlotColorInfluence; if (null != cachedPathData.InsetPath) { var insetColor = _overrideInsetColor ?? scatterSymbol.Inset.Color; if (plotColorInfluence.HasFlag(PlotColorInfluence.InsetColorFull)) { insetColor = plotColor; } else if (plotColorInfluence.HasFlag(PlotColorInfluence.InsetColorPreserveAlpha)) { insetColor = plotColor.NewWithAlphaValue(insetColor.Color.A); } cachedBrushData.InsetBrush = new SolidBrush(insetColor); } if (null != cachedPathData.FillPath) { var fillColor = _overrideFillColor ?? scatterSymbol.FillColor; if (plotColorInfluence.HasFlag(PlotColorInfluence.FillColorFull)) { fillColor = plotColor; } else if (plotColorInfluence.HasFlag(PlotColorInfluence.FillColorPreserveAlpha)) { fillColor = plotColor.NewWithAlphaValue(fillColor.Color.A); } cachedBrushData.FillBrush = new SolidBrush(fillColor); } if (null != cachedPathData.FramePath) { var frameColor = _overrideFrameColor ?? scatterSymbol.Frame.Color; if (plotColorInfluence.HasFlag(PlotColorInfluence.FrameColorFull)) { frameColor = plotColor; } else if (plotColorInfluence.HasFlag(PlotColorInfluence.FrameColorPreserveAlpha)) { frameColor = plotColor.NewWithAlphaValue(frameColor.Color.A); } cachedBrushData.FrameBrush = new SolidBrush(frameColor); } return(true); }
private void PaintOneRange( Graphics g, IPlotArea layer, PointF[] plotPositions, IPlotRange range, IScatterSymbol scatterSymbol, ref CachedPathData cachedPathData, ref CachedBrushData cachedBrushData) { var ptArray = plotPositions; float xpos = 0, ypos = 0; float xdiff, ydiff; int originalIndex; // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size { // calculate the path only once CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); for (int plotPointIndex = range.LowerBound; plotPointIndex < range.UpperBound; plotPointIndex += _skipFreq) { xdiff = ptArray[plotPointIndex].X - xpos; ydiff = ptArray[plotPointIndex].Y - ypos; xpos = ptArray[plotPointIndex].X; ypos = ptArray[plotPointIndex].Y; g.TranslateTransform(xdiff, ydiff); if (null != cachedPathData.InsetPath) { g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); } if (null != cachedPathData.FillPath) { g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); } if (null != cachedPathData.FramePath) { g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); } } // end for } else // using a variable symbol size or variable symbol color { CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); for (int plotPointIndex = range.LowerBound; plotPointIndex < range.UpperBound; plotPointIndex += _skipFreq) { originalIndex = range.GetOriginalRowIndexFromPlotPointIndex(plotPointIndex); if (null == _cachedColorForIndexFunction) { double customSymbolSize = _cachedSymbolSizeForIndexFunction(originalIndex); CalculatePaths(scatterSymbol, customSymbolSize, ref cachedPathData); } else { double customSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalIndex); var customSymbolColor = _cachedColorForIndexFunction(originalIndex); CalculatePaths(scatterSymbol, customSymbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B), cachedPathData, ref cachedBrushData); } xdiff = ptArray[plotPointIndex].X - xpos; ydiff = ptArray[plotPointIndex].Y - ypos; xpos = ptArray[plotPointIndex].X; ypos = ptArray[plotPointIndex].Y; g.TranslateTransform(xdiff, ydiff); if (null != cachedPathData.InsetPath) { g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); } if (null != cachedPathData.FillPath) { g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); } if (null != cachedPathData.FramePath) { g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); } } } g.Restore(gs); // Restore the graphics state }
private static void EnsureSettingsLoaded() { if (!_settingsInitialized) { lock (_appSettingsLock) { if (!_settingsInitialized) { NameValueCollection section = null; try { CachedPathData applicationPathData = CachedPathData.GetApplicationPathData(); if ((applicationPathData != null) && (applicationPathData.ConfigRecord != null)) { section = applicationPathData.ConfigRecord.GetSection("appSettings") as NameValueCollection; } } finally { if ((section == null) || !bool.TryParse(section["aspnet:UseHostHeaderForRequestUrl"], out _useHostHeaderForRequestUrl)) { _useHostHeaderForRequestUrl = false; } if ((section == null) || !bool.TryParse(section["aspnet:ScriptResourceAllowNonJsFiles"], out _scriptResourceAllowNonJsFiles)) { _scriptResourceAllowNonJsFiles = false; } if ((section == null) || !bool.TryParse(section["aspnet:UseLegacyEncryption"], out _useLegacyEncryption)) { _useLegacyEncryption = false; } if ((section == null) || !bool.TryParse(section["aspnet:UseLegacyMachineKeyEncryption"], out _useLegacyMachineKeyEncryption)) { _useLegacyMachineKeyEncryption = false; } if ((section == null) || !bool.TryParse(section["aspnet:AllowRelaxedRelativeUrl"], out _allowRelaxedRelativeUrl)) { _allowRelaxedRelativeUrl = false; } if ((section == null) || !bool.TryParse(section["aspnet:RestrictXmlControls"], out _restrictXmlControls)) { _restrictXmlControls = false; } if ((section == null) || !bool.TryParse(section["aspnet:UseLegacyFormsAuthenticationTicketCompatibility"], out _useLegacyFormsAuthenticationTicketCompatibility)) { _useLegacyFormsAuthenticationTicketCompatibility = false; } if ((section == null) || !bool.TryParse(section["aspnet:AllowRelaxedHttpUserName"], out _allowRelaxedHttpUserName)) { _allowRelaxedHttpUserName = false; } if (((section == null) || !int.TryParse(section["aspnet:MaxHttpCollectionKeys"], out _maxHttpCollectionKeys)) || (_maxHttpCollectionKeys < 0)) { _maxHttpCollectionKeys = 0x3e8; } if (((section == null) || !int.TryParse(section["aspnet:MaxJsonDeserializerMembers"], out _maxJsonDeserializerMembers)) || (_maxJsonDeserializerMembers < 0)) { _maxJsonDeserializerMembers = 0x3e8; } _settingsInitialized = true; } } } } }
internal static object GetSection(string sectionName, VirtualPath path) { return(CachedPathData.GetVirtualPathData(path, true).ConfigRecord.GetSection(sectionName)); }
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata, Processed2DPlotData prevItemData, Processed2DPlotData nextItemData) { // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) _skipFreq = 1; if (this._scatterSymbol is NoSymbol) return; CachedPathData cachedPathData = new CachedPathData(); CachedBrushData cachedBrushData = new CachedBrushData(); PlotRangeList rangeList = pdata.RangeList; PointF[] plotPositions = pdata.PlotPointsInAbsoluteLayerCoordinates; if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY)) { plotPositions = Processed2DPlotData.GetPlotPointsInAbsoluteLayerCoordinatesWithShift(pdata, layer, _cachedLogicalShiftX, _cachedLogicalShiftY); } // Calculate current scatterSymbol overridden with frame and inset var scatterSymbol = CalculateOverriddenScatterSymbol(); if (this._ignoreMissingDataPoints) { // in case we ignore the missing points, all ranges can be plotted // as one range, i.e. continuously // for this, we create the totalRange, which contains all ranges var totalRange = new PlotRangeCompound(rangeList); this.PaintOneRange(g, layer, plotPositions, totalRange, scatterSymbol, ref cachedPathData, ref cachedBrushData); } else // we not ignore missing points, so plot all ranges separately { for (int i = 0; i < rangeList.Count; i++) { this.PaintOneRange(g, layer, plotPositions, rangeList[i], scatterSymbol, ref cachedPathData, ref cachedBrushData); } } cachedBrushData.Clear(); cachedPathData.Clear(); }
private void PaintOneRange( Graphics g, IPlotArea layer, PointF[] plotPositions, IPlotRange range, IScatterSymbol scatterSymbol, ref CachedPathData cachedPathData, ref CachedBrushData cachedBrushData) { var ptArray = plotPositions; float xpos = 0, ypos = 0; float xdiff, ydiff; int originalIndex; // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size { // calculate the path only once CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); for (int plotPointIndex = range.LowerBound; plotPointIndex < range.UpperBound; plotPointIndex += _skipFreq) { xdiff = ptArray[plotPointIndex].X - xpos; ydiff = ptArray[plotPointIndex].Y - ypos; xpos = ptArray[plotPointIndex].X; ypos = ptArray[plotPointIndex].Y; g.TranslateTransform(xdiff, ydiff); if (null != cachedPathData.InsetPath) g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); if (null != cachedPathData.FillPath) g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); if (null != cachedPathData.FramePath) g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); } // end for } else // using a variable symbol size or variable symbol color { CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData); for (int plotPointIndex = range.LowerBound; plotPointIndex < range.UpperBound; plotPointIndex += _skipFreq) { originalIndex = range.GetOriginalRowIndexFromPlotPointIndex(plotPointIndex); if (null == _cachedColorForIndexFunction) { double customSymbolSize = _cachedSymbolSizeForIndexFunction(originalIndex); CalculatePaths(scatterSymbol, customSymbolSize, ref cachedPathData); } else { double customSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalIndex); var customSymbolColor = _cachedColorForIndexFunction(originalIndex); CalculatePaths(scatterSymbol, customSymbolSize, ref cachedPathData); CalculateBrushes(scatterSymbol, NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B), cachedPathData, ref cachedBrushData); } xdiff = ptArray[plotPointIndex].X - xpos; ydiff = ptArray[plotPointIndex].Y - ypos; xpos = ptArray[plotPointIndex].X; ypos = ptArray[plotPointIndex].Y; g.TranslateTransform(xdiff, ydiff); if (null != cachedPathData.InsetPath) g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath); if (null != cachedPathData.FillPath) g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath); if (null != cachedPathData.FramePath) g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath); } } g.Restore(gs); // Restore the graphics state }
/// <summary> /// Calculates the brushes. /// </summary> /// <param name="scatterSymbol">ScatterSymbol, already processed via <see cref="CalculateOverriddenScatterSymbol"/></param> /// <param name="plotColor">The current plot color.</param> /// <param name="cachedPathData">The cached path data.</param> /// <param name="cachedBrushData">Cached brush data, which will be filled-in during this call..</param> /// <returns>True if new cached brush data were calculated; false if the cached data were up-to-date.</returns> private bool CalculateBrushes(IScatterSymbol scatterSymbol, NamedColor plotColor, CachedPathData cachedPathData, ref CachedBrushData cachedBrushData) { if (plotColor == cachedBrushData.PlotColor) return false; // cached data valid and could be reused; cachedBrushData.Clear(); cachedBrushData.PlotColor = plotColor; var plotColorInfluence = _overridePlotColorInfluence ?? scatterSymbol.PlotColorInfluence; if (null != cachedPathData.InsetPath) { var insetColor = _overrideInsetColor ?? scatterSymbol.Inset.Color; if (plotColorInfluence.HasFlag(PlotColorInfluence.InsetColorFull)) insetColor = plotColor; else if (plotColorInfluence.HasFlag(PlotColorInfluence.InsetColorPreserveAlpha)) insetColor = plotColor.NewWithAlphaValue(insetColor.Color.A); cachedBrushData.InsetBrush = new SolidBrush(insetColor); } if (null != cachedPathData.FillPath) { var fillColor = _overrideFillColor ?? scatterSymbol.FillColor; if (plotColorInfluence.HasFlag(PlotColorInfluence.FillColorFull)) fillColor = plotColor; else if (plotColorInfluence.HasFlag(PlotColorInfluence.FillColorPreserveAlpha)) fillColor = plotColor.NewWithAlphaValue(fillColor.Color.A); cachedBrushData.FillBrush = new SolidBrush(fillColor); } if (null != cachedPathData.FramePath) { var frameColor = _overrideFrameColor ?? scatterSymbol.Frame.Color; if (plotColorInfluence.HasFlag(PlotColorInfluence.FrameColorFull)) frameColor = plotColor; else if (plotColorInfluence.HasFlag(PlotColorInfluence.FrameColorPreserveAlpha)) frameColor = plotColor.NewWithAlphaValue(frameColor.Color.A); cachedBrushData.FrameBrush = new SolidBrush(frameColor); } return true; }
internal static object GetApplicationSection(string sectionName) { return(CachedPathData.GetApplicationPathData().ConfigRecord.GetSection(sectionName)); }
private static bool IsUserAllowedToFile(HttpContext context, string fileName) { bool flag2; bool flag3; if (!IsWindowsIdentity(context)) { return(true); } if (fileName == null) { fileName = context.Request.PhysicalPathInternal; } bool flag = (context.User == null) || !context.User.Identity.IsAuthenticated; CachedPathData configurationPathData = null; int iAccess = 3; HttpVerb httpVerb = context.Request.HttpVerb; if (((httpVerb == HttpVerb.GET) || (httpVerb == HttpVerb.POST)) || ((httpVerb == HttpVerb.HEAD) || (context.Request.HttpMethod == "OPTIONS"))) { iAccess = 1; if (!CachedPathData.DoNotCacheUrlMetadata) { configurationPathData = context.GetConfigurationPathData(); if (!StringUtil.EqualsIgnoreCase(fileName, configurationPathData.PhysicalPath)) { configurationPathData = null; } else { if (configurationPathData.AnonymousAccessAllowed) { return(true); } if (configurationPathData.AnonymousAccessChecked && flag) { return(configurationPathData.AnonymousAccessAllowed); } } } } FileSecurityDescriptorWrapper fileSecurityDescriptorWrapper = GetFileSecurityDescriptorWrapper(fileName, out flag2); if (iAccess == 1) { if (fileSecurityDescriptorWrapper._AnonymousAccessChecked && flag) { flag3 = fileSecurityDescriptorWrapper._AnonymousAccess; } else { flag3 = fileSecurityDescriptorWrapper.IsAccessAllowed(context.WorkerRequest.GetUserToken(), iAccess); } if (!fileSecurityDescriptorWrapper._AnonymousAccessChecked && flag) { fileSecurityDescriptorWrapper._AnonymousAccess = flag3; fileSecurityDescriptorWrapper._AnonymousAccessChecked = true; } if (((configurationPathData != null) && configurationPathData.Exists) && fileSecurityDescriptorWrapper._AnonymousAccessChecked) { configurationPathData.AnonymousAccessAllowed = fileSecurityDescriptorWrapper._AnonymousAccess; configurationPathData.AnonymousAccessChecked = true; } } else { flag3 = fileSecurityDescriptorWrapper.IsAccessAllowed(context.WorkerRequest.GetUserToken(), iAccess); } if (flag2) { fileSecurityDescriptorWrapper.FreeSecurityDescriptor(); } if (flag3) { WebBaseEvent.RaiseSystemEvent(null, 0xfa4); return(flag3); } if (!flag) { WebBaseEvent.RaiseSystemEvent(null, 0xfa8); } return(flag3); }