public PlatformInfo(PlatformType platform, Version version)
{
Should.NotBeNull(platform, nameof(platform));
_platform = platform;
_version = version ?? Unknown.Version;
}
public HomeButtonImpl(ActionBar actionBar)
{
Should.NotBeNull(actionBar, nameof(actionBar));
_actionBar = actionBar;
}
public IList <IViewModel> GetOpenedViewModels(NavigationType type, IDataContext context = null)
{
Should.NotBeNull(type, nameof(type));
return(GetOpenedViewModelsInternal(type, context ?? DataContext.Empty));
}
public static void RegisterDefaultBindingMember <TType>([NotNull] string member)
where TType : class
{
Should.NotBeNull(member, nameof(member));
BindingServiceProvider.MemberProvider.Register(AttachedBindingMember.CreateMember(DefaultBindingMemberDescriptor.Override <TType>(), (info, type) => member, null));
}
public static BindingListWrapper <T> ToBindingList <T>(this INotifiableCollection <T> collection)
{
Should.NotBeNull(collection, nameof(collection));
return(new BindingListWrapper <T>(collection));
}
public bool Contains(object item)
{
Should.NotBeNull(item, "item");
lock (Locker)
return(ItemsInternal.ContainsKey(item));
}
public static IBindingInfoBehaviorSyntax <TSource> HasStablePath <TSource>([NotNull] this IBindingInfoSyntax <TSource> syntax, bool value = true)
{
Should.NotBeNull(syntax, nameof(syntax));
syntax.Builder.AddOrUpdate(BindingBuilderConstants.HasStablePath, value);
return(syntax.GetOrAddSyntaxBuilder <IBindingInfoBehaviorSyntax <TSource>, object, TSource>());
}
public void Add(IContentViewManager contentViewManager)
{
Should.NotBeNull(contentViewManager, nameof(contentViewManager));
lock (_contentViewManagers)
_contentViewManagers.Insert(0, contentViewManager);
}
private static void Register([NotNull] IBindingMemberProvider memberProvider)
{
Should.NotBeNull(memberProvider, "memberProvider");
BindingBuilderExtensions.RegisterDefaultBindingMember <Button>("Click");
BindingBuilderExtensions.RegisterDefaultBindingMember <TextBox>(() => v => v.Text);
BindingBuilderExtensions.RegisterDefaultBindingMember <Label>(() => v => v.Text);
BindingBuilderExtensions.RegisterDefaultBindingMember <CheckBox>(() => v => v.Checked);
BindingBuilderExtensions.RegisterDefaultBindingMember <ProgressBar>(() => v => v.Value);
//Object
var itemsSourceMember = AttachedBindingMember.CreateAutoProperty <object, IEnumerable>(AttachedMemberConstants.ItemsSource, ObjectItemsSourceChanged);
var defaultMemberRegistration = new DefaultAttachedMemberRegistration <IEnumerable>(itemsSourceMember);
memberProvider.Register(defaultMemberRegistration.ToAttachedBindingMember <object>());
memberProvider.Register(AttachedBindingMember.CreateAutoProperty(AttachedMembers.Object.CollectionViewManager));
memberProvider.Register(AttachedBindingMember.CreateAutoProperty <object, IContentViewManager>(AttachedMembers.Control.ContentViewManager.Path));
memberProvider.Register(AttachedBindingMember.CreateAutoProperty(ItemsSourceGeneratorBase.MemberDescriptor,
(o, args) =>
{
IEnumerable itemsSource = null;
if (args.OldValue != null)
{
itemsSource = args.OldValue.ItemsSource;
args.OldValue.SetItemsSource(null);
}
if (args.NewValue != null)
{
args.NewValue.SetItemsSource(itemsSource);
}
}));
var itemTemplateMember = AttachedBindingMember.CreateAutoProperty <object, IDataTemplateSelector>(AttachedMemberConstants.ItemTemplateSelector);
memberProvider.Register(itemTemplateMember);
memberProvider.Register(typeof(object), AttachedMemberConstants.ItemTemplate, itemTemplateMember, true);
//Form
memberProvider.Register(AttachedBindingMember.CreateAutoProperty(AttachedMembers.Form.ToastTemplateSelector));
//Control
var sizeChanged = memberProvider.GetBindingMember(typeof(Control), "SizeChanged", true, false);
if (sizeChanged != null)
{
memberProvider.Register(typeof(Control), "WidthChanged", sizeChanged, true);
memberProvider.Register(typeof(Control), "HeightChanged", sizeChanged, true);
}
memberProvider.Register(AttachedBindingMember
.CreateMember <Control, object>(AttachedMemberConstants.FindByNameMethod, FindByNameControlMember));
memberProvider.Register(AttachedBindingMember
.CreateMember <Control, bool>(AttachedMemberConstants.Focused, (info, control) => control.Focused,
(info, control, arg3) =>
{
if (arg3)
{
control.Focus();
}
}, "LostFocus"));
memberProvider.Register(AttachedBindingMember.CreateAutoProperty(AttachedMembers.Control.Content, ContentChanged));
var contenMember = AttachedBindingMember.CreateAutoProperty(AttachedMembers.Control.ContentTemplateSelector, ContentTemplateChanged);
memberProvider.Register(contenMember);
memberProvider.Register(typeof(Control), AttachedMemberConstants.ContentTemplate, contenMember, true);
//DateTimePicker
BindingBuilderExtensions.RegisterDefaultBindingMember <DateTimePicker>(() => v => v.Value);
memberProvider.Register(AttachedBindingMember.CreateMember <DateTimePicker, DateTime>("Value",
(info, picker) => picker.Value,
(info, picker, value) =>
{
if (value < picker.MinDate)
{
picker.Value = picker.MinDate;
}
else if (value > picker.MaxDate)
{
picker.Value = picker.MaxDate;
}
else
{
picker.Value = value;
}
}, "ValueChanged"));
//ToolStripItem
BindingBuilderExtensions.RegisterDefaultBindingMember <ToolStripButton>("Click");
BindingBuilderExtensions.RegisterDefaultBindingMember <ToolStripMenuItem>("Click");
BindingBuilderExtensions.RegisterDefaultBindingMember <ToolStripItem>("Text");
memberProvider.Register(AttachedBindingMember.CreateMember <ToolStripItem, object>(AttachedMemberConstants.ParentExplicit,
GetParentToolStripItem, null, ObserveParentMemberToolStripItem));
memberProvider.Register(AttachedBindingMember.CreateMember <ToolStripItem, object>(AttachedMemberConstants.FindByNameMethod,
FindByNameMemberToolStripItem));
//TabControl
BindingBuilderExtensions.RegisterDefaultBindingMember(AttachedMembers.Object.ItemsSource.Override <TabControl>());
memberProvider.Register(AttachedBindingMember.CreateMember(AttachedMembers.TabControl.SelectedItem,
GetSelectedItemTabControl, SetSelectedItemTabControl, "Selected"));
//ComboBox
BindingBuilderExtensions.RegisterDefaultBindingMember(AttachedMembers.Object.ItemsSource.Override <ComboBox>());
memberProvider.Register(AttachedBindingMember.CreateMember(AttachedMembers.Object.ItemsSource.Override <ComboBox>(),
(info, box) => box.DataSource as IEnumerable,
(info, box, value) => box.DataSource = value, "DataSourceChanged"));
memberProvider.Register(AttachedBindingMember.CreateMember(AttachedMembers.ComboBox.SelectedItem,
(info, box) => box.SelectedItem, (info, box, value) => box.SelectedItem = value,
"SelectedIndexChanged"));
//DataGridView
BindingBuilderExtensions.RegisterDefaultBindingMember(AttachedMembers.Object.ItemsSource.Override <DataGridView>());
memberProvider.Register(AttachedBindingMember.CreateMember(AttachedMembers.Object.ItemsSource.Override <DataGridView>(),
(info, view) => view.DataSource as IEnumerable, (info, view, value) =>
{
view.DataSource = value;
view.Refresh();
}, "DataSourceChanged"));
memberProvider.Register(AttachedBindingMember.CreateMember(AttachedMembers.DataGridView.SelectedItem,
GetSelectedItemDataGridView, SetSelectedItemDataGridView, (info, view, arg3) =>
{
arg3 = arg3.ToWeakEventListener();
EventHandler handler = null;
handler = (sender, args) =>
{
var gridView = (DataGridView)sender;
Action <DataGridView, IEventListener, EventHandler> action =
(dataGridView, listener, eventHandler) =>
{
if (!listener.TryHandle(dataGridView, EventArgs.Empty))
{
dataGridView.CurrentCellChanged -= eventHandler;
}
};
//To prevent this exception 'Operation not valid because it results in a reentrant call to the SetCurrentCellAddressCore function'
gridView.BeginInvoke(action, gridView, arg3, handler);
};
view.CurrentCellChanged += handler;
return(WeakActionToken.Create(view, handler,
(gridView, eventHandler) => gridView.CurrentCellChanged -= eventHandler));
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewModelClosedEventArgs" /> class.
/// </summary>
public ViewModelClosedEventArgs([NotNull] IViewModel viewModel, [CanBeNull] object parameter)
{
Should.NotBeNull(viewModel, "viewModel");
_viewModel = viewModel;
_parameter = parameter;
}
public void Remove(IContentViewManager contentViewManager)
{
Should.NotBeNull(contentViewManager, nameof(contentViewManager));
lock (_contentViewManagers)
_contentViewManagers.Remove(contentViewManager);
}
public MetadataTypeAttribute([NotNull] Type metadataType, [NotNull] string methodName)
{
Should.NotBeNull(metadataType, nameof(metadataType));
Should.NotBeNullOrWhitespace(methodName, nameof(methodName));
_accessor = FindAccessor(methodName, metadataType);
}
/// <summary>
/// Occurs when any workspace view model is changed.
/// </summary>
private void OnViewModelsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
Should.BeSupported(e.Action != NotifyCollectionChangedAction.Reset, "The IMultiViewModel.ItemsSource doesn't support Clear method.");
if (e.NewItems != null && e.NewItems.Count != 0)
{
for (int index = 0; index < e.NewItems.Count; index++)
{
var viewModel = (IViewModel)e.NewItems[index];
// ReSharper disable once NotResolvedInText
Should.NotBeNull(viewModel, "newItem");
var closeableViewModel = viewModel as ICloseableViewModel;
if (closeableViewModel != null)
{
closeableViewModel.Closed += _weakEventHandler;
}
var selectable = viewModel as ISelectable;
if (selectable != null)
{
selectable.PropertyChanged += _propertyChangedWeakEventHandler;
}
OnViewModelAddedEvent(viewModel);
}
}
if (e.OldItems != null && e.OldItems.Count != 0)
{
for (int index = 0; index < e.OldItems.Count; index++)
{
var viewModel = (IViewModel)e.OldItems[index];
TrySetPreviousValue(viewModel, e.OldStartingIndex + index);
var closeableViewModel = viewModel as ICloseableViewModel;
if (closeableViewModel != null)
{
closeableViewModel.Closed -= _weakEventHandler;
}
var navigableViewModel = viewModel as INavigableViewModel;
if (navigableViewModel != null)
{
navigableViewModel.OnNavigatedFrom(new NavigationContext(NavigationMode.Back, viewModel,
SelectedItem, this));
}
var selectable = viewModel as ISelectable;
if (selectable != null)
{
if (selectable.IsSelected)
{
selectable.IsSelected = false;
}
selectable.PropertyChanged -= _propertyChangedWeakEventHandler;
}
OnViewModelRemovedEvent(viewModel);
if (DisposeViewModelOnRemove)
{
viewModel.Dispose();
}
}
}
}
public bool Navigate(IViewMappingItem source, string parameter, IDataContext dataContext)
{
Should.NotBeNull(source, nameof(source));
Should.NotBeNull(dataContext, nameof(dataContext));
bool clearBackStack = dataContext.GetData(NavigationConstants.ClearBackStack);
var viewModel = dataContext.GetData(NavigationConstants.ViewModel);
var currentView = viewModel?.GetCurrentView <object>();
if (currentView != null && ReferenceEquals(currentView, CurrentContent))
{
if (clearBackStack)
{
ClearBackStack(null, viewModel, true, dataContext);
}
RaiseNavigated(currentView, NavigationMode.Refresh, parameter, dataContext);
return(true);
}
bool bringToFront;
dataContext.TryGetData(NavigationProvider.BringToFront, out bringToFront);
if (!RaiseNavigating(new NavigatingCancelEventArgs(source, bringToFront ? NavigationMode.Refresh : NavigationMode.New, parameter, dataContext)))
{
return(false);
}
_newContext = dataContext;
var activity = AndroidToolkitExtensions.CurrentActivity;
var context = activity ?? Application.Context;
var intent = new Intent(context, source.ViewType);
if (activity == null)
{
intent.AddFlags(ActivityFlags.NewTask);
}
else if (clearBackStack)
{
ClearBackStack(intent, viewModel, bringToFront, dataContext);
}
if (parameter != null)
{
intent.PutExtra(IntentParameterKey, parameter);
}
if (bringToFront)
{
if (viewModel != null)
{
intent.PutExtra(MvvmActivityMediator.IntentViewModelIdKey, viewModel.GetViewModelId().ToString("N"));
}
//http://stackoverflow.com/questions/20695522/puzzling-behavior-with-reorder-to-front
//http://code.google.com/p/android/issues/detail?id=63570#c2
bool closed = false;
if (!clearBackStack && AndroidToolkitExtensions.IsApiGreaterThanOrEqualTo19)
{
var activityView = viewModel?.GetCurrentView <object>() as Activity;
if (activityView != null && IsTaskRoot(activityView))
{
var message = new MvvmActivityMediator.FinishActivityMessage(viewModel);
EventAggregator.Publish(this, message);
closed = message.IsFinished;
}
}
if (!closed)
{
intent.AddFlags(ActivityFlags.ReorderToFront);
}
viewModel?.Settings.Metadata.AddOrUpdate(NavigationProvider.BringToFront, true);
}
StartActivity(context, intent, source, dataContext);
return(true);
}
public bool TrySetResult([NotNull] IOperationResult <TResult> result)
{
Should.NotBeNull(result, nameof(result));
return(((IAsyncOperationInternal)this).SetResult(result, false));
}
public ViewModelProvider([NotNull] IIocContainer iocContainer)
{
Should.NotBeNull(iocContainer, nameof(iocContainer));
_iocContainer = iocContainer;
}
public SyntaxBuilder(IBindingBuilder builder)
{
Should.NotBeNull(builder, nameof(builder));
_builder = builder;
}
public Rp5WeatherForecastDataProvider(IMd5AlgorithmProvider md5AlgorithmProvider)
{
Should.NotBeNull(md5AlgorithmProvider, nameof(md5AlgorithmProvider));
_md5AlgorithmProvider = md5AlgorithmProvider;
}
public static IBindingModeInfoBehaviorSyntax <object> To([NotNull] this IBindingToSyntax syntax,
[NotNull] string sourcePath)
{
Should.NotBeNull(sourcePath, nameof(sourcePath));
return(syntax.ToSource(context => BindingExtensions.CreateBindingSource(context, sourcePath, null)));
}
public AsyncOperationImpl([NotNull] IActionContinuation continuationAction, IDataContext context)
: base(context)
{
Should.NotBeNull(continuationAction, nameof(continuationAction));
_continuationAction = continuationAction;
}
public static IDataBinding Build(this IBindingInfoSyntax syntax)
{
Should.NotBeNull(syntax, nameof(syntax));
return(syntax.Builder.Build());
}
public AsyncOperationImpl([NotNull] IFunctionContinuation <TIn, T> continuationFunction, IDataContext context)
: base(context)
{
Should.NotBeNull(continuationFunction, nameof(continuationFunction));
_continuationFunctionGeneric = continuationFunction;
}
private static IBindingInfoBehaviorSyntax <TSource> WithParameter <TSource, TValue>(this IBindingInfoSyntax <TSource> syntax, DataConstant <TValue> constant, TValue value)
{
Should.NotBeNull(syntax, nameof(syntax));
syntax.Builder.Add(constant, value);
return(syntax.GetOrAddSyntaxBuilder <IBindingInfoBehaviorSyntax <TSource>, object, TSource>());
}
public NavigatingCancelEventArgsWrapper([NotNull] NavigatingCancelEventArgs args)
{
Should.NotBeNull(args, "args");
_args = args;
}
public ToastPresenter([NotNull] IThreadManager threadManager)
{
Should.NotBeNull(threadManager, nameof(threadManager));
_threadManager = threadManager;
}
public static string GenerateNavigationParameter([NotNull] IViewModel viewModel)
{
Should.NotBeNull(viewModel, nameof(viewModel));
return(viewModel.GetType().AssemblyQualifiedName + IdSeparator[0] + viewModel.GetViewModelId().ToString("N"));
}
public Task <bool> OnNavigatingAsync(INavigationContext context)
{
Should.NotBeNull(context, nameof(context));
Trace(nameof(OnNavigatingAsync), context);
return(OnNavigatingInternalAsync(context));
}
public void SetResult([NotNull] IOperationResult <TResult> result)
{
Should.NotBeNull(result, nameof(result));
((IAsyncOperationInternal)this).SetResult(result, true);
}
public NavigationDispatcher([NotNull] IOperationCallbackManager callbackManager)
{
Should.NotBeNull(callbackManager, nameof(callbackManager));
CallbackManager = callbackManager;
_openedViewModels = new Dictionary <NavigationType, List <WeakReference> >();
}
public void UpdateCloseTag([NotNull] XmlValueExpressionNode endTag, int endPosition)
{
Should.NotBeNull(endTag, "endTag");
EndTag = endTag;
UpdatePosition(Start, endPosition);
}