private void RaiseViewSizeProperty(CachedProperty cachedProperty,
Func <double> viewSizeDelegate)
{
double viewSize = viewSizeDelegate();
RaiseViewSizeProperty(cachedProperty, viewSizeDelegate, viewSize);
}
/// <summary>
/// Disconnects on adaptors OnTargetChange
/// </summary>
public void Disconnect()
{
if (dataCache != null)
{
dataCache.Disconnect();
}
dataCache = null;
if (controlCache != null)
{
controlCache.Disconnect();
}
controlCache = null;
if (IsSubItem == true)
{
MasterItem.Submappings.RemoveMapping(this);
}
else
if (submappings != null)
{
submappings.Disconnect();
}
submappings = null;
masterItem = null;
if (Adaptor != null)
{
Adaptor.TargetChanged -= TargetChanged;
adaptor.Target = null;
}
adaptor = null;
}
public CachedAssetBundle(Func <Action <AssetBundle>, Action <Exception>, AsyncTask> cacheProcess
, System.Action <AssetBundle> onSuccess = null
, System.Action <Exception> onFail = null)
{
AssetBundle = new CachedProperty <UnityEngine.AssetBundle> (cacheProcess, onSuccess, onFail);
ReferencedCount++;
}
/// <summary>
/// Assign a value, try to convert it if it's not the same type as the property type.
/// </summary>
/// <param name="instance">Object containing the property</param>
/// <param name="propertyName">Name of property</param>
/// <param name="value">Value to convert and assign</param>
/// <exception cref="InvalidOperationException">Failed to find property.</exception>
/// <exception cref="InvalidCastException">Could not convert value type to property type.</exception>
public void SetConvertedValue(object instance, string propertyName, object value)
{
CachedProperty property = GetProperty(propertyName);
if (property == null)
{
return;
}
Type targetType = property.MemberType;
if (!targetType.IsAssignableFrom(value.GetType()))
{
value = property.Convert(targetType, value);
}
// Value types cannot be null, let's get the default value for the value type.
// Not the nicest solution, feel free to improve it.
if (value == null && targetType.IsValueType)
{
object defaultValue;
lock (_valueTypeDefaults)
{
if (!_valueTypeDefaults.TryGetValue(targetType, out defaultValue))
{
defaultValue = Activator.CreateInstance(targetType);
_valueTypeDefaults[targetType] = defaultValue;
}
}
value = defaultValue;
}
_reflectorProvider.SetValue(property.MemberInfo, instance, value);
}
private static bool IsIgnored(CachedProperty property)
{
var attribute =
property.PropertyInfo.GetCustomAttribute <IgnoredPropertyAttribute>();
return(attribute != null);
}
/// <summary>
/// Notification method activated from Adaptor
/// </summary>
/// <param name="aSender">
/// Object that made change <see cref="System.Object"/>
/// </param>
public virtual void GetDataFromDataSource(object aSender)
{
/* if (Adaptor.FinalTarget == null) {
* Visible = false;
* Sensitive = false;
* return;
* }*/
//System.Data.Bindings.DebugInformation.ConsoleDebug.TraceStack ("GetData");
object vis, sen;
CachedProperty.UncachedGetValue(Adaptor.FinalTarget, VisibleMapping, out vis, false);
CachedProperty.UncachedGetValue(Adaptor.FinalTarget, SensitiveMapping, out sen, false);
if (firsttime == false)
{
if (((bool)vis == Visible) && ((bool)sen == Sensitive) && (lastTarget.Target == adaptor.FinalTarget))
{
return;
}
}
//System.Console.WriteLine("AssignData (" + adaptor.FinalTarget + ") vis=" + (bool) vis + " sen=" + (bool) sen);
Gtk.Application.Invoke(delegate {
Visible = (bool)vis;
Sensitive = (bool)sen;
//System.Console.WriteLine("Set firsttime");
firsttime = false;
lastTarget.Target = adaptor.FinalTarget;
});
}
private void CacheScrollbarPeers()
{
IScrollProvider provider = (IScrollProvider)this;
ScrollBar hscrollbar = scrollViewer.ElementHorizontalScrollBar;
hCachedProperty = new CachedProperty();
SetAutomationEvents(provider,
hscrollbar,
GetHorizontallyScrollable,
delegate { return(scrollViewer.ComputedHorizontalScrollBarVisibility); },
delegate { return(provider.HorizontalScrollPercent); },
delegate { return(provider.HorizontalViewSize); },
ScrollPatternIdentifiers.HorizontalScrollPercentProperty,
ScrollPatternIdentifiers.HorizontallyScrollableProperty,
ScrollPatternIdentifiers.HorizontalViewSizeProperty,
AutomationOrientation.Horizontal);
ScrollBar vscrollbar = scrollViewer.ElementVerticalScrollBar;
vCachedProperty = new CachedProperty();
SetAutomationEvents(
provider,
vscrollbar,
GetVerticallyScrollable,
delegate { return(scrollViewer.ComputedVerticalScrollBarVisibility); },
delegate { return(provider.VerticalScrollPercent); },
delegate { return(provider.VerticalViewSize); },
ScrollPatternIdentifiers.VerticalScrollPercentProperty,
ScrollPatternIdentifiers.VerticallyScrollableProperty,
ScrollPatternIdentifiers.VerticalViewSizeProperty,
AutomationOrientation.Vertical);
}
public PropertyViewModel Create(CachedProperty cachedProperty)
{
return(new PropertyViewModel()
{
MemberCode = cachedProperty.MemberCode,
Html = cachedProperty.Html
});
}
private CachedProperty CacheProperty(Culture culture, Property property)
{
CachedProperty cachedProperty = new CachedProperty();
cachedProperty.PropertyId = property.Id;
cachedProperty.MemberCode = this.handler.Storage.GetRepository <IMemberRepository>().WithKey(property.MemberId).Code;
cachedProperty.Html = this.GetLocalizationValue(culture.Id, property.HtmlId);
return(cachedProperty);
}
private void RaiseStructureChanged(CachedProperty cachedProperty,
Func <Visibility> computedVisibilityDelegate)
{
bool visible = computedVisibilityDelegate() == Visibility.Visible;
if (visible != cachedProperty.Visible)
{
cachedProperty.Visible = visible;
RaiseAutomationEvent(AutomationEvents.StructureChanged);
}
}
public WindowsGameHost(Game game, GraphicsContextFlags flags)
{
this.game = game;
base.Window = new WindowsGameWindow(flags);
Window.Activated += OnActivated;
Window.Deactivated += OnDeactivated;
IntPtr handle = Window.Handle;
IsActive = new CachedProperty <bool>(delegate { return(GetForegroundWindow().Equals(handle)); }, 50, true);
}
/// <summary>
/// Get a property value.
/// </summary>
/// <param name="instance">Instance to get value from.</param>
/// <param name="propertyName">Name of property.</param>
/// <returns>Property value.</returns>
public object GetValue(object instance, string propertyName)
{
CachedProperty property = GetProperty(propertyName);
if (property == null)
{
return(null);
}
return(_reflectorProvider.GetValue(property.MemberInfo, instance));
}
public PropertyRecord(Context context, TypeRecord typeRecord, CachedProperty prop)
: this(context, typeRecord)
{
DeclaringTypeId = prop.DeclaringTypeId;
PropertyTag = prop.Tag;
EncodeTag = EncodePropertyTag(DeclaringTypeId, PropertyTag);
DataType = prop.DataType;
PropertyType = prop.PropertyType;
Property = prop;
Name = prop.Name;
}
/// <summary>
/// Assign value to a property
/// </summary>
/// <param name="instance">Object containing the property</param>
/// <param name="propertyName">Name of property</param>
/// <param name="value">Value to assign, must be of the same type as the property.</param>
/// <exception cref="InvalidOperationException">Failed to find property.</exception>
public void SetValue(object instance, string propertyName, object value)
{
CachedProperty property = GetProperty(propertyName);
if (property == null)
{
return;
}
_reflectorProvider.SetValue(property.MemberInfo, instance, value);
}
private void RaiseViewSizeProperty(CachedProperty cachedProperty,
Func <double> viewSizeDelegate,
double viewSize)
{
if (cachedProperty.ViewSize != viewSize)
{
RaisePropertyChangedEvent(cachedProperty.ViewSizeProperty,
cachedProperty.ViewSize,
viewSize);
cachedProperty.ViewSize = viewSize;
}
}
private void RaiseScrollableProperty(CachedProperty cachedProperty,
Func <bool> scrollableDelegate)
{
bool scrollable = scrollableDelegate();
if (cachedProperty.Scrollable != scrollable)
{
RaisePropertyChangedEvent(cachedProperty.ScrollableProperty,
cachedProperty.Scrollable,
scrollable);
cachedProperty.Scrollable = scrollable;
}
}
private void SetPropertyValue <T>(T instance, CachedProperty property, IConfigurationSection section)
where T : class
{
if (IsIgnored(property))
{
return;
}
var propertyConfiguration = GetPropertyConfiguration(property);
var unparsedValue = section[property.Name];
var value = GetParsedValue <T>(property, unparsedValue, propertyConfiguration);
property.SetValue(instance, value);
}
private void RaiseScrollPercentProperty(CachedProperty cachedProperty,
Func <double> scrollPercentDelegate)
{
double percent = scrollPercentDelegate();
if (cachedProperty.ScrollPercent != percent)
{
RaisePropertyChangedEvent(cachedProperty.ScrollPercentProperty,
cachedProperty.ScrollPercent,
percent);
cachedProperty.ScrollPercent = percent;
}
}
public TcpIpSystem(TcpIpSystemParam param) : base(param)
{
LocalHostPossibleGlobalIpAddressListCache =
new AsyncCache <HashSet <IPAddress> >(CoresConfig.TcpIpSystemSettings.LocalHostPossibleGlobalIpAddressListCacheLifetime, CacheFlags.IgnoreUpdateError | CacheFlags.NoGc,
GetLocalHostPossibleGlobalIpAddressListMainAsync);
DnsResolverSingleton = new Singleton <DnsResolver>(() => CreateDnsResolverImpl());
this.HostInfoCache = new CachedProperty <TcpIpSystemHostInfo>(getter: () => this.GetHostInfo(true), expiresLifeTimeMsecs: CoresConfig.TcpIpSystemSettings.HostHostInfoCacheLifetime);
this.EasyHostNameToIpCache = new AsyncCache <string, IPAddress>(CoresConfig.TcpIpSystemSettings.EasyHostNameToIpCacheLifetime, CacheFlags.IgnoreUpdateError | CacheFlags.NoGc,
async(hostname, cancel) => await this.GetIpAsync(hostname, cancel: cancel, orderBy: ip => (long)ip.AddressFamily));
}
public CachedType(Type type)
{
Type = type;
TypeId = type.GetCustomAttribute <TypeIdAttribute>().Id;
Properties = new List <CachedProperty>();
TaggedProperties = new Dictionary <int, CachedProperty>();
foreach (
var prop in
Enumerable.Reverse(type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy |
BindingFlags.Instance | BindingFlags.Static)))
{
var cachedProp = new CachedProperty(prop);
Properties.Add(cachedProp);
if (cachedProp.Tag != -1)
{
var encodeId = EncodePropertyTag(cachedProp.DeclaringTypeId, cachedProp.Tag);
TaggedProperties.Add(encodeId, cachedProp);
}
}
IsSingleton = typeof(ISingleton).IsAssignableFrom(type);
if (IsSingleton)
{
var getExisting = Type.GetCacheableMethod("GetExisting",
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
if (getExisting == null)
{
throw new Exception("ISingleton is missing static GetExisting() method.");
}
GetInstance = getExisting
.Compile();
}
else if (!IsAbstract && IsPublic)
{
var ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
null, new Type[0], null);
if (ctor == null)
{
return;
}
var lambda = Expression.Lambda <Func <object> >(Expression.New(ctor));
GetInstance = lambda.Compile();
}
}
private object Parse(CachedProperty property, string unparsedValue,
PropertyConfigurationAttribute propertyConfiguration)
{
var parser = GetParser(property.PropertyType, property.Name);
object value;
if (propertyConfiguration.AcceptInvalid)
{
value = parser.TryParse(unparsedValue,
propertyConfiguration.DefaultValue);
}
else
{
value = parser.Parse(unparsedValue);
}
return(value);
}
public SqlQuery InsertQuery <T>(T entity) where T : class
{
IDictionary <string, object> expando = new ExpandoObject();
foreach (var prop in CachedProperty.GetPropertiesExcluded <T>(TableInfo.PrimaryKey <T>()))
{
expando[prop.Name] = prop.GetValue(entity);
}
var columns = CachedProperty.GetPropertyNamesExcluded <T>(TableInfo.PrimaryKey <T>());
var query = string.Format("INSERT INTO {0} ({1}) VALUES (@{2})",
TableInfo.TableName <T>(),
string.Join(",", columns),
string.Join(",@", columns));
return(new SqlQuery(query, expando));
}
public SqlQuery UpdateQuery <T>(T entity) where T : class
{
var idKey = TableInfo.PrimaryKey <T>();
var propertiesExcluedPrimaryKey = CachedProperty.GetProperties <T>();
IDictionary <string, object> expando = new ExpandoObject();
foreach (var prop in propertiesExcluedPrimaryKey)
{
expando[prop.Name] = prop.GetValue(entity);
}
var updateProperties = propertiesExcluedPrimaryKey.Where(p => p.Name != idKey).Select(prop => prop.Name + "=@" + prop.Name).ToList();
var query = string.Format("UPDATE {0} SET {1} WHERE {2}=@{2}", TableInfo.TableName <T>(), string.Join(",", updateProperties), TableInfo.PrimaryKey <T>());
return(new SqlQuery(query, expando));
}
private object GetParsedValue <T>(CachedProperty property, string unparsedValue,
PropertyConfigurationAttribute propertyConfiguration) where T : class
{
object value;
if (unparsedValue == null)
{
if (propertyConfiguration.IsMandatory)
{
throw new MissingMandatoryConfigurationException(typeof(T), property.Name);
}
value = propertyConfiguration.DefaultValue;
}
else
{
value = Parse(property, unparsedValue, propertyConfiguration);
}
return(value);
}
/// <summary>
/// Resoves PropertyInfo from connected object
/// </summary>
public bool Resolve()
{
#if NEWCACHE
if (dataCache == null)
{
dataCache = new CachedProperty(Adaptor.FinalTarget, Name);
}
if (resetResolve == true)
{
dataCache.SetObject(Adaptor.FinalTarget);
dataCache.SetProperty(Name.Trim());
}
/* if (dataCache.IsAccessValid == EPropertyAccess.Invalid)
* if (Adaptor.FinalTarget != null) {
* dataCache.SetObject (Adaptor.FinalTarget);
* dataCache.SetProperty (Name.Trim());
* }*/
return(dataCache.IsAccessValid == EPropertyAccess.Valid);
#endif
#if OLDCACHE
if (cached == true)
{
return(true);
}
if (name == "")
{
return(false);
}
cached = false;
cachedInfo = null;
if (Adaptor.FinalTarget != null)
{
cachedInfo = ConnectionProvider.ResolveMappingProperty(Adaptor.FinalTarget, Name, false);
}
cached = (cachedInfo != null);
invalid = (cachedInfo == null);
return(cachedInfo != null);
#endif
}
public TextArea2DComponentManipulator()
{
var textDataField = UnityTypes.AdvPage.ClrType.GetField("textData", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
set_textData = CustomFastReflectionHelper.CreateFastFieldSetter <object, object>(textDataField);
var statusField = UnityTypes.AdvPage.ClrType.GetField("status", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
set_status = CustomFastReflectionHelper.CreateFastFieldSetter <object, object>(statusField);
var isInputSendMessageField = UnityTypes.AdvPage.ClrType.GetField("isInputSendMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
set_isInputSendMessage = CustomFastReflectionHelper.CreateFastFieldSetter <object, bool>(isInputSendMessageField);
var nameTextField = UnityTypes.AdvPage.ClrType.GetField("nameText", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
set_nameText = CustomFastReflectionHelper.CreateFastFieldSetter <object, object>(nameTextField);
_text = UnityTypes.TextArea2D.ClrType.CachedProperty("text");
_TextData = UnityTypes.TextArea2D.ClrType.CachedProperty("TextData");
}
/// <summary>
/// Resolves final target for Adaptor
/// </summary>
/// <returns>
/// Object of the final target this adaptor is pointing to <see cref="System.Object"/>
/// </returns>
protected override object DoGetFinalTarget(out bool aCallControl)
{
aCallControl = false;
if (GetDefaultProperty() == null)
{
return(null);
}
object res = base.DoGetFinalTarget(out aCallControl);
finalTarget.Target = null;
if (res == null)
{
return(null);
}
// Resolve forward if mapped property is adaptor
object tgt = null;
if (GetDefaultProperty() == null)
{
return(null);
}
if (CachedProperty.UncachedGetValue(res, GetDefaultProperty().Name, out tgt) == false)
{
tgt = ConnectionProvider.ResolveTargetForObject(tgt);
}
// set checks
if (DataSourceType != null)
{
if (TypeValidator.IsCompatible(tgt.GetType(), DataSourceType) == true)
{
return(tgt);
}
return(null);
}
else
{
return(tgt);
}
}
private void RaiseStructureChanged (CachedProperty cachedProperty,
Func<Visibility> computedVisibilityDelegate)
{
bool visible = computedVisibilityDelegate () == Visibility.Visible;
if (visible != cachedProperty.Visible) {
cachedProperty.Visible = visible;
RaiseAutomationEvent (AutomationEvents.StructureChanged);
}
}
private void RaiseScrollPercentProperty (CachedProperty cachedProperty,
Func<double> scrollPercentDelegate)
{
double percent = scrollPercentDelegate ();
if (cachedProperty.ScrollPercent != percent) {
RaisePropertyChangedEvent (cachedProperty.ScrollPercentProperty,
cachedProperty.ScrollPercent,
percent);
cachedProperty.ScrollPercent = percent;
}
}
private void RaiseViewSizeProperty (CachedProperty cachedProperty,
Func<double> viewSizeDelegate,
double viewSize)
{
if (cachedProperty.ViewSize != viewSize) {
RaisePropertyChangedEvent (cachedProperty.ViewSizeProperty,
cachedProperty.ViewSize,
viewSize);
cachedProperty.ViewSize = viewSize;
}
}
private void RaiseViewSizeProperty (CachedProperty cachedProperty,
Func<double> viewSizeDelegate)
{
double viewSize = viewSizeDelegate ();
RaiseViewSizeProperty (cachedProperty, viewSizeDelegate, viewSize);
}
public FairyGUITextComponentManipulator()
{
_html = ClrTypes.TextField.CachedField("html") ?? ClrTypes.TextField.CachedFieldByIndex(3, typeof(bool), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
_text = ClrTypes.TextField.CachedProperty("text");
_htmlText = ClrTypes.TextField.CachedProperty("htmlText");
}
public DefaultTextComponentManipulator(Type type)
{
_type = type;
_property = type.CachedProperty(TextPropertyName);
}
/// <summary>
/// Throws Exception
/// </summary>
/// <param name="aProperty">
/// Property which failed on GetValue <see cref="CachedProperty"/>
/// </param>
public ExceptionCachedPropertyGetValueFailed(CachedProperty aProperty)
: base("Property was cached, but CachedProperty.GetValue() did not succedd????")
{
}
private void CacheScrollbarPeers ()
{
IScrollProvider provider = (IScrollProvider) this;
ScrollBar hscrollbar = scrollViewer.ElementHorizontalScrollBar;
hCachedProperty = new CachedProperty ();
SetAutomationEvents (provider,
hscrollbar,
GetHorizontallyScrollable,
delegate { return scrollViewer.ComputedHorizontalScrollBarVisibility; },
delegate { return provider.HorizontalScrollPercent; },
delegate { return provider.HorizontalViewSize; },
ScrollPatternIdentifiers.HorizontalScrollPercentProperty,
ScrollPatternIdentifiers.HorizontallyScrollableProperty,
ScrollPatternIdentifiers.HorizontalViewSizeProperty,
AutomationOrientation.Horizontal);
ScrollBar vscrollbar = scrollViewer.ElementVerticalScrollBar;
vCachedProperty = new CachedProperty ();
SetAutomationEvents (
provider,
vscrollbar,
GetVerticallyScrollable,
delegate { return scrollViewer.ComputedVerticalScrollBarVisibility; },
delegate { return provider.VerticalScrollPercent; },
delegate { return provider.VerticalViewSize; },
ScrollPatternIdentifiers.VerticalScrollPercentProperty,
ScrollPatternIdentifiers.VerticallyScrollableProperty,
ScrollPatternIdentifiers.VerticalViewSizeProperty,
AutomationOrientation.Vertical);
}
private void RaiseScrollableProperty (CachedProperty cachedProperty,
Func<bool> scrollableDelegate)
{
bool scrollable = scrollableDelegate ();
if (cachedProperty.Scrollable != scrollable) {
RaisePropertyChangedEvent (cachedProperty.ScrollableProperty,
cachedProperty.Scrollable,
scrollable);
cachedProperty.Scrollable = scrollable;
}
}
