private static IDisposable ObserveParentMemberToolStripItem(IBindingMemberInfo bindingMemberInfo, ToolStripItem toolStripItem, IEventListener arg3)
{
EventHandler handler = arg3.ToWeakEventListener().Handle;
var owner = GetOwner(toolStripItem);
WeakReference ownerRef = null;
if (owner != null)
{
owner.ParentChanged += handler;
ownerRef = ToolkitServiceProvider.WeakReferenceFactory(owner);
}
toolStripItem.OwnerChanged += handler;
var menuItemRef = ToolkitServiceProvider.WeakReferenceFactory(toolStripItem);
return(new ActionToken(() =>
{
if (ownerRef != null)
{
var toolStrip = ownerRef.Target as ToolStrip;
if (toolStrip != null)
{
toolStrip.ParentChanged -= handler;
}
ownerRef = null;
}
var item = menuItemRef.Target as ToolStripItem;
if (item != null)
{
item.OwnerChanged -= handler;
}
menuItemRef = null;
}));
}
public static void SetCurrentActivity(Activity activity, bool clear)
{
var changed = false;
lock (CurrentActivityLocker)
{
var currentActivity = CurrentActivity;
if (clear)
{
if (ReferenceEquals(currentActivity, activity))
{
_activityRef = Empty.WeakReference;
changed = true;
}
}
else if (!ReferenceEquals(currentActivity, activity))
{
_activityRef = ToolkitServiceProvider.WeakReferenceFactory(activity);
changed = true;
}
}
if (changed)
{
CurrentActivityChanged?.Invoke(activity, EventArgs.Empty);
}
}
private static object GetOrAdd(View view)
{
return(ToolkitServiceProvider
.AttachedValueProvider
.GetOrAdd <View, object>(view, Key, (item, o) =>
{
bool?value;
item.TryGetBindingMemberValue(AttachedMembersBase.Object.IsFlatTree, out value);
if (value == null)
{
var parent = GetParent(item) as View;
while (parent != null)
{
parent.TryGetBindingMemberValue(AttachedMembersBase.Object.IsFlatTree, out value);
if (value == null)
{
parent = GetParent(parent) as View;
}
else if (value.Value)
{
(view as ViewGroup)?.SetDisableHierarchyListener(true);
return ToolkitServiceProvider.WeakReferenceFactory(parent);
}
else
{
break;
}
}
}
return new ParentObserver(item);
}, null));
}
public RootListener(object target)
{
_target = ToolkitServiceProvider.WeakReferenceFactory(target);
_parent = Empty.WeakReference;
UpdateParent(target);
BindingServiceProvider.VisualTreeManager.GetParentMember(target.GetType())?.TryObserve(target, this);
}
protected virtual UIViewController GetCurrentViewController()
{
bool isWindow = true;
var viewModel = NavigationDispatcher.GetTopViewModel(NavigationType.Window);
if (viewModel == null)
{
isWindow = false;
viewModel = NavigationDispatcher.GetTopViewModel(NavigationType.Page);
}
var controller = viewModel.GetCurrentView <object>() as UIViewController;
if (controller == null)
{
return((UIViewController)ViewModel
.GetIocContainer(true)
.Get <INavigationService>()
.CurrentContent);
}
if (isWindow)
{
var weakThis = ToolkitServiceProvider.WeakReferenceFactory(this);
viewModel.AddClosedHandler((sender, args) => ((ModalViewMediator)weakThis.Target)?.OnViewClosed(sender, args));
}
return(controller);
}
private static object GetOrAdd(Element element)
{
return(ToolkitServiceProvider
.AttachedValueProvider
.GetOrAdd <Element, object>(element, "#ParentListener", (item, o) =>
{
bool?value;
item.TryGetBindingMemberValue(AttachedMembersBase.Object.IsFlatTree, out value);
if (value == null)
{
var parent = FindParent(item) as View;
while (parent != null)
{
parent.TryGetBindingMemberValue(AttachedMembersBase.Object.IsFlatTree, out value);
if (value == null)
{
parent = FindParent(parent) as View;
}
else if (value.Value)
{
return ToolkitServiceProvider.WeakReferenceFactory(parent);
}
else
{
break;
}
}
}
return new ParentObserver(item);
}, null));
}
protected override bool OnAttached()
{
if (!CanAttach())
{
return(false);
}
_senderKey = Key + Binding.TargetAccessor.Source.Path.Path;
EventHandler <IObserver, ValueChangedEventArgs> handler = OnBindingSourceValueChanged;
var accessor = Binding.SourceAccessor as ISingleBindingSourceAccessor;
if (_subscribers == null)
{
_subscribers = new List <IDisposable>(accessor == null ? 1 : Binding.SourceAccessor.Sources.Count);
_selfReference = ToolkitServiceProvider.WeakReferenceFactory(this);
}
if (accessor == null)
{
var sources = Binding.SourceAccessor.Sources;
for (int index = 0; index < sources.Count; index++)
{
sources[index].ValueChanged += handler;
}
}
else
{
accessor.Source.ValueChanged += handler;
}
UpdateSources(false);
UpdateErrors(null);
return(true);
}
protected TableViewSourceBase([NotNull] UITableView tableView, string itemTemplate = AttachedMemberConstants.ItemTemplate)
{
Should.NotBeNull(tableView, nameof(tableView));
_tableView = ToolkitServiceProvider.WeakReferenceFactory(tableView);
_templateProvider = new DataTemplateProvider <ITableCellTemplateSelector>(tableView, itemTemplate);
var controllerView = tableView.FindParent <IViewControllerView>();
if (controllerView != null && !(controllerView is IMvvmNavigationController))
{
_listener = ReflectionExtensions.CreateWeakEventHandler <TableViewSourceBase, EventArgs>(this, (adapter, o, arg3) => adapter.OnDisposeController(o, arg3));
controllerView.Mediator.DisposeHandler += _listener.Handle;
}
UseAnimations = tableView
.GetBindingMemberValue(AttachedMembers.UITableView.UseAnimations)
.GetValueOrDefault(true);
AddAnimation = tableView
.GetBindingMemberValue(AttachedMembers.UITableView.AddAnimation)
.GetValueOrDefault(UITableViewRowAnimation.Automatic);
RemoveAnimation = tableView
.GetBindingMemberValue(AttachedMembers.UITableView.RemoveAnimation)
.GetValueOrDefault(UITableViewRowAnimation.Automatic);
ReplaceAnimation = tableView
.GetBindingMemberValue(AttachedMembers.UITableView.ReplaceAnimation)
.GetValueOrDefault(UITableViewRowAnimation.Automatic);
ScrollPosition = tableView
.GetBindingMemberValue(AttachedMembers.UITableView.ScrollPosition)
.GetValueOrDefault(UITableViewScrollPosition.Middle);
}
private static void OnBindChangedCallback(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
var bindChanged = BindChanged;
var bind = (string)args.NewValue;
if (ToolkitServiceProvider.IsDesignMode)
{
if (bindChanged == null)
{
if (ToolkitServiceProvider.IsInitialized)
{
return;
}
var weakSender = ToolkitServiceProvider.WeakReferenceFactory(sender);
ToolkitServiceProvider.Initialized += (o, eventArgs) =>
{
var target = (DependencyObject)weakSender.Target;
if (target != null)
{
BindChanged?.Invoke(target, bind);
}
};
}
else
{
bindChanged.Invoke(sender, bind);
}
}
else
{
Should.MethodBeSupported(bindChanged != null, "View.Bind");
bindChanged.Invoke(sender, bind);
}
}
public BindingContext(object target)
{
_isNull = true;
_isParentContext = true;
_srcRef = ToolkitServiceProvider.WeakReferenceFactory(target);
BindingServiceProvider.VisualTreeManager.GetParentMember(target.GetType())?.TryObserve(target, this);
TryHandle(null, null);
}
public MvvmPickerViewModel([NotNull] UIPickerView pickerView)
{
Should.NotBeNull(pickerView, nameof(pickerView));
_pickerView = ToolkitServiceProvider.WeakReferenceFactory(pickerView);
_weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this,
(adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3));
EmptyTitle = "-";
}
private ParentObserver(FrameworkElement view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
RoutedEventHandler handler = OnChanged;
view.Loaded += handler;
view.Unloaded += handler;
}
public FrameworkElementBindingContext(FrameworkElement element)
{
_sourceReference = ToolkitServiceProvider.WeakReferenceFactory(element);
element.DataContextChanged += RaiseDataContextChanged;
if (ListenUnloadEvent)
{
element.Unloaded += ElementOnUnloaded;
}
_isUnset = IsUnset(element);
}
public SinglePathObserver([NotNull] object source, [NotNull] IBindingPath path, bool ignoreAttachedMembers, bool hasStablePath, bool observable, bool optional)
: base(source, path)
{
Should.BeSupported(path.IsSingle, "The SinglePathObserver supports only single path members.");
_ignoreAttachedMembers = ignoreAttachedMembers;
_ref = ToolkitServiceProvider.WeakReferenceFactory(this);
_hasStablePath = hasStablePath;
_observable = observable;
_optional = optional;
}
public MultiPathObserver([NotNull] object source, [NotNull] IBindingPath path, bool ignoreAttachedMembers, bool hasStablePath, bool observable, bool optional)
: base(source, path)
{
Should.BeSupported(!path.IsEmpty, "The MultiPathObserver doesn't support the empty path members.");
_listeners = new List <IDisposable>(path.Parts.Count - 1);
_ignoreAttachedMembers = ignoreAttachedMembers;
_lastMemberListener = new LastMemberListener(ToolkitServiceProvider.WeakReferenceFactory(this));
_hasStablePath = hasStablePath;
_observable = observable;
_optional = optional;
}
public BindableObjectBindingContext(BindableObject element)
{
_sourceReference = ToolkitServiceProvider.WeakReferenceFactory(element);
if (IsWindows())
{
element.BindingContextChanged += RaiseDataContextChangedWindows;
}
else
{
element.BindingContextChanged += RaiseDataContextChanged;
}
}
public MvvmViewControllerMediator([NotNull] UIViewController viewController)
{
Should.NotBeNull(viewController, nameof(viewController));
_viewController = ToolkitServiceProvider.WeakReferenceFactory(viewController);
_canDispose = true;
var viewModel = viewController.DataContext() as IViewModel;
if (viewModel == null || !viewModel.Settings.Metadata.Contains(ViewModelConstants.StateNotNeeded))
{
viewController.InititalizeRestorationIdentifier();
}
}
protected override bool OnAttached()
{
if (_isTarget)
{
Binding.TargetAccessor.ValueChanging += OnValueChanging;
}
else
{
Binding.SourceAccessor.ValueChanging += OnValueChanging;
}
_timer = new Timer(CallbackInternalDelegate, ToolkitServiceProvider.WeakReferenceFactory(this), Timeout.Infinite, Timeout.Infinite);
return(true);
}
public ParentSourceValue(object target, RelativeSourceInfo node)
{
_node = node;
_isElementSource = _node.Type == RelativeSourceInfo.ElementSourceType;
_targetReference = ToolkitServiceProvider.WeakReferenceFactory(target);
_value = Empty.WeakReference;
IBindingMemberInfo rootMember = BindingServiceProvider.VisualTreeManager.GetRootMember(target.GetType());
if (rootMember != null)
{
_subscriber = rootMember.TryObserve(target, this);
}
TryHandle(null, null);
}
protected ObserverBase([NotNull] object source, [NotNull] IBindingPath path)
{
Should.NotBeNull(source, nameof(source));
Should.NotBeNull(path, nameof(path));
_path = path;
if (source is ISourceValue)
{
_source = source;
}
else
{
_source = ToolkitServiceProvider.WeakReferenceFactory(source);
}
}
private void UpdateParent(object target)
{
var oldParent = _parent.Target;
var parent = BindingServiceProvider.VisualTreeManager.GetParent(target);
if (oldParent != parent)
{
if (oldParent != null)
{
GetOrAdd(oldParent).Remove(this);
}
if (parent != null)
{
GetOrAdd(parent).Add(this);
}
_parent = ToolkitServiceProvider.WeakReferenceFactory(parent);
}
}
internal ItemsSourceGenerator([NotNull] object view)
{
Should.NotBeNull(view, nameof(view));
var type = view.GetType();
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_itemTemplateMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMemberConstants.ItemTemplate, false, false);
#if WINFORMS
_collectionViewManagerMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMembers.Object.CollectionViewManager, false, false);
ListenDisposeEvent(view as IComponent);
_isTabControl = view is TabControl;
#elif TOUCH
_collectionViewManagerMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMembers.UIView.CollectionViewManager, false, false);
TryListenController(view as INativeObject);
#endif
}
public bool TryHandle(object sender, object message)
{
var target = GetReferenceValue();
if (target == null)
{
UnsubscribeEventHandler();
return(false);
}
LastContext.AddOrUpdate(BindingConstants.CurrentEventArgs, message);
WeakReference reference = null;
var command = target as ICommand;
if (command != null)
{
if (sender != null)
{
reference = ToolkitServiceProvider.WeakReferenceFactory(sender);
ToolkitExtensions.AddCurrentBindingEventSender(reference);
}
if (_path.IsDebuggable)
{
var parameter = GetCommandParameter(LastContext);
DebugInfo($"Binding invokes command '{command}' with parameter: '{parameter}', event args: '{message}'", new[] { command, parameter, message });
command.Execute(parameter);
}
else
{
command.Execute(GetCommandParameter(LastContext));
}
if (reference != null)
{
ToolkitExtensions.RemoveCurrentBindingEventSender(reference);
}
return(true);
}
var actionValue = target as BindingActionValue;
if (actionValue == null || actionValue.MemberSource.Target == null)
{
UnsubscribeEventHandler();
return(false);
}
if (sender != null)
{
reference = ToolkitServiceProvider.WeakReferenceFactory(sender);
ToolkitExtensions.AddCurrentBindingEventSender(reference);
}
if (_path.IsDebuggable)
{
var args = new[] { GetCommandParameter(LastContext), message, LastContext };
DebugInfo($"Binding invokes member '{actionValue.Member.Path}' with parameter: '{args[0]}', event args: '{message}'", args);
actionValue.TrySetValue(args, out target);
}
else
{
actionValue.TrySetValue(new[] { GetCommandParameter(LastContext), message, LastContext }, out target);
}
if (reference != null)
{
ToolkitExtensions.RemoveCurrentBindingEventSender(reference);
}
return(true);
}
private ParentObserver(Element view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
view.PropertyChanged += OnPropertyChanged;
}
private ParentObserver(View view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(GetParent(view), Empty.WeakReference, false);
}
public EmptyPathObserver([NotNull] object source, [NotNull] IBindingPath path)
: base(source, path)
{
Should.BeSupported(path.IsEmpty, "The EmptyPathObserver supports only empty path members.");
_members = new EmptyBindingPathMembers(ToolkitServiceProvider.WeakReferenceFactory(this));
}
public NavigationItemSelectedListener(BottomNavigationView view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
}
public WeakOpenedViewModelInfo(IViewModel viewModel, object provider, NavigationType navigationType)
{
_viewModelReference = ToolkitServiceProvider.WeakReferenceFactory(viewModel);
_providerReference = ToolkitServiceProvider.WeakReferenceFactory(provider);
NavigationType = navigationType;
}
private View OnViewCreated(View view, string name, Context context, IAttributeSet attrs)
{
if (name == "fragment" || view != null && _lastCreatedView.Target == view)
{
return(view);
}
ViewResult viewResult;
if (view == null)
{
var type = TypeCache <View> .Instance.GetTypeByName(name, true, false);
if (type == null)
{
return(null);
}
viewResult = _viewFactory.Create(type, context, attrs);
view = viewResult.View;
}
else
{
var type = TypeCache <View> .Instance.GetTypeByName(name, true, false);
if (type != null && !type.IsInstanceOfType(view))
{
try
{
view = (View)JavaCastMethod.MakeGenericMethod(type).Invoke(null, new object[] { view });
}
catch
{
;
}
}
viewResult = _viewFactory.Initialize(view, attrs);
}
var viewCreated = AndroidToolkitExtensions.ViewCreated;
if (viewCreated != null)
{
view = viewCreated(view, name, context, attrs);
}
string bind = null;
if (!viewResult.IsEmpty)
{
view = viewResult.View;
bind = viewResult.Bind;
if (!string.IsNullOrEmpty(bind))
{
if (AndroidToolkitExtensions.CurrentLayoutInflaterResult == null)
{
var manualBindings = view as IManualBindings;
if (manualBindings == null)
{
BindingServiceProvider.BindingProvider.CreateBindingsFromString(view, bind);
}
else
{
manualBindings.SetBindings(bind);
}
}
}
}
if (AndroidToolkitExtensions.CurrentLayoutInflaterResult == null)
{
var viewGroup = view as ViewGroup;
if (viewGroup != null && !viewGroup.IsDisableHierarchyListener())
{
viewGroup.SetOnHierarchyChangeListener(GlobalViewParentListener.Instance);
}
}
else
{
Action <object> postAction;
if (view is ViewGroup)
{
postAction = o =>
{
var vg = (ViewGroup)o;
if (!vg.IsDisableHierarchyListener())
{
vg.SetOnHierarchyChangeListener(GlobalViewParentListener.Instance);
}
};
}
else
{
postAction = null;
}
AndroidToolkitExtensions.CurrentLayoutInflaterResult.AddBindingInfo(view, bind, postAction);
}
_lastCreatedView = ToolkitServiceProvider.WeakReferenceFactory(view);
return(view);
}
