public void Save()
{
lock (appSettingsLock)
{
string json = null;
try
{
json = JsonConvert.SerializeObject(this);
}
catch (Exception ex)
{
LoggerUtil.GetAppWideLogger().Error(ex, "Failed to convert object to JSON.");
return;
}
try
{
IPathProvider paths = PlatformTypes.New <IPathProvider>();
string settingsPath = paths.GetPath(@"app.settings");
using (StreamWriter writer = new StreamWriter(File.Open(settingsPath, FileMode.Create)))
{
writer.Write(json);
}
}
catch (Exception ex)
{
LoggerUtil.GetAppWideLogger().Error(ex, "Failed to save app settings.");
}
}
}
private void LeapPlayer(PlatformTypes platformType)
{
Vector2 velocityToLeap = Vector2.up * ((int)platformType * JumpBoostMultiplier * Time.deltaTime);
rig.velocity.Set(velocityToLeap.x, Mathf.Min(rig.velocity.y, 50));
rig.velocity = velocityToLeap;
}
private void UpdateTranslation(bool scrollNow)
{
SceneView activeView = this.ActiveView;
SceneViewModel viewModel = activeView.ViewModel;
Vector delta = this.dragCurrentPosition - this.dragStartPosition;
if (this.isConstraining)
{
delta = this.ConstrainDeltaToAxis(delta);
}
if (delta == this.lastMove || this.IsAltDown)
{
return;
}
this.EnsureEditTransaction();
Vector vector1 = delta - this.lastMove;
SceneElement primarySelection = viewModel.ElementSelectionSet.PrimarySelection;
if (primarySelection == null)
{
return;
}
PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection);
if (propertyReference == null)
{
return;
}
object computedValue = primarySelection.GetComputedValue(propertyReference);
if (computedValue != null && !PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)primarySelection.ProjectContext))
{
Vector vector2 = vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true);
if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool)
{
ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.StartPointProperty);
ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.EndPointProperty);
Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2);
Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2);
this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1);
this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2);
}
else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool)
{
ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.CenterProperty);
ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.GradientOriginProperty);
Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2);
Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2);
this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point1);
this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point2);
}
else
{
this.TranslateBrushPosition(vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, false), primarySelection);
}
}
activeView.EnsureVisible(this.dragStartPosition + delta, scrollNow);
this.lastMove = delta;
this.UpdateEditTransaction();
}
public override void Draw(DrawingContext context, Matrix matrix)
{
if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.LinearGradientBrush, (ITypeResolver)this.Element.ProjectContext))
{
return;
}
switch (this.kind)
{
case LinearGradientAdornerKind.StartPoint:
this.DrawArrowTail(context, matrix, this.StartPoint, this.EndPoint);
break;
case LinearGradientAdornerKind.EndPoint:
this.DrawArrowHead(context, matrix, this.StartPoint, this.EndPoint);
break;
case LinearGradientAdornerKind.StartRotation:
context.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, this.GetOffsetStartPoint(matrix, RotateAdornerHelper.Radius), RotateAdornerHelper.Radius, RotateAdornerHelper.Radius);
break;
case LinearGradientAdornerKind.EndRotation:
context.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, this.GetOffsetEndPoint(matrix, RotateAdornerHelper.Radius), RotateAdornerHelper.Radius, RotateAdornerHelper.Radius);
break;
default:
throw new NotImplementedException(ExceptionStringTable.UnknownLinearGradientAdorner);
}
}
public static void ClassInit(TestContext context)
{
var antitampering = new Mock <IAntitampering>();
PlatformTypes.Register <IPathProvider>((arr) => new Mocks.MockPathProvider());
PlatformTypes.Register <IAntitampering>((arr) => antitampering.Object);
}
private int GetPlatformCPCost(PlatformTypes type)
{
switch (type)
{
case PlatformTypes.dronesat:
return(this.DroneSatCPCost);
case PlatformTypes.brsat:
return(this.BRSatCPCost);
case PlatformTypes.scansat:
return(this.ScanSatCPCost);
case PlatformTypes.torpsat:
return(this.TorpSatCPCost);
case PlatformTypes.monitorsat:
return(this.MonitorSatCPCost);
case PlatformTypes.missilesat:
return(this.MissileSatCPCost);
default:
return(0);
}
}
public static void Init()
{
FingerprintService.InitFingerprint(new WindowsFingerprint());
// These loosely typed parameter lists are rather gross. Is there a cleaner way to do this?
// params: channel, autoReconnect
PlatformTypes.Register <IPipeClient>((arr) => new WindowsPipeClient((string)arr[0], (arr.Length > 1) ? (bool)arr[1] : false));
// params: channel
PlatformTypes.Register <IPipeServer>((arr) => new WindowsPipeServer((string)arr[0]));
PlatformTypes.Register <IGUIChecks>((arr) => new WindowsGUIChecks());
PlatformTypes.Register <IAntitampering>((arr) => new WindowsAntitampering());
PlatformTypes.Register <INetworkInfo>((arr) => new NetworkListUtil());
PlatformTypes.Register <IAuthenticationStorage>((arr) => new RegistryAuthenticationStorage());
PlatformTypes.Register <IPathProvider>((arr) => new WindowsPathProvider());
PlatformTypes.Register <IFilterAgent>((arr) => new WindowsFilterAgent());
PlatformTypes.Register <IFilterUpdater>((arr) => new WindowsFilterUpdater());
}
public override void Draw(DrawingContext context, Matrix matrix)
{
if (!this.ShouldDraw)
{
return;
}
bool flag = this.AdornerSet.Behavior.Tool is BrushTransformTool;
Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix;
if (flag)
{
Rect brushBounds = this.BrushBounds;
if (brushBounds.Width <= 0.0 || brushBounds.Height <= 0.0)
{
return;
}
Pen thinPen = this.ThinPen;
System.Windows.Media.Geometry rectangleGeometry = Adorner.GetTransformedRectangleGeometry(brushBounds, matrix1, thinPen.Thickness);
context.DrawGeometry((Brush)Brushes.Transparent, thinPen, rectangleGeometry);
}
else
{
Pen pen = new Pen((Brush)Brushes.Transparent, 15.0);
pen.Freeze();
if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.Element.ProjectContext))
{
return;
}
Point startPoint;
Point endPoint;
this.GetBrushOffsetEndpoints(out startPoint, out endPoint, 13.0, 11.0, matrix);
context.DrawLine(pen, startPoint, endPoint);
context.DrawLine(this.ThinPen, startPoint, endPoint);
}
}
/// <summary>
/// 根据指定编号异步获取Ticker对象的操作
/// </summary>
/// <param name="coinType">币种编号</param>
/// <param name="platformType">平台编号</param>
/// <returns>返回执行结果</returns>
public async Task <IExecuteResult> GetTickerAsync(CoinTypes coinType, PlatformTypes platformType)
{
MetadataMessageTransaction transaction = SystemWorker.Instance.CreateMetadataTransaction("CoinAPI");
MetadataContainer reqMsg = new MetadataContainer();
reqMsg.SetAttribute(0x00, new MessageIdentityValueStored(new MessageIdentity
{
ProtocolId = 1,
ServiceId = 0,
DetailsId = 0
}));
reqMsg.SetAttribute(0x0F, new ByteValueStored((byte)coinType));
reqMsg.SetAttribute(0x10, new ByteValueStored((byte)platformType));
TaskCompletionSource <IExecuteResult> completionSource = new TaskCompletionSource <IExecuteResult>();
Task <IExecuteResult> task = completionSource.Task;
transaction.ResponseArrived += delegate(object sender, LightSingleArgEventArgs <MetadataContainer> e)
{
MetadataContainer rspMsg = e.Target;
completionSource.SetResult((!rspMsg.IsAttibuteExsits(0x0A))
? (rspMsg.GetAttribute(0x0F).GetValue <ResourceBlock>() == null
? ExecuteResult.Succeed(null)
: ExecuteResult.Succeed(ConverterFactory.GetTickerConverter().ConvertToDomainObject(rspMsg.GetAttribute(0x0F).GetValue <ResourceBlock>())))
: ExecuteResult.Fail(rspMsg.GetAttribute(0x0A).GetValue <byte>(), rspMsg.GetAttribute(0x0B).GetValue <string>()));
};
transaction.Timeout += delegate { completionSource.SetResult(ExecuteResult.Fail(SystemErrors.Timeout, string.Format("[Async Handle] Transaction: {0} execute timeout!", transaction.Identity))); };
transaction.Failed += delegate { completionSource.SetResult(ExecuteResult.Fail(SystemErrors.Unknown, string.Format("[Async Handle] Transaction: {0} execute failed!", transaction.Identity))); };
transaction.SendRequest(reqMsg);
return(await task);
}
public IPCClient(bool autoReconnect = false)
{
logger = LoggerUtil.GetAppWideLogger();
ipcQueue = new IPCMessageTracker(this);
var channel = string.Format("{0}.{1}", nameof(Citadel.IPC), FingerprintService.Default.Value2).ToLower();
client = PlatformTypes.New <IPipeClient>(channel, autoReconnect); // new NamedPipeClient<BaseMessage>(channel);
logger.Info("Process {0} creating client", Process.GetCurrentProcess().Id);
client.Connected += OnConnected;
client.Disconnected += OnDisconnected;
client.ServerMessage += OnServerMessage;
client.AutoReconnect = autoReconnect;
client.Error += clientError;
client.Start();
m_callbacks.Add(typeof(IpcMessage), (msg) =>
{
HandleIpcMessage(msg as IpcMessage);
});
}
public void TranslateBrushPosition(Vector elementDelta, SceneElement element)
{
PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)element);
if (propertyReference == null)
{
return;
}
object computedValue = element.GetComputedValue(propertyReference);
if (computedValue == null || PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)element.ProjectContext))
{
return;
}
ReferenceStep referenceStep = (ReferenceStep)element.Platform.Metadata.ResolveProperty(BrushNode.RelativeTransformProperty);
object obj = element.ViewModel.DefaultView.ConvertToWpfValue(referenceStep.GetCurrentValue(computedValue));
CanonicalTransform canonicalTransform = !(obj is Transform) ? new CanonicalTransform(Matrix.Identity) : new CanonicalTransform((Transform)obj);
elementDelta *= canonicalTransform.TransformGroup.Value;
double valueToSet1 = RoundingHelper.RoundLength(canonicalTransform.TranslationX + elementDelta.X);
double valueToSet2 = RoundingHelper.RoundLength(canonicalTransform.TranslationY + elementDelta.Y);
this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationXReference, valueToSet1);
this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationYReference, valueToSet2);
}
public IExecuteResult GetValue(CoinTypes coinType, PlatformTypes platformType)
{
try
{
KeyParse keyParse = new KeyParse {
CoinType = coinType, PlatformType = platformType
};
string key = keyParse.ToString();
string content = m_Cache[key] as string;
if (content == null)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTime.Now.AddMilliseconds(25000);
IExecuteResult <Ticker> result = _remoteApiService.GetDataFromDataBase(key);
if (result.State != ExecuteResults.Succeed)
{
return(ExecuteResult.Fail(SystemErrors.Unknown, null));
}
content = result.GetResult().ToString();
m_Cache.Set(key, content, policy);
}
return(ExecuteResult.Succeed(JsonConvert.DeserializeObject <Ticker>(content)));
}
catch (Exception ex)
{
_tracing.Error(ex, null);
return(ExecuteResult.Fail(SystemErrors.NotFound, null));
}
}
public UpdateSystem(IPolicyConfiguration configuration, IPCServer server, string platformId)
{
m_platformPaths = PlatformTypes.New <IPathProvider>();
m_systemServices = PlatformTypes.New <ISystemServices>();
m_ipcServer = server;
m_policyConfiguration = configuration;
m_platformId = platformId;
var bitVersionUri = string.Empty;
if (Environment.Is64BitProcess)
{
bitVersionUri = "/update/cv4w-x64/update.xml";
}
else
{
bitVersionUri = "/update/cv4w-x86/update.xml";
}
var appUpdateInfoUrl = string.Format("{0}{1}", WebServiceUtil.Default.ServiceProviderApiPath, bitVersionUri);
m_updater = new AppcastUpdater(new Uri(appUpdateInfoUrl));
m_logger = LoggerUtil.GetAppWideLogger();
}
private static void EnsureType(IType type, ReplaceStyleTemplateCommand.ExtraReferences references)
{
if (!type.IsResolvable)
{
references.AddUndesolvedType(type);
}
else
{
if (type.RuntimeAssembly.IsLoaded && ((IPlatformTypes)type.PlatformMetadata).IsDesignToolAssembly(type.RuntimeAssembly))
{
return;
}
if (PlatformTypes.IsPlatformType((ITypeId)type))
{
IAssembly targetAssembly = PlatformTypeHelper.GetTargetAssembly(type);
if (targetAssembly == null)
{
return;
}
string name = targetAssembly.Name;
if (string.IsNullOrEmpty(name))
{
return;
}
references.AddPlatformAssembly(name);
}
else
{
references.AddAssembly(type.RuntimeAssembly);
}
}
}
/// <summary>
/// Constructs a new named pipe server for IPC, with a channel name derived from the class
/// namespace and the current machine's digital fingerprint.
/// </summary>
public IPCServer()
{
m_logger = LoggerUtil.GetAppWideLogger();
var channel = string.Format("{0}.{1}", nameof(Citadel.IPC), FingerprintService.Default.Value2).ToLower();
m_server = PlatformTypes.New <IPipeServer>(channel);
//m_server = new NamedPipeServer<BaseMessage>(channel, security);
m_server.ClientConnected += OnClientConnected;
m_server.ClientDisconnected += OnClientDisconnected;
m_server.ClientMessage += OnClientMessage;
m_server.Error += M_server_Error;
// Server is no longer started by constructor. We start the IPCServer after everything else has been set up by the FilterServiceProvider.
m_ipcQueue = new IPCMessageTracker(this);
m_callbacks.Add(typeof(AddSelfModerationEntryMessage), (msg) =>
{
AddSelfModerationEntry?.Invoke(msg as AddSelfModerationEntryMessage);
});
m_callbacks.Add(typeof(IpcMessage), (msg) =>
{
// The new IPC message Request/Send API handles
HandleIpcMessage(msg);
});
}
/// <summary>
/// 判断功能是否开启
/// </summary>
public static bool IsSpreadOpen()
{
// 如果1.8的功能没开放
if (GameFuncControlManager.IsGameFuncDisabled(GameFuncType.System1Dot8))
{
return(false);
}
int state = 0;
PlatformTypes platformType = GameCoreInterface.getinstance().GetPlatformType();
switch (platformType)
{
case PlatformTypes.Android:
state = (int)GameManager.systemParamsList.GetParamValueIntByName("TuiGuang_Android");
break;
case PlatformTypes.APP:
state = (int)GameManager.systemParamsList.GetParamValueIntByName("TuiGuang_APP");
break;
case PlatformTypes.YueYu:
state = (int)GameManager.systemParamsList.GetParamValueIntByName("TuiGuang_YueYu");
break;
}
return(state > 0);
}
private void AddValidElementProperties(ContextMenu menu, IDataObject data, SceneElement hitElement)
{
ResourceEntryItem resourceEntry = this.GetResourceEntry(data);
if (resourceEntry == null || resourceEntry.Resource == null || hitElement == null)
{
return;
}
ResourceManager resourceManager = this.ActiveSceneViewModel.DesignerContext.ResourceManager;
DocumentReference documentReference = resourceEntry.Container.DocumentReference;
if (!PlatformTypes.PlatformsCompatible(hitElement.ProjectContext.PlatformMetadata, resourceEntry.DocumentNode.PlatformMetadata) || !resourceEntry.Resource.IsResourceReachable((SceneNode)hitElement) && (!(documentReference != resourceManager.ActiveRootContainer.DocumentReference) || !(documentReference != resourceManager.TopLevelResourceContainer.DocumentReference)))
{
return;
}
int count = menu.Items.Count;
this.AddProperties(hitElement, resourceEntry, menu.Items);
if (menu.Items.Count <= count)
{
return;
}
string headerText = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.DragDropResourceExistingControlPopupHeader, new object[1]
{
(object)(string.IsNullOrEmpty(hitElement.Name) ? "[" + hitElement.TargetType.Name + "]" : hitElement.Name)
});
this.AddHeaderItem(menu, headerText, 1);
}
/// <summary>
/// 从数据库中获取Ticker数据
/// </summary>
public IExecuteResult <Ticker> GetDataFromDataBase(string key)
{
try
{
KeyParse keyParse;
KeyParse.TryParse(key, out keyParse);
CoinTypes coinType = keyParse.CoinType;
PlatformTypes platformType = keyParse.PlatformType;
string sqlStr = string.Format("SELECT * FROM `coin`.`trades` WHERE `CoinId` ={0} AND `PlatformId` = {1} ORDER BY `NowTime` DESC LIMIT 1"
, (int)coinType, (int)platformType);
DataTable dt = QueryData(sqlStr);
if (dt == null || dt.Rows.Count == 0)
{
return(ExecuteResult <Ticker> .Fail(SystemErrors.Unknown, "没有获取到数据"));
}
Ticker ticker = new Ticker
{
BuyPrice = double.Parse(dt.Rows[0]["BuyPrice"].ToString()),
SellPrice = double.Parse(dt.Rows[0]["SellPrice"].ToString()),
HignPrice = double.Parse(dt.Rows[0]["HighPrice"].ToString()),
LowPrice = double.Parse(dt.Rows[0]["LowPrice"].ToString()),
LastPrice = double.Parse(dt.Rows[0]["LastPrice"].ToString()),
Vol = double.Parse(dt.Rows[0]["TradeVol"].ToString())
};
//Tradescs tradesc = new Tradescs(coinType, ticker, platformType, ((MySqlDateTime)dt.Rows[0]["NowTime"]).GetDateTime());
return(ExecuteResult <Ticker> .Succeed(ticker));
}
catch (Exception ex)
{
_tracing.Error(ex, null);
return(ExecuteResult <Ticker> .Fail(SystemErrors.Unknown, ex.Message));
}
}
private static int GetFigureCount(PathElement pathElement)
{
if (pathElement == null || !pathElement.IsViewObjectValid)
{
return(0);
}
IPlatformTypes metadata = pathElement.Platform.Metadata;
if (!PlatformTypes.IsInstance(pathElement.GetLocalValue(PathElement.DataProperty), PlatformTypes.PathGeometry, metadata.DefaultTypeResolver))
{
return(pathElement.PathGeometry.Figures.Count);
}
object obj = new PropertyReference(new List <ReferenceStep>()
{
metadata.ResolveProperty(PathElement.DataProperty) as ReferenceStep,
metadata.ResolveProperty(PathElement.FiguresProperty) as ReferenceStep,
metadata.ResolveProperty(PathElement.PathFigureCollectionCountProperty) as ReferenceStep
}).GetValue(pathElement.ViewObject.PlatformSpecificObject);
if (obj is int)
{
return((int)obj);
}
return(0);
}
public override IDropAction CreateInstance(DragDropContext context)
{
this.CheckNullArgument((object)context, "context");
TypeAsset result1 = (TypeAsset)null;
if (DragSourceHelper.FirstDataOfType <TypeAsset>(context.Data, ref result1) && PlatformTypes.IsEffectType((ITypeId)result1.Type))
{
ISceneInsertionPoint insertionPoint = this.GetInsertionPoint((object)result1, context);
if (insertionPoint != null)
{
return((IDropAction) new DropEffectAssetAction(result1, insertionPoint));
}
}
DocumentNodeMarkerSortedList result2 = (DocumentNodeMarkerSortedList)null;
if (DragSourceHelper.FirstDataOfType <DocumentNodeMarkerSortedList>(context.Data, ref result2) && result2.Count == 1)
{
DocumentNodeMarker marker = result2.MarkerAt(0);
if (marker != null && marker.Node != null && PlatformTypes.IsEffectType((ITypeId)marker.Node.Type))
{
SceneViewModel viewModel = context.Target.TimelineItemManager.ViewModel;
SceneNode sceneNode = SceneNode.FromMarker <SceneNode>(marker, viewModel);
if (sceneNode != null)
{
ISceneInsertionPoint insertionPoint = this.GetInsertionPoint((object)sceneNode, context);
if (insertionPoint != null)
{
return((IDropAction) new DropEffectSceneNodeAction(sceneNode, insertionPoint));
}
}
}
}
return((IDropAction)null);
}
internal static IPropertyId RefineDataContextProperty(SceneNode target, IPropertyId targetProperty, DocumentNode dataNode)
{
if (targetProperty.MemberType == MemberType.DesignTimeProperty || !DataContextHelper.IsDataContextProperty(target.DocumentNode, targetProperty))
{
return(targetProperty);
}
SampleNonBasicType sampleNonBasicType = dataNode.Type as SampleNonBasicType;
if (sampleNonBasicType != null)
{
if (!sampleNonBasicType.DeclaringDataSet.IsEnabledAtRuntime)
{
return(DesignTimeProperties.DesignDataContextProperty);
}
if (((DocumentCompositeNode)target.DocumentNode).Properties[targetProperty] != null)
{
DataContextInfo dataContextInfo = new DataContextEvaluator().Evaluate(target, targetProperty, true);
if (dataContextInfo.DataSource != null && !(dataContextInfo.DataSource.DataSourceType is SampleNonBasicType))
{
return(DesignTimeProperties.DesignDataContextProperty);
}
}
return(targetProperty);
}
if (PlatformTypes.IsExpressionInteractiveType(dataNode.Type.RuntimeType))
{
return(DesignTimeProperties.DesignDataContextProperty);
}
return(targetProperty);
}
private DocumentNode GetResolvedDocumentRootForSourceUri(IDocumentRootResolver documentRootResolver, DocumentCompositeNode resourceDictionaryNode, ICollection <string> warnings)
{
DocumentNode documentNode;
DocumentCompositeNode rootNode;
DocumentCompositeNode documentCompositeNode = null;
IDocumentRoot documentRoot = null;
Uri uriValue = resourceDictionaryNode.GetUriValue(KnownProperties.ResourceDictionarySourceProperty);
Uri uri = uriValue;
if (uri != null)
{
uri = this.documentContext.MakeDesignTimeUri(uri);
}
if (uri != null)
{
try
{
documentRoot = documentRootResolver.GetDocumentRoot(uri.OriginalString);
if (documentRoot != null)
{
if (PlatformTypes.PlatformsCompatible(documentRoot.TypeResolver.PlatformMetadata, resourceDictionaryNode.TypeResolver.PlatformMetadata))
{
if (documentRoot.IsEditable)
{
rootNode = documentRoot.RootNode as DocumentCompositeNode;
}
else
{
rootNode = null;
}
documentCompositeNode = rootNode;
}
else
{
if (warnings != null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string resourceDictionaryTargetFrameworkNotMatching = StringTable.ResourceDictionaryTargetFrameworkNotMatching;
object[] fullName = new object[] { uriValue, documentRoot.TypeResolver.PlatformMetadata.TargetFramework.FullName, resourceDictionaryNode.TypeResolver.PlatformMetadata.TargetFramework.FullName };
warnings.Add(string.Format(currentCulture, resourceDictionaryTargetFrameworkNotMatching, fullName));
}
documentNode = null;
return(documentNode);
}
}
return(documentCompositeNode);
}
catch (IOException oException)
{
return(documentCompositeNode);
}
catch (NotSupportedException notSupportedException)
{
return(documentCompositeNode);
}
return(documentNode);
}
return(documentCompositeNode);
}
private static bool ShouldUseDocumentForPreview(IInstanceBuilderContext context, XamlDocument xamlDocument)
{
if (!PlatformTypes.PlatformsCompatible(context.Platform.Metadata, xamlDocument.TypeResolver.PlatformMetadata))
{
return(false);
}
return(context.ShouldInstantiatePreviewControl(xamlDocument));
}
public SocketPipeServer()
{
paths = PlatformTypes.New <IPathProvider>();
logger = LoggerUtil.GetAppWideLogger();
isStopped = false;
connectedClients = new List <ClientRepresentation>();
}
public RoomOptions(Vector2 dimensions, EnemySpawnDistributions enemySpawnDistributions, PlatformTypes platformTypes, bool platformsHaveGaps, int platformLayers = -1)
{
this.dimensions = dimensions;
this.enemySpawnDistributions = enemySpawnDistributions;
this.platformTypes = platformTypes;
this.platformsHaveGaps = platformsHaveGaps;
this.platformLayers = platformLayers >= 0 ? platformLayers : getDefaultPlatformLayers();
}
public PropertyReference ConvertToWpfPropertyReference(PropertyReference propertyReference, IPlatformMetadata destinationWpfPlatform)
{
if (propertyReference != null)
{
return(PlatformTypes.ConvertToPlatformPropertyReference(propertyReference, destinationWpfPlatform));
}
return((PropertyReference)null);
}
public override void Draw(DrawingContext ctx, Matrix matrix)
{
if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext) || !(this.AdornerSet.Behavior.Tool is GradientBrushTool))
{
return;
}
base.Draw(ctx, matrix);
}
private static bool IsTypeSerializable(ITypeResolver typeResolver, IType type)
{
if (type.IsInProject(typeResolver) || PlatformTypes.IsDesignTimeType(type.NearestResolvedType.RuntimeType))
{
return(true);
}
return(!PlatformTypes.IsExpressionInteractiveType(type.NearestResolvedType.RuntimeType));
}
public ProxyClrPropertyImplementation(PlatformTypes platformTypes, Type declaringType, string name, Type targetType, Type valueType, object defaultValue, string constructorArgument) : base(platformTypes)
{
this.declaringType = declaringType;
this.name = name;
this.targetType = targetType;
this.valueType = valueType;
this.defaultValue = defaultValue;
this.constructorArgument = constructorArgument;
}
protected override void OnStartup(StartupEventArgs e)
{
Citadel.Core.Windows.Platform.Init();
PlatformTypes.Register <IFilterStarter>((arr) => new WindowsFilterStarter());
PlatformTypes.Register <IGuiServices>((arr) => new WindowsGuiServices());
PlatformTypes.Register <ITrayIconController>((arr) => new WindowsTrayIconController());
base.OnStartup(e);
}
// Check platformTypes variable if the platform type is available.
public bool PlatformTypeIs(PlatformTypes platformType) {
bool isAvailable = false;
for (int i=0; i<platformTypes.Length; i++) {
if (platformTypes[i] == platformType) {
isAvailable = true;
break;
}
}
return isAvailable;
}
// --- functions ---
/// <summary>Initializes information about the current platform.</summary>
internal static void Initialize()
{
// platform
try {
int platform = (int)Environment.OSVersion.Platform;
/*
* 0 Win32S
* 1 Win32Windows
* 2 Win32NT
* 3 WinCE
* 4 Unix
* 5 Xbox
* 6 MacOSX
* 128 Unix
* */
if (platform >= 0 & platform <= 3) {
PlatformType = PlatformTypes.Windows;
} else if (platform == 4 | platform == 128) {
PlatformType = PlatformTypes.Unix;
} else if (platform == 6) {
PlatformType = PlatformTypes.MacOsX;
} else {
PlatformType = PlatformTypes.Unknown;
}
} catch {
PlatformType = PlatformTypes.Unknown;
}
// cli
try {
if (Type.GetType("Mono.Runtime") != null) {
CliType = CliTypes.Mono;
} else {
CliType = CliTypes.Unknown;
}
} catch {
CliType = CliTypes.Unknown;
}
// others
Processors = Environment.ProcessorCount;
NewLine = Environment.NewLine;
CaseSensitiveFileSystem = PlatformType != PlatformTypes.Windows;
}
