internal void Initialize(string prefix, InitializationContext context)
{
Initialize(prefix, m_rdlRowIndex, m_rdlColumnIndex, isCustomProperty: false, context);
}
internal void Initialize(InitializationContext context)
{
if (m_x != null)
{
m_x.Initialize("X", context);
context.ExprHostBuilder.ChartDataPointValueX(m_x);
}
if (m_y != null)
{
m_y.Initialize("Y", context);
context.ExprHostBuilder.ChartDataPointValueY(m_y);
}
if (m_size != null)
{
m_size.Initialize("Size", context);
context.ExprHostBuilder.ChartDataPointValueSize(m_size);
}
if (m_high != null)
{
m_high.Initialize("High", context);
context.ExprHostBuilder.ChartDataPointValueHigh(m_high);
}
if (m_low != null)
{
m_low.Initialize("Low", context);
context.ExprHostBuilder.ChartDataPointValueLow(m_low);
}
if (m_start != null)
{
m_start.Initialize("Start", context);
context.ExprHostBuilder.ChartDataPointValueStart(m_start);
}
if (m_end != null)
{
m_end.Initialize("End", context);
context.ExprHostBuilder.ChartDataPointValueEnd(m_end);
}
if (m_mean != null)
{
m_mean.Initialize("Mean", context);
context.ExprHostBuilder.ChartDataPointValueMean(m_mean);
}
if (m_median != null)
{
m_median.Initialize("Median", context);
context.ExprHostBuilder.ChartDataPointValueMedian(m_median);
}
if (m_highlightX != null)
{
m_highlightX.Initialize("HighlightX", context);
context.ExprHostBuilder.ChartDataPointValueHighlightX(m_highlightX);
}
if (m_highlightY != null)
{
m_highlightY.Initialize("HighlightY", context);
context.ExprHostBuilder.ChartDataPointValueHighlightY(m_highlightY);
}
if (m_highlightSize != null)
{
m_highlightSize.Initialize("HighlightSize", context);
context.ExprHostBuilder.ChartDataPointValueHighlightSize(m_highlightSize);
}
if (m_formatX != null)
{
m_formatX.Initialize("FormatX", context);
context.ExprHostBuilder.ChartDataPointValueFormatX(m_formatX);
}
if (m_formatY != null)
{
m_formatY.Initialize("FormatY", context);
context.ExprHostBuilder.ChartDataPointValueFormatY(m_formatY);
}
if (m_formatSize != null)
{
m_formatSize.Initialize("FormatSize", context);
context.ExprHostBuilder.ChartDataPointValueFormatSize(m_formatSize);
}
if (m_currencyLanguageX != null)
{
m_currencyLanguageX.Initialize("CurrencyLanguageX", context);
context.ExprHostBuilder.ChartDataPointValueCurrencyLanguageX(m_currencyLanguageX);
}
if (m_currencyLanguageY != null)
{
m_currencyLanguageY.Initialize("CurrencyLanguageY", context);
context.ExprHostBuilder.ChartDataPointValueCurrencyLanguageY(m_currencyLanguageY);
}
if (m_currencyLanguageSize != null)
{
m_currencyLanguageSize.Initialize("CurrencyLanguageSize", context);
context.ExprHostBuilder.ChartDataPointValueCurrencyLanguageSize(m_currencyLanguageSize);
}
}
public void InitializeEndpoints(GameObject go)
{
try
{
var httpSecurity = new HttpSecurity();
var context = new InitializationContext(httpSecurity, Settings.FromLanguage, Settings.Language);
CreateEndpoints(go, context);
AllEndpoints = AllEndpoints
.OrderBy(x => x.Error != null)
.ThenBy(x => x.Endpoint.FriendlyName)
.ToList();
var primaryEndpoint = AllEndpoints.FirstOrDefault(x => x.Endpoint.Id == Settings.ServiceEndpoint);
if (primaryEndpoint != null)
{
if (primaryEndpoint.Error != null)
{
XuaLogger.AutoTranslator.Error(primaryEndpoint.Error, "Error occurred during the initialization of the selected translate endpoint.");
}
else
{
CurrentEndpoint = primaryEndpoint;
}
}
else if (!string.IsNullOrEmpty(Settings.ServiceEndpoint))
{
XuaLogger.AutoTranslator.Error($"Could not find the configured endpoint '{Settings.ServiceEndpoint}'.");
}
if (Settings.DisableCertificateValidation)
{
XuaLogger.AutoTranslator.Info($"Disabling certificate checks for endpoints because of configuration.");
ServicePointManager.ServerCertificateValidationCallback += (a1, a2, a3, a4) => true;
}
else
{
var callback = httpSecurity.GetCertificateValidationCheck();
if (callback != null && !Features.SupportsNet4x)
{
XuaLogger.AutoTranslator.Info($"Disabling certificate checks for endpoints because a .NET 3.x runtime is used.");
ServicePointManager.ServerCertificateValidationCallback += callback;
}
else
{
XuaLogger.AutoTranslator.Info($"Not disabling certificate checks for endpoints because a .NET 4.x runtime is used.");
}
}
// save config because the initialization phase of plugins may have changed the config
Settings.Save();
}
catch (Exception e)
{
XuaLogger.AutoTranslator.Error(e, "An error occurred while constructing endpoints. Shutting plugin down.");
Settings.IsShutdown = true;
}
}
public bool AppliesTo(Type implementationType, InitializationContext context) => this.predicate(context);
public void Initialize(InitializationContext context, int index)
{
context.ExprHostBuilder.MapTileStart(index.ToString(CultureInfo.InvariantCulture.NumberFormat));
this.m_exprHostID = context.ExprHostBuilder.MapTileEnd();
}
internal override void Initialize(InitializationContext context)
{
base.Initialize(context);
if (m_action != null)
{
m_action.Initialize(context);
}
if (m_barStart != null)
{
m_barStart.Initialize("BarStart", context);
context.ExprHostBuilder.GaugePointerBarStart(m_barStart);
}
if (m_distanceFromScale != null)
{
m_distanceFromScale.Initialize("DistanceFromScale", context);
context.ExprHostBuilder.GaugePointerDistanceFromScale(m_distanceFromScale);
}
if (m_pointerImage != null)
{
m_pointerImage.Initialize(context);
}
if (m_markerLength != null)
{
m_markerLength.Initialize("MarkerLength", context);
context.ExprHostBuilder.GaugePointerMarkerLength(m_markerLength);
}
if (m_markerStyle != null)
{
m_markerStyle.Initialize("MarkerStyle", context);
context.ExprHostBuilder.GaugePointerMarkerStyle(m_markerStyle);
}
if (m_placement != null)
{
m_placement.Initialize("Placement", context);
context.ExprHostBuilder.GaugePointerPlacement(m_placement);
}
if (m_snappingEnabled != null)
{
m_snappingEnabled.Initialize("SnappingEnabled", context);
context.ExprHostBuilder.GaugePointerSnappingEnabled(m_snappingEnabled);
}
if (m_snappingInterval != null)
{
m_snappingInterval.Initialize("SnappingInterval", context);
context.ExprHostBuilder.GaugePointerSnappingInterval(m_snappingInterval);
}
if (m_toolTip != null)
{
m_toolTip.Initialize("ToolTip", context);
context.ExprHostBuilder.GaugePointerToolTip(m_toolTip);
}
if (m_hidden != null)
{
m_hidden.Initialize("Hidden", context);
context.ExprHostBuilder.GaugePointerHidden(m_hidden);
}
if (m_width != null)
{
m_width.Initialize("Width", context);
context.ExprHostBuilder.GaugePointerWidth(m_width);
}
}
public bool AppliesTo(Type implementationType, InitializationContext context)
{
var typeHierarchy = Helpers.GetTypeHierarchyFor(implementationType);
return(typeHierarchy.Contains(this.serviceType));
}
private static bool Always(InitializationContext context)
{
return true;
}
private static object CollectResolvedInstance(InitializationContext context, Func<object> instanceProducer)
{
object instance = instanceProducer();
GetListForCurrentRequest(ResolvedInstances).Add(new InstanceInitializationData(context, instance));
return instance;
}
internal Action <TImplementation> GetInitializer <TImplementation>(InitializationContext context)
{
return(this.GetInitializer <TImplementation>(typeof(TImplementation), context));
}
internal Action <object> GetInitializer(Type implementationType, InitializationContext context)
{
return(this.GetInitializer <object>(implementationType, context));
}
public virtual bool Initialize(InitializationContext context)
{
if (this.m_top == null)
{
this.m_top = "0mm";
this.m_topValue = 0.0;
}
else
{
this.m_topValue = context.ValidateSize(ref this.m_top, "Top");
}
if (this.m_left == null)
{
this.m_left = "0mm";
this.m_leftValue = 0.0;
}
else
{
this.m_leftValue = context.ValidateSize(ref this.m_left, "Left");
}
if (this.m_parent != null)
{
bool flag = true;
if (this.m_width == null)
{
if ((context.Location & LocationFlags.InMatrixOrTable) == (LocationFlags)0)
{
if (ObjectType.Table == context.ObjectType || ObjectType.Matrix == context.ObjectType)
{
this.m_width = "0mm";
this.m_widthValue = 0.0;
flag = false;
}
else if (ObjectType.PageHeader == context.ObjectType || ObjectType.PageFooter == context.ObjectType)
{
Report report = this.m_parent as Report;
this.m_widthValue = report.PageSectionWidth;
this.m_width = Converter.ConvertSize(this.m_widthValue);
}
else
{
this.m_widthValue = Math.Round(this.m_parent.m_widthValue - this.m_leftValue, Validator.DecimalPrecision);
this.m_width = Converter.ConvertSize(this.m_widthValue);
}
}
else
{
flag = false;
}
}
if (flag)
{
this.m_widthValue = context.ValidateSize(this.m_width, "Width");
}
flag = true;
if (this.m_height == null)
{
if ((context.Location & LocationFlags.InMatrixOrTable) == (LocationFlags)0)
{
if (ObjectType.Table == context.ObjectType || ObjectType.Matrix == context.ObjectType)
{
this.m_height = "0mm";
this.m_heightValue = 0.0;
flag = false;
}
else
{
this.m_heightValue = Math.Round(this.m_parent.m_heightValue - this.m_topValue, Validator.DecimalPrecision);
this.m_height = Converter.ConvertSize(this.m_heightValue);
}
}
else
{
flag = false;
}
}
if (flag)
{
this.m_heightValue = context.ValidateSize(this.m_height, "Height");
}
}
else
{
this.m_widthValue = context.ValidateSize(ref this.m_width, "Width");
this.m_heightValue = context.ValidateSize(ref this.m_height, "Height");
}
if ((context.Location & LocationFlags.InMatrixOrTable) == (LocationFlags)0)
{
this.ValidateParentBoundaries(context, context.ObjectType, context.ObjectName);
}
if (this.m_styleClass != null)
{
this.m_styleClass.Initialize(context);
}
if (this.m_label != null)
{
this.m_label.Initialize("Label", context);
context.ExprHostBuilder.GenericLabel(this.m_label);
}
if (this.m_bookmark != null)
{
this.m_bookmark.Initialize("Bookmark", context);
context.ExprHostBuilder.ReportItemBookmark(this.m_bookmark);
}
if (this.m_toolTip != null)
{
this.m_toolTip.Initialize("ToolTip", context);
context.ExprHostBuilder.ReportItemToolTip(this.m_toolTip);
}
if (this.m_customProperties != null)
{
this.m_customProperties.Initialize(null, true, context);
}
this.DataRendererInitialize(context);
return(false);
}
internal virtual void Initialize(InitializationContext context, int index)
{
}
public virtual void Initialize(Tablix tablix, InitializationContext context)
{
}
public void InitializationContext_CreateNewContext()
{
InitializationContext context = new InitializationContext(null, null);
Assert.IsNotNull(context.FormatPatternFactory);
Assert.IsNotNull(context.ConditionFactory);
}
public abstract void ValidateScopeRulesForIdcNaturalJoin(InitializationContext context, IRIFDataScope scope);
/// <summary>
/// Initializes the log filter.
/// </summary>
/// <param name="context"></param>
protected internal override void Initialize(InitializationContext context)
{
if (!_minLevelHasBeenSet)
{
throw new BlackBoxException("The minimum log level has not been set.");
}
if (!_maxLevelHasBeenSet)
{
throw new BlackBoxException("The maximum log level has not been set.");
}
if (_minLevel > _maxLevel)
{
throw new BlackBoxException("The minimum log level must be less or equal to the maximum log level.");
}
}
internal void Initialize(string propertyName, bool isCustomProperty, DynamicImageOrCustomUniqueNameValidator validator, InitializationContext context)
{
context.ExprHostBuilder.DataValueStart();
if (m_name != null)
{
m_name.Initialize(propertyName + ".Name", context);
if (isCustomProperty && ExpressionInfo.Types.Constant == m_name.Type)
{
validator.Validate(Severity.Error, propertyName + ".Name", context.ObjectType, context.ObjectName, m_name.StringValue, context.ErrorContext);
}
context.ExprHostBuilder.DataValueName(m_name);
}
if (m_value != null)
{
m_value.Initialize(propertyName + ".Value", context);
context.ExprHostBuilder.DataValueValue(m_value);
}
m_exprHostID = context.ExprHostBuilder.DataValueEnd(isCustomProperty);
}
private static Func <object> ApplyResolveInterceptor(ResolveInterceptor interceptor,
InitializationContext context, Func <object> wrappedProducer)
{
return(() => ThrowWhenResolveInterceptorReturnsNull(interceptor(context, wrappedProducer)));
}
public override void CalculateSizes(double width, double height, InitializationContext context, bool overwrite)
{
base.CalculateSizes(width, height, context, overwrite);
this.m_reportItems.CalculateSizes(context, false);
}
public Action <T> CreateAction <T>(InitializationContext context)
{
return(Helpers.CreateAction <T>(this.instanceInitializer));
}
protected override void DataRendererInitialize(InitializationContext context)
{
base.DataRendererInitialize(context);
CLSNameValidator.ValidateDataElementName(ref this.m_dataInstanceName, "Item", context.ObjectType, context.ObjectName, "DataInstanceName", context.ErrorContext);
}
public void Initialize(InitializationContext context)
{
}
public void Initialize(InitializationContext context)
{
context.ExprHostBuilder.GroupStart(this.m_name);
this.m_saveGroupExprValues = context.HasPreviousAggregates;
this.DataRendererInitialize(context);
if (this.m_groupExpressions != null)
{
for (int i = 0; i < this.m_groupExpressions.Count; i++)
{
ExpressionInfo expressionInfo = this.m_groupExpressions[i];
expressionInfo.GroupExpressionInitialize(context);
context.ExprHostBuilder.GroupExpression(expressionInfo);
}
}
if (this.m_groupLabel != null)
{
this.m_groupLabel.Initialize("Label", context);
context.ExprHostBuilder.GenericLabel(this.m_groupLabel);
}
if (this.m_filters != null)
{
for (int j = 0; j < this.m_filters.Count; j++)
{
this.m_filters[j].Initialize(context);
}
}
if (this.m_parent != null)
{
context.ExprHostBuilder.GroupParentExpressionsStart();
for (int k = 0; k < this.m_parent.Count; k++)
{
ExpressionInfo expressionInfo2 = this.m_parent[k];
expressionInfo2.GroupExpressionInitialize(context);
context.ExprHostBuilder.GroupParentExpression(expressionInfo2);
}
context.ExprHostBuilder.GroupParentExpressionsEnd();
}
if (this.m_userSortExpressions != null)
{
context.ExprHostBuilder.UserSortExpressionsStart();
for (int l = 0; l < this.m_userSortExpressions.Count; l++)
{
ExpressionInfo expression = this.m_userSortExpressions[l];
context.ExprHostBuilder.UserSortExpression(expression);
}
context.ExprHostBuilder.UserSortExpressionsEnd();
}
if (this.m_variables != null && this.m_variables.Count != 0)
{
context.ExprHostBuilder.VariableValuesStart();
for (int m = 0; m < this.m_variables.Count; m++)
{
Variable variable = this.m_variables[m];
variable.Initialize(context);
context.ExprHostBuilder.VariableValueExpression(variable.Value);
}
context.ExprHostBuilder.VariableValuesEnd();
}
if (this.m_pageBreak != null)
{
this.m_pageBreak.Initialize(context);
}
if (this.m_pageName != null)
{
this.m_pageName.Initialize("PageName", context);
context.ExprHostBuilder.PageName(this.m_pageName);
}
context.ExprHostBuilder.GroupEnd();
}
public override void InternalInitialize(int parentRowID, int parentColumnID, int rowindex, int colIndex, InitializationContext context)
{
}
private static bool ShouldApplyInitializer(InitializationContext context) => context.Registration is DisposableRegistration;
public void Initialize(string propertyName, bool isCustomProperty, CustomPropertyUniqueNameValidator validator, InitializationContext context)
{
context.ExprHostBuilder.DataValueStart();
if (this.m_name != null)
{
this.m_name.Initialize(propertyName + ".Name", context);
if (isCustomProperty && ExpressionInfo.Types.Constant == this.m_name.Type)
{
validator.Validate(Severity.Error, context.ObjectType, context.ObjectName, this.m_name.Value, context.ErrorContext);
}
context.ExprHostBuilder.DataValueName(this.m_name);
}
if (this.m_value != null)
{
this.m_value.Initialize(propertyName + ".Value", context);
context.ExprHostBuilder.DataValueValue(this.m_value);
}
this.m_exprHostID = context.ExprHostBuilder.DataValueEnd(isCustomProperty);
}
internal override void Initialize(InitializationContext context)
{
m_heightValue = context.ValidateSize(m_height, "Height");
}
public void Initialize(InitializationContext context)
{
context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
}
public void Initialize(InitializationContext context, string name)
{
context.ExprHostBuilder.ChartSeriesStart();
if (this.m_customProperties != null)
{
this.m_customProperties.Initialize("ChartSeries" + name, context);
}
if (this.m_styleClass != null)
{
this.m_styleClass.Initialize(context);
}
if (this.m_action != null)
{
this.m_action.Initialize(context);
}
if (this.m_type == null)
{
this.m_type = ExpressionInfo.CreateConstExpression(ChartSeriesType.Column.ToString());
}
this.m_type.Initialize("Type", context);
context.ExprHostBuilder.ChartSeriesType(this.m_type);
if (this.m_subtype == null)
{
this.m_subtype = ExpressionInfo.CreateConstExpression(ChartSeriesSubtype.Plain.ToString());
}
this.m_subtype.Initialize("Subtype", context);
context.ExprHostBuilder.ChartSeriesSubtype(this.m_subtype);
if (this.m_chartSmartLabel != null)
{
this.m_chartSmartLabel.Initialize(context);
}
if (this.m_emptyPoints != null)
{
this.m_emptyPoints.Initialize(context);
}
if (this.m_legendName != null)
{
this.m_legendName.Initialize("LegendName", context);
context.ExprHostBuilder.ChartSeriesLegendName(this.m_legendName);
}
if (this.m_legendText != null)
{
this.m_legendText.Initialize("LegendText", context);
context.ExprHostBuilder.ChartSeriesLegendText(this.m_legendText);
}
if (this.m_chartAreaName != null)
{
this.m_chartAreaName.Initialize("ChartAreaName", context);
context.ExprHostBuilder.ChartSeriesChartAreaName(this.m_chartAreaName);
}
if (this.m_valueAxisName != null)
{
this.m_valueAxisName.Initialize("ValueAxisName", context);
context.ExprHostBuilder.ChartSeriesValueAxisName(this.m_valueAxisName);
}
if (this.m_categoryAxisName != null)
{
this.m_categoryAxisName.Initialize("CategoryAxisName", context);
context.ExprHostBuilder.ChartSeriesCategoryAxisName(this.m_categoryAxisName);
}
if (this.m_hidden != null)
{
this.m_hidden.Initialize("Hidden", context);
context.ExprHostBuilder.ChartSeriesHidden(this.m_hidden);
}
if (this.m_hideInLegend != null)
{
this.m_hideInLegend.Initialize("HideInLegend", context);
context.ExprHostBuilder.ChartSeriesHideInLegend(this.m_hideInLegend);
}
if (this.m_dataLabel != null)
{
this.m_dataLabel.Initialize(context);
}
if (this.m_marker != null)
{
this.m_marker.Initialize(context);
}
List <ChartDerivedSeries> childrenDerivedSeries = this.ChildrenDerivedSeries;
if (childrenDerivedSeries != null)
{
for (int i = 0; i < childrenDerivedSeries.Count; i++)
{
childrenDerivedSeries[i].Initialize(context, i);
}
}
if (this.m_toolTip != null)
{
this.m_toolTip.Initialize("ToolTip", context);
context.ExprHostBuilder.ChartSeriesToolTip(this.m_toolTip);
}
if (this.m_chartItemInLegend != null)
{
this.m_chartItemInLegend.Initialize(context);
}
context.ExprHostBuilder.ChartSeriesEnd();
}
public override void InternalInitialize(int parentRowID, int parentColumnID, int rowindex, int colIndex, InitializationContext context)
{
AspNetCore.ReportingServices.RdlExpressions.ExprHostBuilder exprHostBuilder = context.ExprHostBuilder;
if (this.m_dataPointValues != null)
{
this.m_dataPointValues.Initialize(context);
}
if (this.m_dataLabel != null)
{
this.m_dataLabel.Initialize(context);
}
if (this.m_action != null)
{
this.m_action.Initialize(context);
}
if (this.m_styleClass != null)
{
exprHostBuilder.DataPointStyleStart();
this.m_styleClass.Initialize(context);
exprHostBuilder.DataPointStyleEnd();
}
if (this.m_marker != null)
{
this.m_marker.Initialize(context);
}
if (this.m_customProperties != null)
{
this.m_customProperties.Initialize(null, context);
}
if (this.m_axisLabel != null)
{
this.m_axisLabel.Initialize("AxisLabel", context);
context.ExprHostBuilder.ChartDataPointAxisLabel(this.m_axisLabel);
}
if (this.m_itemInLegend != null)
{
this.m_itemInLegend.Initialize(context);
}
if (this.m_toolTip != null)
{
this.m_toolTip.Initialize("ToolTip", context);
context.ExprHostBuilder.ChartDataPointToolTip(this.m_toolTip);
}
this.DataRendererInitialize(context);
}
internal override void InitializeMapMember(InitializationContext context)
{
context.ExprHostBuilder.MapSizeRuleStart();
base.InitializeMapMember(context);
context.ExprHostBuilder.MapSizeRuleEnd();
}
/// <summary>
/// Initializes the log filter.
/// </summary>
/// <param name="context"></param>
protected internal override void Initialize(InitializationContext context)
{
if (!_levelHasBeenSet)
{
throw new BlackBoxException("The log level has not been set.");
}
}
public override void Initialize(InitializationContext context)
{
this.m_heightValue = context.ValidateSize(this.m_height, "Height");
}
/// <summary>
/// Initializes the specified log filter.
/// </summary>
/// <param name="context">The context.</param>
protected internal virtual void Initialize(InitializationContext context)
{
}
public InstanceInitializationPair(InitializationContext context, object instance)
{
this.Context = context;
this.Instance = instance;
}