bool emitted = false;
cell.Appearing += (sender, args) => emitted = true;
- ((ICellController)cell).SendAppearing ();
+ cell.SendAppearing ();
Assert.True (emitted);
Assert.True (cell.OnAppearingSent);
Assert.False (cell.OnDisappearingSent);
bool emitted = false;
cell.Disappearing += (sender, args) => emitted = true;
- ((ICellController)cell).SendDisappearing ();
+ cell.SendDisappearing ();
Assert.True (emitted);
Assert.False (cell.OnAppearingSent);
Assert.True (cell.OnDisappearingSent);
var cell = new ViewCell { Parent = lv };
int numberOfCalls = 0;
- ((ICellController)cell).ForceUpdateSizeRequested += (object sender, System.EventArgs e) => { numberOfCalls++; };
+ cell.ForceUpdateSizeRequested += (object sender, System.EventArgs e) => { numberOfCalls++; };
cell.ForceUpdateSize ();
cell.ForceUpdateSize ();
var cell = new ViewCell { Parent = lv };
int numberOfCalls = 0;
- ((ICellController)cell).ForceUpdateSizeRequested += (object sender, System.EventArgs e) => { numberOfCalls++; };
+ cell.ForceUpdateSizeRequested += (object sender, System.EventArgs e) => { numberOfCalls++; };
cell.ForceUpdateSize ();
{
if (initialLoad && Element.Source != null) {
initialLoad = false;
- ((IImageController)Element).SetIsLoading(true);
+ Element.SetIsLoading(true);
await (Element.Source as UriImageSource).GetStreamAsync ();
- ((IImageController)Element).SetIsLoading(false);
+ Element.SetIsLoading(false);
}
}
};
menu.Add (child);
- ((INavigationMenuController)menu).SendTargetSelected (child);
+ menu.SendTargetSelected (child);
Assert.True (pushed);
Assert.AreEqual (child, navForm.CurrentPage);
var view = new OpenGLView ();
bool displayed = false;
- ((IOpenGlViewController)view).DisplayRequested += (s, o) => displayed = true;
+ view.DisplayRequested += (s, o) => displayed = true;
view.Display ();
Assert.True (displayed);
ObservableCollection<Element> InternalChildren { get; } = new ObservableCollection<Element>();
- void IApplicationController.SetAppIndexingProvider(IAppIndexingProvider provider)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetAppIndexingProvider(IAppIndexingProvider provider)
{
_appIndexProvider = provider;
}
using System;
+using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Input;
using Xamarin.Forms.Internals;
set { SetValueCore(IsEnabledProperty, value); }
}
- void IButtonController.SendClicked()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendClicked()
{
Command?.Execute(CommandParameter);
Clicked?.Invoke(this, EventArgs.Empty);
}
- void IButtonController.SendPressed()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPressed()
{
Pressed?.Invoke(this, EventArgs.Empty);
}
- void IButtonController.SendReleased()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendReleased()
{
Released?.Invoke(this, EventArgs.Empty);
}
public event EventHandler Disappearing;
- event EventHandler ForceUpdateSizeRequested;
- event EventHandler ICellController.ForceUpdateSizeRequested
- {
- add { ForceUpdateSizeRequested += value; }
- remove { ForceUpdateSizeRequested -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler ForceUpdateSizeRequested;
public void ForceUpdateSize()
{
base.OnPropertyChanging(propertyName);
}
- void ICellController.SendAppearing()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendAppearing()
{
OnAppearing();
- var container = RealParent as IListViewController;
+ var container = RealParent as ListView;
if (container != null)
container.SendCellAppearing(this);
}
- void ICellController.SendDisappearing()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendDisappearing()
{
OnDisappearing();
- var container = RealParent as IListViewController;
+ var container = RealParent as ListView;
if (container != null)
container.SendCellDisappearing(this);
}
using System;
+using System.ComponentModel;
namespace Xamarin.Forms
{
public event EventHandler Completed;
- void IEntryCellController.SendCompleted()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendCompleted()
{
EventHandler handler = Completed;
if (handler != null)
using System;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
return _platformConfigurationRegistry.Value.On<T>();
}
- void IEditorController.SendCompleted()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendCompleted()
{
EventHandler handler = Completed;
if (handler != null)
internal virtual ReadOnlyCollection<Element> LogicalChildrenInternal => EmptyChildren;
- ReadOnlyCollection<Element> IElementController.LogicalChildren => LogicalChildrenInternal;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ReadOnlyCollection<Element> LogicalChildren => LogicalChildrenInternal;
internal bool Owned { get; set; }
_changeHandlers.Remove(onchanged);
}
- IEffectControlProvider IElementController.EffectControlProvider
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public IEffectControlProvider EffectControlProvider
{
get { return _effectControlProvider; }
set
}
}
- void IElementController.SetValueFromRenderer(BindableProperty property, object value)
+ void IElementController.SetValueFromRenderer(BindableProperty property, object value) => SetValueFromRenderer(property, value);
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetValueFromRenderer(BindableProperty property, object value)
{
SetValueCore(property, value);
}
- void IElementController.SetValueFromRenderer(BindablePropertyKey property, object value)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetValueFromRenderer(BindablePropertyKey property, object value)
{
SetValueCore(property, value);
}
- bool IElementController.EffectIsAttached(string name)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool EffectIsAttached(string name)
{
foreach (var effect in Effects)
{
using System;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
public event EventHandler<TextChangedEventArgs> TextChanged;
- void IEntryController.SendCompleted()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendCompleted()
{
Completed?.Invoke(this, EventArgs.Empty);
}
using System;
using System.Collections.Generic;
+using System.ComponentModel;
using System.Reflection;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
}
}
- void IImageController.SetIsLoading(bool isLoading)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetIsLoading(bool isLoading)
{
SetValue(IsLoadingPropertyKey, isLoading);
}
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
+using System.ComponentModel;
using System.Linq;
using Xamarin.Forms.Internals;
_children = new ElementCollection<T>(InternalChildren);
}
- public IList<T> Children
+ public new IList<T> Children
{
get { return _children; }
}
public event EventHandler LayoutChanged;
- IReadOnlyList<Element> ILayoutController.Children
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public IReadOnlyList<Element> Children
{
get { return InternalChildren; }
}
[EditorBrowsable(EditorBrowsableState.Never)]
public ListViewCachingStrategy CachingStrategy { get; private set; }
- ListViewCachingStrategy IListViewController.CachingStrategy
- {
- get
- {
- return CachingStrategy;
- }
- }
- bool RefreshAllowed
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool RefreshAllowed
{
set
{
get { return _refreshAllowed; }
}
- Element IListViewController.FooterElement
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Element FooterElement
{
get { return _footerElement; }
}
- Element IListViewController.HeaderElement
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Element HeaderElement
{
get { return _headerElement; }
}
- bool IListViewController.RefreshAllowed
- {
- get { return RefreshAllowed; }
- }
-
- void IListViewController.SendCellAppearing(Cell cell)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendCellAppearing(Cell cell)
{
EventHandler<ItemVisibilityEventArgs> handler = ItemAppearing;
if (handler != null)
handler(this, new ItemVisibilityEventArgs(cell.BindingContext));
}
- void IListViewController.SendCellDisappearing(Cell cell)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendCellDisappearing(Cell cell)
{
EventHandler<ItemVisibilityEventArgs> handler = ItemDisappearing;
if (handler != null)
handler(this, new ItemVisibilityEventArgs(cell.BindingContext));
}
- void IListViewController.SendRefreshing()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendRefreshing()
{
BeginRefresh();
}
content.Parent = null;
}
- Cell IListViewController.CreateDefaultCell(object item)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Cell CreateDefaultCell(object item)
{
return CreateDefault(item);
}
- string IListViewController.GetDisplayTextFromGroup(object cell)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public string GetDisplayTextFromGroup(object cell)
{
int groupIndex = TemplatedItems.GetGlobalIndexOfGroup(cell);
var group = TemplatedItems.GetGroup(groupIndex);
return displayBinding;
}
- internal void NotifyRowTapped(int groupIndex, int inGroupIndex, Cell cell = null)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void NotifyRowTapped(int groupIndex, int inGroupIndex, Cell cell = null)
{
var group = TemplatedItems.GetGroup(groupIndex);
ItemTapped?.Invoke(this, new ItemTappedEventArgs(ItemsSource.Cast<object>().ElementAt(groupIndex), cell.BindingContext));
}
- internal void NotifyRowTapped(int index, Cell cell = null)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void NotifyRowTapped(int index, Cell cell = null)
{
if (IsGroupingEnabled)
{
NotifyRowTapped(0, index, cell);
}
- void IListViewController.NotifyRowTapped(int index, Cell cell)
- {
- NotifyRowTapped(index, cell);
- }
-
- void IListViewController.NotifyRowTapped(int index, int inGroupIndex, Cell cell)
- {
- NotifyRowTapped(index, inGroupIndex, cell);
- }
-
internal override void OnIsPlatformEnabledChanged()
{
base.OnIsPlatformEnabledChanged();
}
}
- internal event EventHandler<ScrollToRequestedEventArgs> ScrollToRequested;
- event EventHandler<ScrollToRequestedEventArgs> IListViewController.ScrollToRequested { add { ScrollToRequested += value; } remove { ScrollToRequested -= value; } }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<ScrollToRequestedEventArgs> ScrollToRequested;
void OnCommandCanExecuteChanged(object sender, EventArgs eventArgs)
{
using System;
using System.Collections.Generic;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
Rectangle _masterBounds;
- IPageController PageController => this as IPageController;
-
public Page Detail
{
get { return _detail; }
OnPropertyChanging();
if (_detail != null)
- PageController.InternalChildren.Remove(_detail);
+ InternalChildren.Remove(_detail);
_detail = value;
- PageController.InternalChildren.Add(_detail);
+ InternalChildren.Add(_detail);
OnPropertyChanged();
}
}
OnPropertyChanging();
if (_master != null)
- PageController.InternalChildren.Remove(_master);
+ InternalChildren.Remove(_master);
_master = value;
- PageController.InternalChildren.Add(_master);
+ InternalChildren.Add(_master);
OnPropertyChanged();
}
}
set { SetValue(MasterBehaviorProperty, value); }
}
- bool IMasterDetailPageController.CanChangeIsPresented { get; set; } = true;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool CanChangeIsPresented { get; set; } = true;
- Rectangle IMasterDetailPageController.DetailBounds
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Rectangle DetailBounds
{
get { return _detailBounds; }
set
}
}
- Rectangle IMasterDetailPageController.MasterBounds
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Rectangle MasterBounds
{
get { return _masterBounds; }
set
}
}
- bool IMasterDetailPageController.ShouldShowSplitMode
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool ShouldShowSplitMode
{
get
{
protected override void OnAppearing()
{
- ((IMasterDetailPageController)this).CanChangeIsPresented = true;
+ CanChangeIsPresented = true;
UpdateMasterBehavior(this);
base.OnAppearing();
}
return true;
}
- EventHandler<BackButtonPressedEventArgs> handler = BackButtonPressedInternal;
+ EventHandler<BackButtonPressedEventArgs> handler = BackButtonPressed;
if (handler != null)
{
var args = new BackButtonPressedEventArgs();
base.OnParentSet();
}
- event EventHandler<BackButtonPressedEventArgs> BackButtonPressedInternal;
- event EventHandler<BackButtonPressedEventArgs> IMasterDetailPageController.BackButtonPressed
- {
- add { BackButtonPressedInternal += value; }
- remove { BackButtonPressedInternal -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<BackButtonPressedEventArgs> BackButtonPressed;
- void IMasterDetailPageController.UpdateMasterBehavior()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void UpdateMasterBehavior()
{
UpdateMasterBehavior(this);
}
internal static void UpdateMasterBehavior(MasterDetailPage page)
{
- if (((IMasterDetailPageController)page).ShouldShowSplitMode)
+ if (page.ShouldShowSplitMode)
{
page.SetValueCore(IsPresentedProperty, true);
if (page.MasterBehavior != MasterBehavior.Default)
- ((IMasterDetailPageController)page).CanChangeIsPresented = false;
+ page.CanChangeIsPresented = false;
}
}
static void OnIsPresentedPropertyChanging(BindableObject sender, object oldValue, object newValue)
{
var page = (MasterDetailPage)sender;
- if (!((IMasterDetailPageController)page).CanChangeIsPresented)
+ if (!page.CanChangeIsPresented)
throw new InvalidOperationException(string.Format("Can't change IsPresented when setting {0}", page.MasterBehavior));
}
[EditorBrowsable(EditorBrowsableState.Never)]
public static readonly BindableProperty IsEnabledProperty = BindableProperty.Create("IsEnabled", typeof(bool), typeof(ToolbarItem), true);
- string IMenuItemController.IsEnabledPropertyName
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public string IsEnabledPropertyName
{
get
{
handler(this, EventArgs.Empty);
}
- void IMenuItemController.Activate()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void Activate()
{
if (Command != null)
{
T _current;
- ObservableCollection<Element> InternalChildren => ((IPageController)this).InternalChildren;
-
protected MultiPage()
{
_templatedItems = new TemplatedItemsList<MultiPage<T>, T>(this, ItemsSourceProperty, ItemTemplateProperty);
return _platformConfigurationRegistry.Value.On<T>();
}
- void INavigationMenuController.SendTargetSelected(Page target)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendTargetSelected(Page target)
{
Navigation.PushAsync(target);
}
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
+using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
using Xamarin.Forms.Internals;
internal Task CurrentNavigationTask { get; set; }
- Page INavigationPageController.Peek(int depth)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Page Peek(int depth)
{
if (depth < 0)
{
return null;
}
- if (PageController.InternalChildren.Count <= depth)
+ if (InternalChildren.Count <= depth)
{
return null;
}
- return (Page)PageController.InternalChildren[PageController.InternalChildren.Count - depth - 1];
+ return (Page)InternalChildren[InternalChildren.Count - depth - 1];
}
- IEnumerable<Page> INavigationPageController.Pages => PageController.InternalChildren.Cast<Page>();
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public IEnumerable<Page> Pages => InternalChildren.Cast<Page>();
- int INavigationPageController.StackDepth
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public int StackDepth
{
- get { return PageController.InternalChildren.Count; }
+ get { return InternalChildren.Count; }
}
- IPageController PageController => this as IPageController;
-
public Page CurrentPage
{
get { return (Page)GetValue(CurrentPageProperty); }
CurrentNavigationTask = tcs.Task;
await oldTask;
- Page page = await ((INavigationPageController)this).PopAsyncInner(animated);
+ Page page = await PopAsyncInner(animated, false);
tcs.SetResult(true);
return page;
}
- Task<Page> result = ((INavigationPageController)this).PopAsyncInner(animated);
+ Task<Page> result = PopAsyncInner(animated, false);
CurrentNavigationTask = result;
return await result;
}
if (CurrentPage.SendBackButtonPressed())
return true;
- if (((INavigationPageController)this).StackDepth > 1)
+ if (StackDepth > 1)
{
SafePop();
return true;
return base.OnBackButtonPressed();
}
- event EventHandler<NavigationRequestedEventArgs> InsertPageBeforeRequestedInternal;
-
- event EventHandler<NavigationRequestedEventArgs> INavigationPageController.InsertPageBeforeRequested
- {
- add { InsertPageBeforeRequestedInternal += value; }
- remove { InsertPageBeforeRequestedInternal -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<NavigationRequestedEventArgs> InsertPageBeforeRequested;
- async Task<Page> INavigationPageController.PopAsyncInner(bool animated, bool fast)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public async Task<Page> PopAsyncInner(bool animated, bool fast)
{
- if (((INavigationPageController)this).StackDepth == 1)
+ if (StackDepth == 1)
{
return null;
}
- var page = (Page)PageController.InternalChildren.Last();
+ var page = (Page)InternalChildren.Last();
var args = new NavigationRequestedEventArgs(page, animated);
var removed = true;
- EventHandler<NavigationRequestedEventArgs> requestPop = PopRequestedInternal;
+ EventHandler<NavigationRequestedEventArgs> requestPop = PopRequested;
if (requestPop != null)
{
requestPop(this, args);
if (!removed && !fast)
return CurrentPage;
- PageController.InternalChildren.Remove(page);
+ InternalChildren.Remove(page);
- CurrentPage = (Page)PageController.InternalChildren.Last();
+ CurrentPage = (Page)InternalChildren.Last();
if (Popped != null)
Popped(this, args);
return page;
}
- event EventHandler<NavigationRequestedEventArgs> PopRequestedInternal;
-
- event EventHandler<NavigationRequestedEventArgs> INavigationPageController.PopRequested
- {
- add { PopRequestedInternal += value; }
- remove { PopRequestedInternal -= value; }
- }
-
- event EventHandler<NavigationRequestedEventArgs> PopToRootRequestedInternal;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<NavigationRequestedEventArgs> PopRequested;
- event EventHandler<NavigationRequestedEventArgs> INavigationPageController.PopToRootRequested
- {
- add { PopToRootRequestedInternal += value; }
- remove { PopToRootRequestedInternal -= value; }
- }
-
- event EventHandler<NavigationRequestedEventArgs> PushRequestedInternal;
-
- event EventHandler<NavigationRequestedEventArgs> INavigationPageController.PushRequested
- {
- add { PushRequestedInternal += value; }
- remove { PushRequestedInternal -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<NavigationRequestedEventArgs> PopToRootRequested;
- event EventHandler<NavigationRequestedEventArgs> RemovePageRequestedInternal;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<NavigationRequestedEventArgs> PushRequested;
- event EventHandler<NavigationRequestedEventArgs> INavigationPageController.RemovePageRequested
- {
- add { RemovePageRequestedInternal += value; }
- remove { RemovePageRequestedInternal -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<NavigationRequestedEventArgs> RemovePageRequested;
void InsertPageBefore(Page page, Page before)
{
if (before == null)
throw new ArgumentNullException($"{nameof(before)} cannot be null.");
- if (!PageController.InternalChildren.Contains(before))
+ if (!InternalChildren.Contains(before))
throw new ArgumentException($"{nameof(before)} must be a child of the NavigationPage", nameof(before));
- if (PageController.InternalChildren.Contains(page))
+ if (InternalChildren.Contains(page))
throw new ArgumentException("Cannot insert page which is already in the navigation stack");
- EventHandler<NavigationRequestedEventArgs> handler = InsertPageBeforeRequestedInternal;
+ EventHandler<NavigationRequestedEventArgs> handler = InsertPageBeforeRequested;
handler?.Invoke(this, new NavigationRequestedEventArgs(page, before, false));
- int index = PageController.InternalChildren.IndexOf(before);
- PageController.InternalChildren.Insert(index, page);
+ int index = InternalChildren.IndexOf(before);
+ InternalChildren.Insert(index, page);
if (index == 0)
RootPage = page;
async Task PopToRootAsyncInner(bool animated)
{
- if (((INavigationPageController)this).StackDepth == 1)
+ if (StackDepth == 1)
return;
- Element[] childrenToRemove = PageController.InternalChildren.Skip(1).ToArray();
+ Element[] childrenToRemove = InternalChildren.Skip(1).ToArray();
foreach (Element child in childrenToRemove)
- PageController.InternalChildren.Remove(child);
+ InternalChildren.Remove(child);
CurrentPage = RootPage;
var args = new NavigationRequestedEventArgs(RootPage, animated);
- EventHandler<NavigationRequestedEventArgs> requestPopToRoot = PopToRootRequestedInternal;
+ EventHandler<NavigationRequestedEventArgs> requestPopToRoot = PopToRootRequested;
if (requestPopToRoot != null)
{
requestPopToRoot(this, args);
async Task PushAsyncInner(Page page, bool animated)
{
- if (PageController.InternalChildren.Contains(page))
+ if (InternalChildren.Contains(page))
return;
PushPage(page);
var args = new NavigationRequestedEventArgs(page, animated);
- EventHandler<NavigationRequestedEventArgs> requestPush = PushRequestedInternal;
+ EventHandler<NavigationRequestedEventArgs> requestPush = PushRequested;
if (requestPush != null)
{
requestPush(this, args);
void PushPage(Page page)
{
- PageController.InternalChildren.Add(page);
+ InternalChildren.Add(page);
- if (PageController.InternalChildren.Count == 1)
+ if (InternalChildren.Count == 1)
RootPage = page;
CurrentPage = page;
return;
}
- if (!PageController.InternalChildren.Contains(page))
+ if (!InternalChildren.Contains(page))
throw new ArgumentException("Page to remove must be contained on this Navigation Page");
- EventHandler<NavigationRequestedEventArgs> handler = RemovePageRequestedInternal;
+ EventHandler<NavigationRequestedEventArgs> handler = RemovePageRequested;
handler?.Invoke(this, new NavigationRequestedEventArgs(page, true));
- PageController.InternalChildren.Remove(page);
+ InternalChildren.Remove(page);
if (RootPage == page)
- RootPage = (Page)PageController.InternalChildren.First();
+ RootPage = (Page)InternalChildren.First();
}
void SafePop()
public NavigationImpl(NavigationPage owner)
{
Owner = owner;
- _castingList = new Lazy<ReadOnlyCastingList<Page, Element>>(() => new ReadOnlyCastingList<Page, Element>(((IPageController)Owner).InternalChildren));
+ _castingList = new Lazy<ReadOnlyCastingList<Page, Element>>(() => new ReadOnlyCastingList<Page, Element>(Owner.InternalChildren));
}
NavigationPage Owner { get; }
using System;
+using System.ComponentModel;
using Xamarin.Forms.Platform;
namespace Xamarin.Forms
public Action<Rectangle> OnDisplay { get; set; }
- event EventHandler IOpenGlViewController.DisplayRequested
- {
- add { DisplayRequested += value; }
- remove { DisplayRequested -= value; }
- }
-
public void Display()
{
EventHandler handler = DisplayRequested;
handler(this, EventArgs.Empty);
}
- event EventHandler DisplayRequested;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler DisplayRequested;
public OpenGLView()
{
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
+using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
ReadOnlyCollection<Element> _logicalChildren;
- IPageController PageController => this as IPageController;
- IElementController ElementController => this as IElementController;
-
public Page()
{
var toolbarItems = new ObservableCollection<ToolbarItem>();
toolbarItems.CollectionChanged += OnToolbarItemsCollectionChanged;
ToolbarItems = toolbarItems;
- PageController.InternalChildren.CollectionChanged += InternalChildrenOnCollectionChanged;
+ InternalChildren.CollectionChanged += InternalChildrenOnCollectionChanged;
_platformConfigurationRegistry = new Lazy<PlatformConfigurationRegistry<Page>>(() => new PlatformConfigurationRegistry<Page>(this));
}
public IList<ToolbarItem> ToolbarItems { get; internal set; }
- Rectangle IPageController.ContainerArea
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Rectangle ContainerArea
{
get { return _containerArea; }
set
}
}
- bool IPageController.IgnoresContainerArea
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool IgnoresContainerArea
{
get { return (bool)GetValue(IgnoresContainerAreaProperty); }
set { SetValue(IgnoresContainerAreaProperty, value); }
}
- ObservableCollection<Element> IPageController.InternalChildren { get; } = new ObservableCollection<Element>();
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ObservableCollection<Element> InternalChildren { get; } = new ObservableCollection<Element>();
internal override ReadOnlyCollection<Element> LogicalChildrenInternal =>
- _logicalChildren ?? (_logicalChildren = new ReadOnlyCollection<Element>(PageController.InternalChildren));
+ _logicalChildren ?? (_logicalChildren = new ReadOnlyCollection<Element>(InternalChildren));
public event EventHandler LayoutChanged;
Rectangle originalArea = area;
if (_containerAreaSet)
{
- area = PageController.ContainerArea;
+ area = ContainerArea;
area.X += Padding.Left;
area.Y += Padding.Right;
area.Width -= Padding.HorizontalThickness;
area.Height = Math.Max(0, area.Height);
}
- List<Element> elements = ElementController.LogicalChildren.ToList();
+ List<Element> elements = LogicalChildren.ToList();
foreach (Element element in elements)
{
var child = element as VisualElement;
if (child == null)
continue;
var page = child as Page;
- if (page != null && ((IPageController)page).IgnoresContainerArea)
+ if (page != null && page.IgnoresContainerArea)
Forms.Layout.LayoutChildIntoBoundingRegion(child, originalArea);
else
Forms.Layout.LayoutChildIntoBoundingRegion(child, area);
if (!ShouldLayoutChildren())
return;
- var startingLayout = new List<Rectangle>(ElementController.LogicalChildren.Count);
- foreach (VisualElement c in ElementController.LogicalChildren)
+ var startingLayout = new List<Rectangle>(LogicalChildren.Count);
+ foreach (VisualElement c in LogicalChildren)
{
startingLayout.Add(c.Bounds);
}
LayoutChildren(x, y, w, h);
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < LogicalChildren.Count; i++)
{
- var c = (VisualElement)ElementController.LogicalChildren[i];
+ var c = (VisualElement)LogicalChildren[i];
if (c.Bounds != startingLayout[i])
{
}
else
{
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < LogicalChildren.Count; i++)
{
- var v = ElementController.LogicalChildren[i] as VisualElement;
+ var v = LogicalChildren[i] as VisualElement;
if (v != null && v.IsVisible && (!v.IsPlatformEnabled || !v.IsNativeStateConsistent))
return;
}
}
}
- void IPageController.SendAppearing()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendAppearing()
{
if (_hasAppeared)
return;
handler(this, EventArgs.Empty);
var pageContainer = this as IPageContainer<Page>;
- ((IPageController)pageContainer?.CurrentPage)?.SendAppearing();
+ pageContainer?.CurrentPage?.SendAppearing();
}
- void IPageController.SendDisappearing()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendDisappearing()
{
if (!_hasAppeared)
return;
MessagingCenter.Send(this, BusySetSignalName, false);
var pageContainer = this as IPageContainer<Page>;
- ((IPageController)pageContainer?.CurrentPage)?.SendDisappearing();
+ pageContainer?.CurrentPage?.SendDisappearing();
OnDisappearing();
EventHandler handler = Disappearing;
bool ShouldLayoutChildren()
{
- if (!ElementController.LogicalChildren.Any() || Width <= 0 || Height <= 0 || !IsNativeStateConsistent)
+ if (!LogicalChildren.Any() || Width <= 0 || Height <= 0 || !IsNativeStateConsistent)
return false;
var container = this as IPageContainer<Page>;
if (container?.CurrentPage != null)
{
- if (PageController.InternalChildren.Contains(container.CurrentPage))
+ if (InternalChildren.Contains(container.CurrentPage))
return container.CurrentPage.IsPlatformEnabled && container.CurrentPage.IsNativeStateConsistent;
return true;
}
var any = false;
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < LogicalChildren.Count; i++)
{
- var v = ElementController.LogicalChildren[i] as VisualElement;
+ var v = LogicalChildren[i] as VisualElement;
if (v != null && (!v.IsPlatformEnabled || !v.IsNativeStateConsistent))
{
any = true;
using System;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
namespace Xamarin.Forms
set { SetValue(TouchPointsProperty, value); }
}
- void IPanGestureController.SendPan(Element sender, double totalX, double totalY, int gestureId)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPan(Element sender, double totalX, double totalY, int gestureId)
{
PanUpdated?.Invoke(sender, new PanUpdatedEventArgs(GestureStatus.Running, gestureId, totalX, totalY));
}
- void IPanGestureController.SendPanCanceled(Element sender, int gestureId)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPanCanceled(Element sender, int gestureId)
{
PanUpdated?.Invoke(sender, new PanUpdatedEventArgs(GestureStatus.Canceled, gestureId));
}
- void IPanGestureController.SendPanCompleted(Element sender, int gestureId)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPanCompleted(Element sender, int gestureId)
{
PanUpdated?.Invoke(sender, new PanUpdatedEventArgs(GestureStatus.Completed, gestureId));
}
- void IPanGestureController.SendPanStarted(Element sender, int gestureId)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPanStarted(Element sender, int gestureId)
{
PanUpdated?.Invoke(sender, new PanUpdatedEventArgs(GestureStatus.Started, gestureId));
}
using System;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
namespace Xamarin.Forms
{
public sealed class PinchGestureRecognizer : GestureRecognizer, IPinchGestureController
{
- bool IPinchGestureController.IsPinching { get; set; }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool IsPinching { get; set; }
- void IPinchGestureController.SendPinch(Element sender, double delta, Point currentScalePoint)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPinch(Element sender, double delta, Point currentScalePoint)
{
EventHandler<PinchGestureUpdatedEventArgs> handler = PinchUpdated;
if (handler != null)
{
handler(sender, new PinchGestureUpdatedEventArgs(GestureStatus.Running, delta, currentScalePoint));
}
- ((IPinchGestureController)this).IsPinching = true;
+ IsPinching = true;
}
- void IPinchGestureController.SendPinchCanceled(Element sender)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPinchCanceled(Element sender)
{
EventHandler<PinchGestureUpdatedEventArgs> handler = PinchUpdated;
if (handler != null)
{
handler(sender, new PinchGestureUpdatedEventArgs(GestureStatus.Canceled));
}
- ((IPinchGestureController)this).IsPinching = false;
+ IsPinching = false;
}
- void IPinchGestureController.SendPinchEnded(Element sender)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPinchEnded(Element sender)
{
EventHandler<PinchGestureUpdatedEventArgs> handler = PinchUpdated;
if (handler != null)
{
handler(sender, new PinchGestureUpdatedEventArgs(GestureStatus.Completed));
}
- ((IPinchGestureController)this).IsPinching = false;
+ IsPinching = false;
}
- void IPinchGestureController.SendPinchStarted(Element sender, Point initialScalePoint)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendPinchStarted(Element sender, Point initialScalePoint)
{
EventHandler<PinchGestureUpdatedEventArgs> handler = PinchUpdated;
if (handler != null)
{
handler(sender, new PinchGestureUpdatedEventArgs(GestureStatus.Started, 1, initialScalePoint));
}
- ((IPinchGestureController)this).IsPinching = true;
+ IsPinching = true;
}
public event EventHandler<PinchGestureUpdatedEventArgs> PinchUpdated;
using System;
+using System.ComponentModel;
using System.Threading.Tasks;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
_platformConfigurationRegistry = new Lazy<PlatformConfigurationRegistry<ScrollView>>(() => new PlatformConfigurationRegistry<ScrollView>(this));
}
- Point IScrollViewController.GetScrollPositionForElement(VisualElement item, ScrollToPosition pos)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Point GetScrollPositionForElement(VisualElement item, ScrollToPosition pos)
{
ScrollToPosition position = pos;
double y = GetCoordinate(item, "Y", 0);
return new Point(x, y);
}
- event EventHandler<ScrollToRequestedEventArgs> IScrollViewController.ScrollToRequested
- {
- add { ScrollToRequested += value; }
- remove { ScrollToRequested -= value; }
- }
-
- void IScrollViewController.SendScrollFinished()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendScrollFinished()
{
if (_scrollCompletionSource != null)
_scrollCompletionSource.TrySetResult(true);
}
- void IScrollViewController.SetScrolledPosition(double x, double y)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetScrolledPosition(double x, double y)
{
if (ScrollX == x && ScrollY == y)
return;
handler(this, e);
}
- event EventHandler<ScrollToRequestedEventArgs> ScrollToRequested;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<ScrollToRequestedEventArgs> ScrollToRequested;
}
}
\ No newline at end of file
using System;
+using System.ComponentModel;
using System.Windows.Input;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
_platformConfigurationRegistry = new Lazy<PlatformConfigurationRegistry<SearchBar>>(() => new PlatformConfigurationRegistry<SearchBar>(this));
}
- void ISearchBarController.OnSearchButtonPressed()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void OnSearchButtonPressed()
{
ICommand cmd = SearchCommand;
OnModelChanged();
}
}
- ITableModel ITableViewController.Model
+
+ ITableModel ITableViewController.Model
{
- get
+ get
{
return Model;
}
return new SizeRequest(request, minimumSize);
}
- internal event EventHandler ModelChanged;
- event EventHandler ITableViewController.ModelChanged
- {
- add { ModelChanged += value; }
- remove { ModelChanged -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler ModelChanged;
public IPlatformElementConfiguration<T, TableView> On<T>() where T : IConfigPlatform
{
set { SetValue(ControlTemplateProperty, value); }
}
- IList<Element> IControlTemplated.InternalChildren => ((IPageController)this).InternalChildren;
+ IList<Element> IControlTemplated.InternalChildren => InternalChildren;
internal override void ComputeConstraintForView(View view)
{
}
}
- void IVisualElementController.NativeSizeChanged()
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void NativeSizeChanged()
{
InvalidateMeasureInternal(InvalidationTrigger.MeasureChanged);
}
using System;
+using System.ComponentModel;
using Xamarin.Forms.Internals;
using Xamarin.Forms.Platform;
_platformConfigurationRegistry = new Lazy<PlatformConfigurationRegistry<WebView>>(() => new PlatformConfigurationRegistry<WebView>(this));
}
- bool IWebViewController.CanGoBack {
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ bool IWebViewController.CanGoBack
+ {
get { return CanGoBack; }
set { SetValue(CanGoBackPropertyKey, value); }
}
get { return (bool)GetValue(CanGoBackProperty); }
}
- bool IWebViewController.CanGoForward {
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ bool IWebViewController.CanGoForward
+ {
get { return CanGoForward; }
set { SetValue(CanGoForwardPropertyKey, value); }
}
remove { EvalRequested -= value; }
}
- event EventHandler<EvalRequested> EvalRequested;
-
- event EventHandler IWebViewController.GoBackRequested {
- add { GoBackRequested += value; }
- remove { GoBackRequested -= value; }
- }
-
- event EventHandler GoBackRequested;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<EvalRequested> EvalRequested;
- event EventHandler IWebViewController.GoForwardRequested {
- add { GoForwardRequested += value; }
- remove { GoForwardRequested -= value; }
- }
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler GoBackRequested;
- event EventHandler GoForwardRequested;
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler GoForwardRequested;
- void IWebViewController.SendNavigated(WebNavigatedEventArgs args)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendNavigated(WebNavigatedEventArgs args)
{
Navigated?.Invoke(this, args);
}
- void IWebViewController.SendNavigating(WebNavigatingEventArgs args)
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendNavigating(WebNavigatingEventArgs args)
{
Navigating?.Invoke(this, args);
}
if (_cell == value)
return;
- ICellController cellController = _cell;
-
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendDisappearing);
+ if (_cell != null)
+ Device.BeginInvokeOnMainThread(_cell.SendDisappearing);
_cell = value;
- cellController = value;
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendAppearing);
+ if (_cell != null)
+ Device.BeginInvokeOnMainThread(_cell.SendAppearing);
}
}
if (menuItem.Enabled)
menuItem.Activated += (sender, e) =>
{
- ((IMenuItemController)contextAction).Activate();
+ contextAction.Activate();
};
if (!string.IsNullOrEmpty(contextAction.Icon))
menuItem.Image = new NSImage(contextAction.Icon);
void UpdateCell(ViewCell cell)
{
- ICellController cellController = _viewCell;
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendDisappearing);
+ if (_viewCell != null)
+ Device.BeginInvokeOnMainThread(_viewCell.SendDisappearing);
_viewCell = cell;
- cellController = cell;
- Device.BeginInvokeOnMainThread(cellController.SendAppearing);
+ Device.BeginInvokeOnMainThread(_viewCell.SendAppearing);
IVisualElementRenderer renderer;
if (_rendererRef == null || !_rendererRef.TryGetTarget(out renderer))
{
const string ToolBarId = "AwesomeBarToolbar";
- INavigationPageController NavigationController => _navigation;
-
readonly string _defaultBackButtonTitle = "Back";
readonly ToolbarTracker _toolbarTracker;
if (NSApplication.SharedApplication.MainWindow == null)
return;
- if (NavigationController == null)
+ if (_navigation == null)
{
if (_toolbar != null)
_toolbar.Visible = false;
return;
}
- var currentPage = NavigationController.Peek();
+ var currentPage = _navigation.Peek(0);
if (NavigationPage.GetHasNavigationBar(currentPage))
{
async Task NavigateBackFrombackButton()
{
- var popAsyncInner = NavigationController?.PopAsyncInner(true, true);
+ var popAsyncInner = _navigation?.PopAsyncInner(true, true);
if (popAsyncInner != null)
await popAsyncInner;
}
bool IsRootPage()
{
- if (NavigationController == null)
+ if (_navigation == null)
return true;
- return NavigationController.StackDepth <= 1;
+ return _navigation.StackDepth <= 1;
}
NSColor GetBackgroundColor()
string GetCurrentPageTitle()
{
- if (NavigationController == null)
+ if (_navigation == null)
return string.Empty;
- return NavigationController.Peek().Title ?? "";
+ return _navigation.Peek(0).Title ?? "";
}
string GetPreviousPageTitle()
{
- if (NavigationController == null || NavigationController.StackDepth <= 1)
+ if (_navigation == null || _navigation.StackDepth <= 1)
return string.Empty;
- return NavigationController.Peek(1).Title ?? _defaultBackButtonTitle;
+ return _navigation.Peek(1).Title ?? _defaultBackButtonTitle;
}
List<ToolbarItem> GetToolbarItems()
if (_toolbar == null || _navigation == null || _toolbarGroup == null)
return;
- var currentPage = NavigationController.Peek();
+ var currentPage = _navigation.Peek(0);
UpdateGroup(_toolbarGroup, currentPage.ToolbarItems, ToolbarItemWidth, ToolbarItemSpacing);
}
var element = toolbarItems[i];
var item = new NSToolbarItem(element.Text ?? "");
- item.Activated += (sender, e) => (element as IMenuItemController).Activate();
+ item.Activated += (sender, e) => element.Activate();
var button = new NSButton();
button.Title = element.Text ?? "";
button.Frame = new CGRect(currentX + i * itemSpacing, 0, buttonWidth, ToolbarItemHeight);
currentX += buttonWidth;
totalWidth += button.Frame.Width;
- button.Activated += (sender, e) => (element as IMenuItemController).Activate();
+ button.Activated += (sender, e) => element.Activate();
button.BezelStyle = NSBezelStyle.TexturedRounded;
if (!string.IsNullOrEmpty(element.Icon))
{
}
- IElementController ElementController => Element;
-
- IPageController PageController => (IPageController)Element;
+ Page Page => (Page)Element;
public override nint SelectedIndex
{
return;
base.SelectedIndex = value;
if (Carousel != null)
- Carousel.CurrentPage = (ContentPage)ElementController.LogicalChildren[(int)SelectedIndex];
+ Carousel.CurrentPage = (ContentPage)Element.LogicalChildren[(int)SelectedIndex];
}
}
return;
_appeared = true;
- PageController.SendAppearing();
+ Page.SendAppearing();
}
public override void ViewDidDisappear()
return;
_appeared = false;
- PageController.SendDisappearing();
+ Page.SendDisappearing();
}
protected override void Dispose(bool disposing)
if (_appeared)
{
_appeared = false;
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
}
if (_events != null)
void UpdateSource()
{
var pages = new List<NSPageContainer>();
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < Element.LogicalChildren.Count; i++)
{
- Element element = ElementController.LogicalChildren[i];
+ Element element = Element.LogicalChildren[i];
var child = element as ContentPage;
if (child != null)
pages.Add(new NSPageContainer(child, i));
IImageSourceHandler handler;
- ((IImageController)Element).SetIsLoading(true);
+ Element.SetIsLoading(true);
if (source != null && (handler = Internals.Registrar.Registered.GetHandler<IImageSourceHandler>(source.GetType())) != null)
{
Control.Image = null;
if (!_isDisposed)
- ((IImageController)Element).SetIsLoading(false);
+ Element.SetIsLoading(false);
}
void SetOpacity()
readonly NSTableView _nsTableView;
protected readonly ListView List;
- IListViewController Controller => List;
-
ITemplatedItemsView<Cell> TemplatedItemsView => List;
bool _selectionFromNative;
return;
_selectionFromNative = true;
- Controller.NotifyRowTapped((int)indexPath.Section, (int)indexPath.Item, cell);
+ List.NotifyRowTapped((int)indexPath.Section, (int)indexPath.Item, cell);
}
NSView nativeCell;
- var cachingStrategy = Controller.CachingStrategy;
+ var cachingStrategy = List.CachingStrategy;
if (cachingStrategy == ListViewCachingStrategy.RetainElement)
{
cell = GetCellForPath(indexPath, isHeader);
{
var templatedList = TemplatedItemsView.TemplatedItems.GetGroup(sectionIndex);
cell = (Cell)((INativeElementView)nativeCell).Element;
- ICellController controller = cell;
- controller.SendDisappearing();
+
+ cell.SendDisappearing();
templatedList.UpdateContent(cell, itemIndexInSection);
- controller.SendAppearing();
+ cell.SendAppearing();
}
}
else
IVisualElementRenderer _headerRenderer;
IVisualElementRenderer _footerRenderer;
- IListViewController Controller => Element;
-
ITemplatedItemsView<Cell> TemplatedItemsView => Element;
public const int DefaultRowHeight = 44;
{
if (e.OldElement != null)
{
- var controller = (IListViewController)e.OldElement;
- controller.ScrollToRequested -= OnScrollToRequested;
+ var listView = e.OldElement;
+ listView.ScrollToRequested -= OnScrollToRequested;
var templatedItems = ((ITemplatedItemsView<Cell>)e.OldElement).TemplatedItems;
templatedItems.CollectionChanged -= OnCollectionChanged;
SetNativeControl(scroller);
}
- var controller = (IListViewController)e.NewElement;
- controller.ScrollToRequested += OnScrollToRequested;
+ var listView = e.NewElement;
+ listView.ScrollToRequested += OnScrollToRequested;
var templatedItems = ((ITemplatedItemsView<Cell>)e.NewElement).TemplatedItems;
templatedItems.CollectionChanged += OnCollectionChanged;
void UpdateHeader()
{
- var header = Controller.HeaderElement;
+ var header = Element.HeaderElement;
var headerView = (View)header;
if (headerView != null)
VisualElementTracker _tracker;
MasterDetailPage _masterDetailPage;
- IPageController PageController => Element as IPageController;
+ Page Page => Element as Page;
void IEffectControlProvider.RegisterEffect(Effect effect)
{
{
if (!_disposed && disposing)
{
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
if (Element != null)
{
VisualElementTracker _tracker;
Stack<NavigationChildPageWrapper> _currentStack = new Stack<NavigationChildPageWrapper>();
- IPageController PageController => Element as IPageController;
-
- IElementController ElementController => Element as IElementController;
-
- INavigationPageController NavigationController => Element as INavigationPageController;
+ NavigationPage NavigationPage => Element as NavigationPage;
void IEffectControlProvider.RegisterEffect(Effect effect)
{
{
if (Element != null)
{
- PageController?.SendDisappearing();
- ((Element as IPageContainer<Page>)?.CurrentPage as IPageController)?.SendDisappearing();
+ NavigationPage?.SendDisappearing();
+ ((Element as IPageContainer<Page>)?.CurrentPage as Page)?.SendDisappearing();
Element.PropertyChanged -= HandlePropertyChanged;
Element = null;
}
return;
Platform.NativeToolbarTracker.TryHide(Element as NavigationPage);
_appeared = false;
- PageController?.SendDisappearing();
+ NavigationPage?.SendDisappearing();
}
public override void ViewDidAppear()
return;
_appeared = true;
- PageController?.SendAppearing();
+ NavigationPage?.SendAppearing();
}
protected virtual void OnElementChanged(VisualElementChangedEventArgs e)
Platform.NativeToolbarTracker.Navigation = navPage;
- NavigationController.PushRequested += OnPushRequested;
- NavigationController.PopRequested += OnPopRequested;
- NavigationController.PopToRootRequested += OnPopToRootRequested;
- NavigationController.RemovePageRequested += OnRemovedPageRequested;
- NavigationController.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
+ NavigationPage.PushRequested += OnPushRequested;
+ NavigationPage.PopRequested += OnPopRequested;
+ NavigationPage.PopToRootRequested += OnPopToRootRequested;
+ NavigationPage.RemovePageRequested += OnRemovedPageRequested;
+ NavigationPage.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
navPage.Popped += (sender, e) => Platform.NativeToolbarTracker.UpdateToolBar();
navPage.PoppedToRoot += (sender, e) => Platform.NativeToolbarTracker.UpdateToolBar();
_events.LoadEvents(NativeView);
_tracker = new VisualElementTracker(this);
- ((INavigationPageController)navPage).Pages.ForEach(async p => await PushPageAsync(p, false));
+ navPage.Pages.ForEach(async p => await PushPageAsync(p, false));
UpdateBackgroundColor();
}
void RemovePage(Page page, bool removeFromStack)
{
- (page as IPageController)?.SendDisappearing();
+ page?.SendDisappearing();
var target = Platform.GetRenderer(page);
target?.NativeView?.RemoveFromSuperview();
target?.ViewController?.RemoveFromParentViewController();
throw new NotSupportedException("Popped page does not appear on top of current navigation stack, please file a bug.");
_currentStack.Pop();
- (page as IPageController)?.SendDisappearing();
+ page.SendDisappearing();
var target = Platform.GetRenderer(page);
var previousPage = _currentStack.Peek().Page;
var vco = Platform.GetRenderer(oldPage);
AddChildViewController(vc.ViewController);
return await this.HandleAsyncAnimation(vco.ViewController, vc.ViewController,
- NSViewControllerTransitionOptions.SlideForward, () => (page as IPageController)?.SendAppearing(), true);
+ NSViewControllerTransitionOptions.SlideForward, () => page?.SendAppearing(), true);
}
void UpdateBackgroundColor()
if (_tracker == null)
return;
- if (e.PropertyName == NavigationPage.BarBackgroundColorProperty.PropertyName)
+ if (e.PropertyName == Xamarin.Forms.NavigationPage.BarBackgroundColorProperty.PropertyName)
UpdateBarBackgroundColor();
- else if (e.PropertyName == NavigationPage.BarTextColorProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.NavigationPage.BarTextColorProperty.PropertyName)
UpdateBarTextColor();
else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
UpdateBackgroundColor();
_displayLink = null;
if (Element != null)
- ((IOpenGlViewController)Element).DisplayRequested -= Display;
+ Element.DisplayRequested -= Display;
}
base.Dispose(disposing);
protected override void OnElementChanged(ElementChangedEventArgs<OpenGLView> e)
{
if (e.OldElement != null)
- ((IOpenGlViewController)e.OldElement).DisplayRequested -= Display;
+ e.OldElement.DisplayRequested -= Display;
if (e.NewElement != null)
{
var glkView = new MacOSOpenGLView();
SetNativeControl(glkView);
- ((IOpenGlViewController)e.NewElement).DisplayRequested += Display;
+ e.NewElement.DisplayRequested += Display;
SetupRenderLoop(false);
}
VisualElementPackager _packager;
VisualElementTracker _tracker;
- IPageController PageController => Element as IPageController;
+ Page Page => Element as Page;
public PageRenderer()
{
return;
_appeared = true;
- PageController.SendAppearing();
+ Page.SendAppearing();
}
public override void ViewDidDisappear()
return;
_appeared = false;
- PageController.SendDisappearing();
+ Page.SendDisappearing();
}
public override void ViewWillAppear()
Element.PropertyChanged -= OnHandlePropertyChanged;
Platform.SetRenderer(Element, null);
if (_appeared)
- PageController.SendDisappearing();
+ Page.SendDisappearing();
_appeared = false;
HasVerticalScroller = true;
}
- IScrollViewController Controller => Element as IScrollViewController;
+ ScrollView ScrollView => Element as ScrollView;
public VisualElement Element { get; private set; }
if (oldElement != null)
{
oldElement.PropertyChanged -= HandlePropertyChanged;
- ((IScrollViewController)oldElement).ScrollToRequested -= OnScrollToRequested;
+ ((ScrollView)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
element.PropertyChanged += HandlePropertyChanged;
- ((IScrollViewController)element).ScrollToRequested += OnScrollToRequested;
+ ((ScrollView)element).ScrollToRequested += OnScrollToRequested;
if (_tracker == null)
{
PackContent();
{
ClearContentRenderer();
- if (Controller.Children.Count == 0 || !(Controller.Children[0] is VisualElement))
+ if (ScrollView.Children.Count == 0 || !(ScrollView.Children[0] is VisualElement))
return;
- var content = (VisualElement)Controller.Children[0];
+ var content = (VisualElement)ScrollView.Children[0];
if (Platform.GetRenderer(content) == null)
Platform.SetRenderer(content, Platform.CreateRenderer(content));
void HandleScrollAnimationEnded(object sender, EventArgs e)
{
- Controller.SendScrollFinished();
+ ScrollView.SendScrollFinished();
}
void HandleScrolled(object sender, EventArgs e)
Point scrollPoint = (e.Mode == ScrollToMode.Position)
? new Point(e.ScrollX, Element.Height - e.ScrollY)
- : Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
+ : ScrollView.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
(DocumentView as NSView)?.ScrollPoint(scrollPoint.ToPointF());
- Controller.SendScrollFinished();
+ ScrollView.SendScrollFinished();
}
void UpdateBackgroundColor()
{
var convertedPoint = (DocumentView as NSView)?.ConvertPointFromView(ContentView.Bounds.Location, ContentView);
if (convertedPoint.HasValue)
- Controller.SetScrolledPosition(Math.Max(0, convertedPoint.Value.X), Math.Max(0, convertedPoint.Value.Y));
+ ScrollView.SetScrolledPosition(Math.Max(0, convertedPoint.Value.X), Math.Max(0, convertedPoint.Value.Y));
}
void ClearContentRenderer()
void OnSearchButtonClicked(object sender, EventArgs e)
{
- ((ISearchBarController)Element).OnSearchButtonPressed();
+ Element.OnSearchButtonPressed();
Control.ResignFirstResponder();
}
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
}
- IPageController PageController => Element as IPageController;
-
- IElementController ElementController => Element;
+ Page Page => Element as Page;
void IEffectControlProvider.RegisterEffect(Effect effect)
{
View.Frame = new System.Drawing.RectangleF((float)Element.X, (float)Element.Y, (float)Element.Width, (float)Element.Height);
var frame = View.Frame;
- PageController.ContainerArea = new Rectangle(0, 0, frame.Width, frame.Height - TabHolderHeight);
+ Page.ContainerArea = new Rectangle(0, 0, frame.Width, frame.Height - TabHolderHeight);
if (!_queuedSize.IsZero)
{
public override void ViewDidAppear()
{
- PageController.SendAppearing();
+ Page.SendAppearing();
base.ViewDidAppear();
}
public override void ViewDidDisappear()
{
base.ViewDidDisappear();
- PageController.SendDisappearing();
+ Page.SendDisappearing();
}
protected override void Dispose(bool disposing)
if (disposing && !_disposed)
{
_disposed = true;
- PageController.SendDisappearing();
+ Page.SendDisappearing();
Tabbed.PropertyChanged -= OnPropertyChanged;
Tabbed.PagesChanged -= OnPagesChanged;
void SetControllers()
{
_updatingControllers = true;
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < Element.LogicalChildren.Count; i++)
{
- var child = ElementController.LogicalChildren[i];
+ var child = Element.LogicalChildren[i];
var page = child as Page;
if (page == null)
continue;
int originalIndex;
if (int.TryParse(TabViewItems[i].ViewController.Identifier, out originalIndex))
{
- var page = PageController.InternalChildren[originalIndex];
+ var page = Page.InternalChildren[originalIndex];
TabbedPage.SetIndex(page as Page, i);
}
}
void UpdateCurrentPage()
{
- var count = PageController.InternalChildren.Count;
+ var count = Page.InternalChildren.Count;
Tabbed.CurrentPage = SelectedTabViewItemIndex >= 0 && SelectedTabViewItemIndex < count
? Tabbed.GetPageByIndex((int)SelectedTabViewItemIndex)
: null;
const string HeaderIdentifier = nameof(TextCell);
const string ItemIdentifier = nameof(ViewCell);
- protected ITableViewController Controller => _tableView;
-
readonly NSTableView _nsTableView;
readonly TableView _tableView;
{
_tableView = tableViewRenderer.Element;
_nsTableView = tableViewRenderer.TableView;
- Controller.ModelChanged += (s, e) => { _nsTableView?.ReloadData(); };
+ _tableView.ModelChanged += (s, e) => { _nsTableView?.ReloadData(); };
AutomaticallyDeselect = true;
}
GetComputedIndexes(row, out sectionIndex, out itemIndexInSection, out isHeader);
- var cell = Controller.Model.GetCell(sectionIndex, itemIndexInSection);
- Controller.Model.RowSelected(cell);
+ var cell = _tableView.Model.GetCell(sectionIndex, itemIndexInSection);
+ _tableView.Model.RowSelected(cell);
if (AutomaticallyDeselect)
_nsTableView.DeselectRow(row);
}
public override nint GetRowCount(NSTableView tableView)
{
nint count = 0;
- s_sectionCount = Controller.Model.GetSectionCount();
+ s_sectionCount = _tableView.Model.GetSectionCount();
for (int i = 0; i < s_sectionCount; i++)
{
- count += Controller.Model.GetRowCount(i) + 1;
+ count += _tableView.Model.GetRowCount(i) + 1;
}
return count;
if (isHeader)
{
id = HeaderIdentifier;
- cell = Controller.Model.GetHeaderCell(sectionIndex) ??
- new TextCell { Text = Controller.Model.GetSectionTitle(sectionIndex) };
+ cell = _tableView.Model.GetHeaderCell(sectionIndex) ??
+ new TextCell { Text = _tableView.Model.GetSectionTitle(sectionIndex) };
}
else
{
id = ItemIdentifier;
- cell = Controller.Model.GetCell(sectionIndex, itemIndexInSection);
+ cell = _tableView.Model.GetCell(sectionIndex, itemIndexInSection);
}
var nativeCell = CellNSView.GetNativeCell(tableView, cell, id, isHeader);
for (int i = 0; i < s_sectionCount; i++)
{
- var groupCount = Controller.Model.GetRowCount(i);
+ var groupCount = _tableView.Model.GetRowCount(i);
var itemsInSection = groupCount + 1;
if (row < totalItems + itemsInSection)
WebNavigationEvent _lastBackForwardEvent;
WebNavigationEvent _lastEvent;
- IWebViewController ElementController => Element;
-
void IWebViewDelegate.LoadHtml(string html, string baseUrl)
{
if (html != null)
Control.OnFinishedLoading += OnNSWebViewFinishedLoad;
Control.OnFailedLoading += OnNSWebViewFailedLoadWithError;
- ElementController.EvalRequested += OnEvalRequested;
- ElementController.GoBackRequested += OnGoBackRequested;
- ElementController.GoForwardRequested += OnGoForwardRequested;
+ Element.EvalRequested += OnEvalRequested;
+ Element.GoBackRequested += OnGoBackRequested;
+ Element.GoForwardRequested += OnGoForwardRequested;
Layer.BackgroundColor = NSColor.Clear.CGColor;
}
_disposed = true;
Control.OnFinishedLoading -= OnNSWebViewFinishedLoad;
Control.OnFailedLoading -= OnNSWebViewFailedLoadWithError;
- ElementController.EvalRequested -= OnEvalRequested;
- ElementController.GoBackRequested -= OnGoBackRequested;
- ElementController.GoForwardRequested -= OnGoForwardRequested;
+ Element.EvalRequested -= OnEvalRequested;
+ Element.GoBackRequested -= OnGoBackRequested;
+ Element.GoForwardRequested -= OnGoForwardRequested;
}
base.Dispose(disposing);
}
{
if (Element == null)
return;
- ElementController.CanGoBack = Control.CanGoBack();
- ElementController.CanGoForward = Control.CanGoForward();
+ ((IWebViewController)Element).CanGoBack = Control.CanGoBack();
+ ((IWebViewController)Element).CanGoForward = Control.CanGoForward();
}
void OnEvalRequested(object sender, EvalRequested eventArg)
void OnNSWebViewFailedLoadWithError(object sender, WebKit.WebResourceErrorEventArgs e)
{
_lastEvent = _lastBackForwardEvent;
- ElementController?.SendNavigated(new WebNavigatedEventArgs(_lastEvent, new UrlWebViewSource { Url = Control.MainFrameUrl },
+ Element?.SendNavigated(new WebNavigatedEventArgs(_lastEvent, new UrlWebViewSource { Url = Control.MainFrameUrl },
Control.MainFrameUrl, WebNavigationResult.Failure));
UpdateCanGoBackForward();
return;
_ignoreSourceChanges = true;
- ElementController?.SetValueFromRenderer(WebView.SourceProperty, new UrlWebViewSource { Url = Control.MainFrameUrl });
+ Element?.SetValueFromRenderer(WebView.SourceProperty, new UrlWebViewSource { Url = Control.MainFrameUrl });
_ignoreSourceChanges = false;
_lastEvent = _lastBackForwardEvent;
- ElementController?.SendNavigated(new WebNavigatedEventArgs(_lastEvent, Element?.Source, Control.MainFrameUrl,
+ Element?.SendNavigated(new WebNavigatedEventArgs(_lastEvent, Element?.Source, Control.MainFrameUrl,
WebNavigationResult.Success));
UpdateCanGoBackForward();
if (ActualWidth > 0 && ActualHeight > 0)
{
var page = (Page)DataContext;
- ((IPageController)page.RealParent).ContainerArea = new Rectangle(0, 0, ActualWidth, ActualHeight);
+ ((Page)page.RealParent).ContainerArea = new Rectangle(0, 0, ActualWidth, ActualHeight);
}
};
}
void FormsPresenter_Loaded(object sender, RoutedEventArgs e)
{
- var page = (IPageController)DataContext;
+ var page = (Page)DataContext;
page.SendAppearing();
}
void FormsPresenter_Unloaded(object sender, RoutedEventArgs e)
{
- var page = (IPageController)DataContext;
+ var page = (Page)DataContext;
page.SendDisappearing();
}
}
{
set { Control.ToolbarForeground = value; }
}
-
- IPageController PageController => Element as IPageController;
-
- IMasterDetailPageController MasterDetailPageController => Element as IMasterDetailPageController;
bool ITitleProvider.ShowTitle
{
if (Element == null)
return;
- PageController.SendAppearing();
+ Element.SendAppearing();
UpdateBounds();
}
void OnControlUnloaded(object sender, RoutedEventArgs routedEventArgs)
{
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
void OnDetailPropertyChanged(object sender, PropertyChangedEventArgs e)
Windows.Foundation.Size masterSize = Control.MasterSize;
Windows.Foundation.Size detailSize = Control.DetailSize;
- MasterDetailPageController.MasterBounds = new Rectangle(0, 0, masterSize.Width, masterSize.Height);
- MasterDetailPageController.DetailBounds = new Rectangle(0, 0, detailSize.Width, detailSize.Height);
+ Element.MasterBounds = new Rectangle(0, 0, masterSize.Width, masterSize.Height);
+ Element.DetailBounds = new Rectangle(0, 0, detailSize.Width, detailSize.Height);
}
void UpdateDetail()
UpdateDetailTitle();
Control.CollapseStyle = Element.OnThisPlatform().GetCollapseStyle();
Control.CollapsedPaneWidth = Element.OnThisPlatform().CollapsedPaneWidth();
- Control.ShouldShowSplitMode = MasterDetailPageController.ShouldShowSplitMode;
+ Control.ShouldShowSplitMode = Element.ShouldShowSplitMode;
}
void UpdateToolbarPlacement()
void UpdateBackButton()
{
- bool showBackButton = PageController.InternalChildren.Count > 1 && NavigationPage.GetHasBackButton(_currentPage);
+ bool showBackButton = Element.InternalChildren.Count > 1 && NavigationPage.GetHasBackButton(_currentPage);
_container.ShowBackButton = showBackButton;
if (_navManager != null)
void OnQuerySubmitted(AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs e)
{
- ((ISearchBarController)Element).OnSearchButtonPressed();
+ Element.OnSearchButtonPressed();
}
void OnTextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs e)
set { Control.ToolbarForeground = value; }
}
- IPageController PageController => Element as IPageController;
-
bool ITitleProvider.ShowTitle
{
get { return _showTitle; }
return;
_disposed = true;
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
SetElement(null);
Tracker = null;
}
void OnLoaded(object sender, RoutedEventArgs args)
{
- PageController?.SendAppearing();
+ Element?.SendAppearing();
UpdateBarTextColor();
UpdateBarBackgroundColor();
}
Page currentPage = Element.CurrentPage;
if (currentPage == page)
return;
- ((IPageController)currentPage)?.SendDisappearing();
+ currentPage?.SendDisappearing();
Element.CurrentPage = page;
- ((IPageController)page)?.SendAppearing();
+ page?.SendAppearing();
}
void OnUnloaded(object sender, RoutedEventArgs args)
{
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
Brush GetBarBackgroundBrush()
if (oldCell != null)
{
oldCell.PropertyChanged -= _propertyChangedHandler;
- ((ICellController)oldCell).SendDisappearing();
+ oldCell.SendDisappearing();
}
if (newCell != null)
{
- ((ICellController)newCell).SendAppearing();
+ newCell.SendAppearing();
if (oldCell == null || oldCell.GetType() != newCell.GetType())
ContentTemplate = GetTemplate(newCell);
var menuItem = item.DataContext as MenuItem;
if (menuItem != null)
- ((IMenuItemController)menuItem).Activate();
+ menuItem.Activate();
};
return item;
}
async void SetSource(System.Windows.Controls.Image image)
{
- ((IImageController)Element).SetIsLoading(true);
+ Element.SetIsLoading(true);
ImageSource source = Element.Source;
IImageSourceHandler handler;
else
image.Source = null;
- ((IImageController)Element).SetIsLoading(false);
+ Element.SetIsLoading(false);
}
}
System.Windows.Controls.ProgressBar _progressBar;
ViewportControl _viewport;
- IListViewController Controller => Element;
- ITemplatedItemsView<Cell> TemplatedItemsView => Element;
+ ITemplatedItemsView<Cell> TemplatedItemsView => base.Element;
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
{
{
base.OnElementChanged(e);
- Controller.ScrollToRequested += OnScrollToRequested;
+ Element.ScrollToRequested += OnScrollToRequested;
- if (Element.SelectedItem != null)
+ if (base.Element.SelectedItem != null)
_itemNeedsSelecting = true;
- _listBox = new FixedLongListSelector
- {
- DataContext = Element,
+ _listBox = new FixedLongListSelector {
+ DataContext = base.Element,
ItemsSource = (IList)TemplatedItemsView.TemplatedItems,
ItemTemplate = (System.Windows.DataTemplate)System.Windows.Application.Current.Resources["CellTemplate"],
GroupHeaderTemplate = (System.Windows.DataTemplate)System.Windows.Application.Current.Resources["ListViewHeader"],
base.OnElementPropertyChanged(sender, e);
if (e.PropertyName == ListView.SelectedItemProperty.PropertyName)
- OnItemSelected(Element.SelectedItem);
+ OnItemSelected(base.Element.SelectedItem);
else if (e.PropertyName == "HeaderElement")
UpdateHeader();
else if (e.PropertyName == "FooterElement")
base.UpdateNativeWidget();
if (_progressBar != null)
- _progressBar.Width = Element.Width;
+ _progressBar.Width = base.Element.Width;
}
Cell FindCell(GestureEventArgs e, out FrameworkElement element)
return;
var cell = e.Container.DataContext as Cell;
- if (cell == null || !Equals(cell.BindingContext, Element.SelectedItem))
+ if (cell == null || !Equals(cell.BindingContext, base.Element.SelectedItem))
return;
_itemNeedsSelecting = false;
- OnItemSelected(Element.SelectedItem);
+ OnItemSelected(base.Element.SelectedItem);
}
void OnItemSelected(object selectedItem)
Cell parentCell = null;
- if (Element.IsGroupingEnabled)
+ if (base.Element.IsGroupingEnabled)
{
parentCell = cell.GetGroupHeaderContent<ItemsView<Cell>, Cell>();
}
_fromNative = cell.BindingContext;
- if (Element.IsGroupingEnabled)
+ if (base.Element.IsGroupingEnabled)
{
- Controller.NotifyRowTapped(parentCell.GetIndex<ItemsView<Cell>, Cell>(), cell.GetIndex<ItemsView<Cell>, Cell>(), null);
+ Element.NotifyRowTapped(parentCell.GetIndex<ItemsView<Cell>, Cell>(), cell.GetIndex<ItemsView<Cell>, Cell>(), null);
}
else
- Controller.NotifyRowTapped(cell.GetIndex<ItemsView<Cell>, Cell>(), null);
+ Element.NotifyRowTapped(cell.GetIndex<ItemsView<Cell>, Cell>(), null);
}
void OnNativeSelectionChanged(object sender, SelectionChangedEventArgs e)
void OnPullToRefreshCanceled(object sender, EventArgs args)
{
- if (Element.IsPullToRefreshEnabled && Controller.RefreshAllowed)
+ if (base.Element.IsPullToRefreshEnabled && Element.RefreshAllowed)
_progressBar.Visibility = Visibility.Collapsed;
}
void OnPullToRefreshCompleted(object sender, EventArgs args)
{
- if (Element.IsPullToRefreshEnabled && Controller.RefreshAllowed)
+ if (base.Element.IsPullToRefreshEnabled && Element.RefreshAllowed)
{
_progressBar.IsIndeterminate = true;
- Controller.SendRefreshing();
+ Element.SendRefreshing();
}
}
void OnPullToRefreshStarted(object sender, EventArgs args)
{
- if (Element.IsPullToRefreshEnabled && Controller.RefreshAllowed)
+ if (base.Element.IsPullToRefreshEnabled && Element.RefreshAllowed)
{
_progressBar.Visibility = Visibility.Visible;
_progressBar.IsIndeterminate = false;
void OnPullToRefreshStatusUpdated(object sender, EventArgs eventArgs)
{
- if (Element.IsPullToRefreshEnabled && Controller.RefreshAllowed)
+ if (base.Element.IsPullToRefreshEnabled && Element.RefreshAllowed)
_progressBar.Value = Math.Max(0, Math.Min(1, _listBox.PullToRefreshStatus));
}
var found = false;
- if (Element.IsGroupingEnabled)
+ if (base.Element.IsGroupingEnabled)
{
for (var g = 0; g < templatedItems.Count; g++)
{
position = ScrollToPosition.Start;
}
- if (position == ScrollToPosition.Start && Element.IsGroupingEnabled)
+ if (position == ScrollToPosition.Start && base.Element.IsGroupingEnabled)
y = y - targetHeaderHeight;
else if (position == ScrollToPosition.Center)
y = y - (_viewport.ActualHeight / 2 + targetHeight / 2);
void UpdateFooter()
{
- Control.ListFooter = Controller.FooterElement;
+ Control.ListFooter = Element.FooterElement;
}
void UpdateHeader()
{
- Control.ListHeader = Controller.HeaderElement;
+ Control.ListHeader = Element.HeaderElement;
}
void UpdateIsRefreshing()
{
- if (Element.IsRefreshing)
+ if (base.Element.IsRefreshing)
{
_progressBar.Visibility = Visibility.Visible;
_progressBar.IsIndeterminate = true;
else
{
_progressBar.IsIndeterminate = false;
- _progressBar.Visibility = _listBox.IsInPullToRefresh && Element.IsPullToRefreshEnabled && Controller.RefreshAllowed ? Visibility.Visible : Visibility.Collapsed;
+ _progressBar.Visibility = _listBox.IsInPullToRefresh && base.Element.IsPullToRefreshEnabled && Element.RefreshAllowed ? Visibility.Visible : Visibility.Collapsed;
}
}
void UpdateJumpList()
{
- if (_listBox.IsGroupingEnabled && Element.GroupShortNameBinding == null)
+ if (_listBox.IsGroupingEnabled && base.Element.GroupShortNameBinding == null)
_listBox.JumpListStyle = null;
else
_listBox.JumpListStyle = (System.Windows.Style)System.Windows.Application.Current.Resources["HeaderJumpStyle"];
AutoPackage = false;
}
- IMasterDetailPageController MasterDetailPageController => Element as IMasterDetailPageController;
-
public bool Visible { get; private set; }
- IPageController PageController => Element as IPageController;
+ IPageController PageController => (base.Element as IPageController);
protected override System.Windows.Size ArrangeOverride(System.Windows.Size finalSize)
{
base.OnElementChanged(e);
if (e.OldElement != null)
- ((IMasterDetailPageController)e.OldElement).BackButtonPressed -= HandleBackButtonPressed;
+ e.OldElement.BackButtonPressed -= HandleBackButtonPressed;
if (e.NewElement != null)
- ((IMasterDetailPageController)e.NewElement).BackButtonPressed += HandleBackButtonPressed;
+ e.NewElement.BackButtonPressed += HandleBackButtonPressed;
LoadDetail();
LoadMaster();
Loaded += (sender, args) =>
{
- if (Element.IsPresented)
+ if (base.Element.IsPresented)
Toggle();
PageController.SendAppearing();
};
PageController.SendDisappearing();
if (Visible)
{
- var platform = (Platform)Element.Platform;
+ var platform = (Platform)base.Element.Platform;
Canvas container = platform.GetCanvas();
container.Children.Remove(_popup);
}
else if (e.PropertyName == MasterDetailPage.IsPresentedProperty.PropertyName)
{
- if (Visible == Element.IsPresented)
+ if (Visible == base.Element.IsPresented)
return;
Toggle();
}
internal void Toggle()
{
- var platform = Element.Platform as Platform;
+ var platform = base.Element.Platform as Platform;
Canvas container = platform.GetCanvas();
if (_toggleTransition != null)
Visible = !Visible;
- ((IElementController)Element).SetValueFromRenderer(MasterDetailPage.IsPresentedProperty, Visible);
+ ((IElementController)base.Element).SetValueFromRenderer(MasterDetailPage.IsPresentedProperty, Visible);
}
void HandleBackButtonPressed(object sender, BackButtonPressedEventArgs e)
if (_detailRenderer != null)
Children.Remove(_detailRenderer.ContainerElement);
- Page detail = Element.Detail;
+ Page detail = base.Element.Detail;
if (Platform.GetRenderer(detail) == null)
Platform.SetRenderer(detail, Platform.CreateRenderer(detail));
if (_masterRenderer != null && _popup != null)
_popup.Child = null;
- Page master = Element.Master;
+ Page master = base.Element.Master;
if (Platform.GetRenderer(master) == null)
Platform.SetRenderer(master, Platform.CreateRenderer(master));
if (width <= 0 || height <= 0)
return;
- var platform = Element.Platform as Platform;
+ var platform = base.Element.Platform as Platform;
Size screenSize = platform.Size;
- MasterDetailPageController.MasterBounds = new Rectangle(0, 0, screenSize.Width - 20, screenSize.Height - 20);
- MasterDetailPageController.DetailBounds = new Rectangle(0, 0, width, height);
+ Element.MasterBounds = new Rectangle(0, 0, screenSize.Width - 20, screenSize.Height - 20);
+ Element.DetailBounds = new Rectangle(0, 0, width, height);
_popup.Width = width - 20;
_popup.Height = height - 20;
{
const int Spacing = 12;
- INavigationMenuController ElementController => Element;
-
protected override void OnElementChanged(ElementChangedEventArgs<NavigationMenu> e)
{
base.OnElementChanged(e);
hubTile.Background = target.BackgroundColor.ToBrush();
Page tmp = target;
- hubTile.Tap += (sender, args) => ElementController.SendTargetSelected(tmp);
+ hubTile.Tap += (sender, args) => Element.SendTargetSelected(tmp);
hubTile.SetValue(System.Windows.Controls.Grid.RowProperty, y);
hubTile.SetValue(System.Windows.Controls.Grid.ColumnProperty, x);
var buttonsToAdd = new List<TaggedAppBarButton>();
foreach (ToolbarItem item in items.Where(i => i.Order != ToolbarItemOrder.Secondary))
{
- IMenuItemController controller = item;
if (_page.ApplicationBar.Buttons.OfType<TaggedAppBarButton>().Any(b => b.Tag == item))
continue;
{
IconUri = new Uri(item.Icon ?? "ApplicationIcon.jpg", UriKind.Relative),
Text = !string.IsNullOrWhiteSpace(item.Text) ? item.Text : (string)item.Icon ?? "ApplicationIcon.jpg",
- IsEnabled = controller.IsEnabled,
+ IsEnabled = item.IsEnabled,
Tag = item
};
- button.Click += (sender, args) => controller.Activate();
+ button.Click += (sender, args) => item.Activate();
buttonsToAdd.Add(button);
}
continue;
var button = new TaggedAppBarMenuItem { Text = !string.IsNullOrWhiteSpace(item.Text) ? item.Text : (string)item.Icon ?? "MenuItem", IsEnabled = true, Tag = item };
- button.Click += (sender, args) => ((IMenuItemController)item).Activate();
+ button.Click += (sender, args) => item.Activate();
menuItemsToAdd.Add(button);
}
if (item == null)
return;
- IMenuItemController controller = item;
-
- if (e.PropertyName == controller.IsEnabledPropertyName)
- IsEnabled = controller.IsEnabled;
+ if (e.PropertyName == item.IsEnabledPropertyName)
+ IsEnabled = item.IsEnabled;
else if (e.PropertyName == MenuItem.TextProperty.PropertyName)
Text = !string.IsNullOrWhiteSpace(item.Text) ? item.Text : (string)item.Icon ?? "ApplicationIcon.jpg";
else if (e.PropertyName == MenuItem.IconProperty.PropertyName)
AutoPackage = false;
}
- protected IScrollViewController Controller
- {
- get { return Element; }
- }
-
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
{
SizeRequest result = base.GetDesiredSize(widthConstraint, heightConstraint);
base.OnElementChanged(e);
if (e.OldElement != null)
- ((IScrollViewController)e.OldElement).ScrollToRequested -= OnScrollToRequested;
+ e.OldElement.ScrollToRequested -= OnScrollToRequested;
if (e.NewElement != null)
{
SetNativeControl(new ScrollViewer { ManipulationMode = ManipulationMode.Control });
Control.LayoutUpdated += (sender, args) => { UpdateScrollPosition(); };
}
- ((IScrollViewController)e.NewElement).ScrollToRequested += OnScrollToRequested;
+ e.NewElement.ScrollToRequested += OnScrollToRequested;
}
SizeChanged += (sender, args) =>
if (e.Mode == ScrollToMode.Element)
{
- Point itemPosition = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
+ Point itemPosition = Element.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = itemPosition.X;
y = itemPosition.Y;
}
animation.Commit(_animatable, "ScrollTo", length: 500, easing: Easing.CubicInOut, finished: (v, d) =>
{
UpdateScrollOffset(x, y);
- Controller.SendScrollFinished();
+ Element.SendScrollFinished();
});
}
else
{
UpdateScrollOffset(x, y);
- Controller.SendScrollFinished();
+ Element.SendScrollFinished();
}
}
void UpdateScrollPosition()
{
if (Element != null)
- Controller.SetScrolledPosition(Control.HorizontalOffset, Control.VerticalOffset);
+ Element.SetScrolledPosition(Control.HorizontalOffset, Control.VerticalOffset);
}
}
}
\ No newline at end of file
void PhoneTextBoxOnKeyUp(object sender, KeyEventArgs keyEventArgs)
{
if (keyEventArgs.Key == Key.Enter)
- ((ISearchBarController)Element).OnSearchButtonPressed();
+ Element.OnSearchButtonPressed();
}
void PhoneTextBoxOnTextChanged(object sender, System.Windows.Controls.TextChangedEventArgs textChangedEventArgs)
{
- ((IElementController)Element).SetValueFromRenderer(SearchBar.TextProperty, Control.Text);
+ Element.SetValueFromRenderer(SearchBar.TextProperty, Control.Text);
}
void UpdateAlignment()
void OnQuerySubmitted (SearchBox sender, SearchBoxQuerySubmittedEventArgs e)
{
- ((ISearchBarController)Element).OnSearchButtonPressed ();
+ Element.OnSearchButtonPressed ();
}
void UpdatePlaceholder ()
if (ActualWidth > 0 && ActualHeight > 0)
{
var tab = ((Page)DataContext);
- ((IPageController)tab.RealParent).ContainerArea = new Rectangle(0, 0, ActualWidth, ActualHeight);
+ ((Page)tab.RealParent).ContainerArea = new Rectangle(0, 0, ActualWidth, ActualHeight);
}
};
}
bool _showTitle;
ITitleProvider TitleProvider => this;
- IPageController PageController => Element as IPageController;
public event EventHandler<VisualElementChangedEventArgs> ElementChanged;
_disposed = true;
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
SetElement(null);
Tracker = null;
}
void OnLoaded(object sender, RoutedEventArgs args)
{
- PageController?.SendAppearing();
+ Element?.SendAppearing();
UpdateBarTextColor();
UpdateBarBackgroundColor();
}
void OnUnloaded(object sender, RoutedEventArgs args)
{
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
void OnTrackerUpdated(object sender, EventArgs e)
void OnQuerySubmitted(SearchBox sender, SearchBoxQuerySubmittedEventArgs e)
{
- ((ISearchBarController)Element).OnSearchButtonPressed();
+ Element.OnSearchButtonPressed();
}
void UpdatePlaceholder()
get { return (TabbedPage)Element; }
}
- IPageController PageController => Element as IPageController;
-
protected VisualElementTracker<Page, Canvas> Tracker
{
get { return _tracker; }
_disposed = true;
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
SetElement(null);
Tracker = null;
}
return;
ShowTabs();
- PageController.SendAppearing();
+ Page.SendAppearing();
}
void tabs_OnLoaded(object sender, RoutedEventArgs e)
void canvas_OnUnloaded(object sender, RoutedEventArgs args)
{
RemoveTabs();
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
}
}
}
\ No newline at end of file
get { return Element; }
}
- IPageController PageController => Element as IPageController;
+ Page Page => Element as Page;
public event EventHandler<VisualElementChangedEventArgs> ElementChanged;
if (oldPage != null)
{
- ((IPageController)oldPage).SendDisappearing();
+ oldPage.SendDisappearing();
((INotifyCollectionChanged)oldPage.Children).CollectionChanged -= OnChildrenChanged;
oldPage.PropertyChanged -= OnElementPropertyChanged;
}
newPage.PropertyChanged += OnElementPropertyChanged;
UpdateCurrentPage();
- ((IPageController)newPage).SendAppearing();
+ newPage.SendAppearing();
}
OnElementChanged(new ElementChangedEventArgs<CarouselPage>(oldPage, newPage));
}
_disposed = true;
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
SetElement(null);
}
void OnLoaded(object sender, RoutedEventArgs e)
{
- PageController?.SendAppearing();
+ Page?.SendAppearing();
}
void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
ContentPage currentPage = Element.CurrentPage;
if (currentPage == page)
return;
- ((IPageController)currentPage)?.SendDisappearing();
+ currentPage?.SendDisappearing();
Element.CurrentPage = page;
- ((IPageController)page)?.SendAppearing();
+ page?.SendAppearing();
}
void OnUnloaded(object sender, RoutedEventArgs e)
{
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
}
void UpdateCurrentPage()
Unloaded += (sender, args) =>
{
- ICellController cell = Cell;
- if (cell != null)
- cell.SendDisappearing();
+ if (Cell != null)
+ Cell.SendDisappearing();
};
_propertyChangedHandler = OnCellPropertyChanged;
}
else
{
- IListViewController listViewController = lv;
-
if (isGroupHeader)
- bindingContext = listViewController.GetDisplayTextFromGroup(bindingContext);
+ bindingContext = lv.GetDisplayTextFromGroup(bindingContext);
- cell = listViewController.CreateDefaultCell(bindingContext);
+ cell = lv.CreateDefaultCell(bindingContext);
}
// A TableView cell should already have its parent,
if (oldCell != null)
{
oldCell.PropertyChanged -= _propertyChangedHandler;
- ((ICellController)oldCell).SendDisappearing();
+ oldCell.SendDisappearing();
}
if (newCell != null)
{
- ((ICellController)newCell).SendAppearing();
+ newCell.SendAppearing();
UpdateContent(newCell);
SetupContextMenu();
RefreshImage();
}
- ((IImageController)Element)?.SetIsLoading(false);
+ Element?.SetIsLoading(false);
}
void OnImageFailed(object sender, ExceptionRoutedEventArgs exceptionRoutedEventArgs)
{
Log.Warning("Image Loading", $"Image failed to load: {exceptionRoutedEventArgs.ErrorMessage}" );
- ((IImageController)Element)?.SetIsLoading(false);
+ Element?.SetIsLoading(false);
}
void RefreshImage()
async Task UpdateSource()
{
- ((IImageController)Element).SetIsLoading(true);
+ Element.SetIsLoading(true);
ImageSource source = Element.Source;
IImageSourceHandler handler;
else
{
Control.Source = null;
- ((IImageController)Element)?.SetIsLoading(false);
+ Element?.SetIsLoading(false);
}
}
}
{
public class ListViewRenderer : ViewRenderer<ListView, FrameworkElement>
{
- IListViewController Controller => Element;
ITemplatedItemsView<Cell> TemplatedItemsView => Element;
if (e.OldElement != null)
{
e.OldElement.ItemSelected -= OnElementItemSelected;
- ((IListViewController)e.OldElement).ScrollToRequested -= OnElementScrollToRequested;
+ e.OldElement.ScrollToRequested -= OnElementScrollToRequested;
}
if (e.NewElement != null)
{
e.NewElement.ItemSelected += OnElementItemSelected;
- ((IListViewController)e.NewElement).ScrollToRequested += OnElementScrollToRequested;
+ e.NewElement.ScrollToRequested += OnElementScrollToRequested;
if (List == null)
{
void UpdateFooter()
{
- List.Footer = Controller.FooterElement;
+ List.Footer = Element.FooterElement;
}
void UpdateHeader()
{
- List.Header = Controller.HeaderElement;
+ List.Header = Element.HeaderElement;
}
void UpdateGrouping()
}
#endif
- Controller.NotifyRowTapped(index, cell: null);
+ Element.NotifyRowTapped(index, cell: null);
#if !WINDOWS_UWP
set { _container.ToolbarForeground = value; }
}
- IMasterDetailPageController MasterDetailPageController => Element as IMasterDetailPageController;
-
bool ITitleProvider.ShowTitle
{
get { return _showTitle; }
bool GetIsMasterAPopover()
{
// TODO: Support tablet being shrunk to a very small size
- return !MasterDetailPageController.ShouldShowSplitMode;
+ return !Element.ShouldShowSplitMode;
}
void OnLoaded(object sender, RoutedEventArgs args)
if (!isPopover)
detailWidth -= masterWidth;
- MasterDetailPageController.MasterBounds = new Rectangle(0, 0, masterWidth, constraint.Height);
- MasterDetailPageController.DetailBounds = new Rectangle(0, 0, detailWidth, constraint.Height);
+ Element.MasterBounds = new Rectangle(0, 0, masterWidth, constraint.Height);
+ Element.DetailBounds = new Rectangle(0, 0, detailWidth, constraint.Height);
}
void UpdateIsPresented()
internal class MenuItemCommand : ICommand
{
readonly MenuItem _menuItem;
- IMenuItemController Controller => _menuItem;
public MenuItemCommand(MenuItem item)
{
public virtual bool CanExecute(object parameter)
{
- return Controller.IsEnabled;
+ return _menuItem.IsEnabled;
}
public event EventHandler CanExecuteChanged;
public void Execute(object parameter)
{
- Controller.Activate();
+ _menuItem.Activate();
}
void OnCanExecuteChanged()
}
}
- IPageController PageController => Element as IPageController;
-
bool ITitleProvider.ShowTitle
{
get { return _showTitle; }
if (oldElement != null)
{
- ((INavigationPageController)oldElement).PushRequested -= OnPushRequested;
- ((INavigationPageController)oldElement).PopRequested -= OnPopRequested;
- ((INavigationPageController)oldElement).PopToRootRequested -= OnPopToRootRequested;
- ((IPageController)oldElement).InternalChildren.CollectionChanged -= OnChildrenChanged;
+ oldElement.PushRequested -= OnPushRequested;
+ oldElement.PopRequested -= OnPopRequested;
+ oldElement.PopToRootRequested -= OnPopToRootRequested;
+ oldElement.InternalChildren.CollectionChanged -= OnChildrenChanged;
oldElement.PropertyChanged -= OnElementPropertyChanged;
}
#endif
Element.PropertyChanged += OnElementPropertyChanged;
- ((INavigationPageController)Element).PushRequested += OnPushRequested;
- ((INavigationPageController)Element).PopRequested += OnPopRequested;
- ((INavigationPageController)Element).PopToRootRequested += OnPopToRootRequested;
- PageController.InternalChildren.CollectionChanged += OnChildrenChanged;
+ Element.PushRequested += OnPushRequested;
+ Element.PopRequested += OnPopRequested;
+ Element.PopToRootRequested += OnPopToRootRequested;
+ Element.InternalChildren.CollectionChanged += OnChildrenChanged;
if (!string.IsNullOrEmpty(Element.AutomationId))
_container.SetValue(AutomationProperties.AutomationIdProperty, Element.AutomationId);
return;
}
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
_disposed = true;
_container.PointerPressed -= OnPointerPressed;
#if WINDOWS_UWP
_navManager = SystemNavigationManager.GetForCurrentView();
#endif
- PageController.SendAppearing();
+ Element.SendAppearing();
UpdateBackButton();
UpdateTitleOnParents();
}
void OnPopRequested(object sender, NavigationRequestedEventArgs e)
{
- var newCurrent = ((INavigationPageController)Element).Peek(1);
+ var newCurrent = Element.Peek(1);
SetPage(newCurrent, e.Animated, true);
}
void OnUnloaded(object sender, RoutedEventArgs args)
{
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
void PushExistingNavigationStack()
{
- foreach (var page in ((INavigationPageController)Element).Pages)
+ foreach (var page in Element.Pages)
{
SetPage(page, false, false);
}
void UpdateContainerArea()
{
- PageController.ContainerArea = new Rectangle(0, 0, _container.ContentWidth, _container.ContentHeight);
+ Element.ContainerArea = new Rectangle(0, 0, _container.ContentWidth, _container.ContentHeight);
}
void UpdateNavigationBarBackground()
void UpdateBackButton()
{
- bool showBackButton = PageController.InternalChildren.Count > 1 && NavigationPage.GetHasBackButton(_currentPage);
+ bool showBackButton = Element.InternalChildren.Count > 1 && NavigationPage.GetHasBackButton(_currentPage);
_container.ShowBackButton = showBackButton;
}
bool _loaded;
- IPageController PageController => Element as IPageController;
-
protected override void Dispose(bool disposing)
{
if (!disposing || _disposed)
var visualChild = children[i] as VisualElement;
visualChild?.Cleanup();
}
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
base.Dispose();
{
base.OnElementChanged(e);
- ((IPageController)e.OldElement)?.SendDisappearing();
+ e.OldElement?.SendDisappearing();
if (e.NewElement != null)
{
}
if (_loaded)
- ((IPageController)e.NewElement).SendAppearing();
+ e.NewElement.SendAppearing();
}
}
return;
}
_loaded = true;
- PageController?.SendAppearing();
+ Element?.SendAppearing();
}
void OnUnloaded(object sender, RoutedEventArgs args)
{
_loaded = false;
- PageController?.SendDisappearing();
+ Element?.SendDisappearing();
}
}
}
\ No newline at end of file
AutoPackage = false;
}
- protected IScrollViewController Controller
- {
- get { return Element; }
- }
-
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
{
SizeRequest result = base.GetDesiredSize(widthConstraint, heightConstraint);
if (e.OldElement != null)
{
- ((IScrollViewController)e.OldElement).ScrollToRequested -= OnScrollToRequested;
+ e.OldElement.ScrollToRequested -= OnScrollToRequested;
}
if (e.NewElement != null)
Control.ViewChanged += OnViewChanged;
}
- Controller.ScrollToRequested += OnScrollToRequested;
+ Element.ScrollToRequested += OnScrollToRequested;
UpdateOrientation();
ScrollToMode mode = e.Mode;
if (mode == ScrollToMode.Element)
{
- Point pos = Controller.GetScrollPositionForElement((VisualElement)e.Element, e.Position);
+ Point pos = Element.GetScrollPositionForElement((VisualElement)e.Element, e.Position);
x = pos.X;
y = pos.Y;
mode = ScrollToMode.Position;
{
Control.ChangeView(x, y, null, !e.ShouldAnimate);
}
- Controller.SendScrollFinished();
+ Element.SendScrollFinished();
}
void OnViewChanged(object sender, ScrollViewerViewChangedEventArgs e)
{
- Controller.SetScrolledPosition(Control.HorizontalOffset, Control.VerticalOffset);
+ Element.SetScrolledPosition(Control.HorizontalOffset, Control.VerticalOffset);
if (!e.IsIntermediate)
- Controller.SendScrollFinished();
+ Element.SendScrollFinished();
}
void UpdateMargins()
public class TableViewRenderer : ViewRenderer<TableView, Windows.UI.Xaml.Controls.ListView>
{
bool _ignoreSelectionEvent;
- ITableViewController Controller => Element;
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
{
{
if (e.OldElement != null)
{
- ((ITableViewController)e.OldElement).ModelChanged -= OnModelChanged;
+ e.OldElement.ModelChanged -= OnModelChanged;
}
if (e.NewElement != null)
Control.SelectionChanged += OnSelectionChanged;
}
- ((ITableViewController)e.NewElement).ModelChanged += OnModelChanged;
+ e.NewElement.ModelChanged += OnModelChanged;
OnModelChanged(e.NewElement, EventArgs.Empty);
}
if (cell != null)
{
if (cell.IsEnabled)
- Controller.Model.RowSelected(cell);
+ Element.Model.RowSelected(cell);
break;
}
}
{
if (!_wasPanGestureStartedSent)
{
- ((IPanGestureController)recognizer).SendPanStarted(view, Application.Current.PanGestureId);
+ recognizer.SendPanStarted(view, Application.Current.PanGestureId);
}
- ((IPanGestureController)recognizer).SendPan(view, e.Delta.Translation.X + e.Cumulative.Translation.X, e.Delta.Translation.Y + e.Cumulative.Translation.Y, Application.Current.PanGestureId);
+ recognizer.SendPan(view, e.Delta.Translation.X + e.Cumulative.Translation.X, e.Delta.Translation.Y + e.Cumulative.Translation.Y, Application.Current.PanGestureId);
}
_wasPanGestureStartedSent = true;
}
{
if (!_wasPinchGestureStartedSent)
{
- ((IPinchGestureController)recognizer).SendPinchStarted(view, scaleOriginPoint);
+ recognizer.SendPinchStarted(view, scaleOriginPoint);
}
- ((IPinchGestureController)recognizer).SendPinch(view, e.Delta.Scale, scaleOriginPoint);
+ recognizer.SendPinch(view, e.Delta.Scale, scaleOriginPoint);
}
_wasPinchGestureStartedSent = true;
}
{
if (success)
{
- ((IPanGestureController)recognizer).SendPanCompleted(view, Application.Current.PanGestureId);
+ recognizer.SendPanCompleted(view, Application.Current.PanGestureId);
}
else
{
- ((IPanGestureController)recognizer).SendPanCanceled(view, Application.Current.PanGestureId);
+ recognizer.SendPanCanceled(view, Application.Current.PanGestureId);
}
}
{
if (success)
{
- ((IPinchGestureController)recognizer).SendPinchEnded(view);
+ recognizer.SendPinchEnded(view);
}
else
{
- ((IPinchGestureController)recognizer).SendPinchCanceled(view);
+ recognizer.SendPinchCanceled(view);
}
}
if(bases.length == 0){
head.innerHTML = 'baseTag' + head.innerHTML;
}";
- IWebViewController ElementController => Element;
-
public void LoadHtml(string html, string baseUrl)
{
if (IsNullOrEmpty(baseUrl))
if (e.OldElement != null)
{
- var oldElementController = e.OldElement as IWebViewController;
- oldElementController.EvalRequested -= OnEvalRequested;
- oldElementController.GoBackRequested -= OnGoBackRequested;
- oldElementController.GoForwardRequested -= OnGoForwardRequested;
+ var oldElement = e.OldElement;
+ oldElement.EvalRequested -= OnEvalRequested;
+ oldElement.GoBackRequested -= OnGoBackRequested;
+ oldElement.GoForwardRequested -= OnGoForwardRequested;
}
if (e.NewElement != null)
SetNativeControl(webView);
}
- var newElementController = e.NewElement as IWebViewController;
- newElementController.EvalRequested += OnEvalRequested;
- newElementController.GoForwardRequested += OnGoForwardRequested;
- newElementController.GoBackRequested += OnGoBackRequested;
+ var newElement = e.NewElement;
+ newElement.EvalRequested += OnEvalRequested;
+ newElement.GoForwardRequested += OnGoForwardRequested;
+ newElement.GoBackRequested += OnGoBackRequested;
Load();
}
{
var args = new WebNavigatingEventArgs(_eventState, new UrlWebViewSource { Url = uri.AbsoluteUri }, uri.AbsoluteUri);
- ElementController.SendNavigating(args);
+ Element.SendNavigating(args);
e.Cancel = args.Cancel;
// reset in this case because this is the last event we will get
((IElementController)Element).SetValueFromRenderer(WebView.SourceProperty, source);
_updating = false;
- ElementController.SendNavigated(new WebNavigatedEventArgs(evnt, source, source.Url, result));
+ Element.SendNavigated(new WebNavigatedEventArgs(evnt, source, source.Url, result));
UpdateCanGoBackForward();
_eventState = WebNavigationEvent.NewPage;
void UpdateCanGoBackForward()
{
- ElementController.CanGoBack = Control.CanGoBack;
- ElementController.CanGoForward = Control.CanGoForward;
+ ((IWebViewController)Element).CanGoBack = Control.CanGoBack;
+ ((IWebViewController)Element).CanGoForward = Control.CanGoForward;
}
}
}
\ No newline at end of file
get { return _cell; }
set
{
- if (_cell == value)
+ if (this._cell == value)
return;
- ICellController cellController = _cell;
-
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendDisappearing);
+ if (_cell != null)
+ Device.BeginInvokeOnMainThread(_cell.SendDisappearing);
+ this._cell = value;
_cell = value;
- cellController = value;
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendAppearing);
+ if (_cell != null)
+ Device.BeginInvokeOnMainThread(_cell.SendAppearing);
}
}
void UpdateCell(ViewCell cell)
{
- ICellController cellController = _viewCell;
- if (cellController != null)
- Device.BeginInvokeOnMainThread(cellController.SendDisappearing);
+ if (_viewCell != null)
+ Device.BeginInvokeOnMainThread(_viewCell.SendDisappearing);
+ this._viewCell = cell;
_viewCell = cell;
- cellController = cell;
- Device.BeginInvokeOnMainThread(cellController.SendAppearing);
+ Device.BeginInvokeOnMainThread(_viewCell.SendAppearing);
IVisualElementRenderer renderer;
if (_rendererRef == null || !_rendererRef.TryGetTarget(out renderer))
if (renderer.Element != null && renderer == Platform.GetRenderer(renderer.Element))
renderer.Element.ClearValue(Platform.RendererProperty);
- var type = Internals.Registrar.Registered.GetHandlerType(_viewCell.View.GetType());
+ var type = Internals.Registrar.Registered.GetHandlerType(this._viewCell.View.GetType());
if (renderer.GetType() == type || (renderer is Platform.DefaultRenderer && type == null))
- renderer.SetElement(_viewCell.View);
+ renderer.SetElement(this._viewCell.View);
else
{
//when cells are getting reused the element could be already set to another cell
}
}
- Platform.SetRenderer(_viewCell.View, renderer);
+ Platform.SetRenderer(this._viewCell.View, renderer);
}
}
}
public void Update(UITableView tableView, Cell cell, UITableViewCell nativeCell)
{
- var parentListView = cell.RealParent as IListViewController;
+ var parentListView = cell.RealParent as ListView;
var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement;
if (_cell != cell && recycling)
{
_scroller.SetContentOffset(new PointF(0, 0), true);
MenuItem mi;
if (weakItem.TryGetTarget(out mi))
- ((IMenuItemController)mi).Activate();
+ mi.Activate();
});
actionSheet.AddAction(action);
}
button.SetTitle(item.Text, UIControlState.Normal);
button.TitleEdgeInsets = new UIEdgeInsets(0, 15, 0, 15);
- button.Enabled = ((IMenuItemController)item).IsEnabled;
+ button.Enabled = item.IsEnabled;
return button;
}
else
{
_scroller.SetContentOffset(new PointF(0, 0), true);
- ((IMenuItemController)_cell.ContextActions[(int)button.Tag]).Activate();
+ _cell.ContextActions[(int)button.Tag].Activate();
}
}
{
if (e.PropertyName == "HasContextActions")
{
- var parentListView = _cell.RealParent as IListViewController;
+ var parentListView = _cell.RealParent as ListView;
var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement;
if (!recycling)
ReloadRow();
void OnContextItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
- var parentListView = _cell.RealParent as IListViewController;
+ var parentListView = _cell.RealParent as ListView;
var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement;
if (recycling)
Update(_tableView, _cell, ContentCell);
void OnMenuItemPropertyChanged(object sender, PropertyChangedEventArgs e)
{
- var parentListView = _cell.RealParent as IListViewController;
+ var parentListView = _cell.RealParent as ListView;
var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement;
if (recycling)
Update(_tableView, _cell, ContentCell);
// do not activate a -1 index when dismissing by clicking outside the popover
if (buttonIndex >= 0)
- ((IMenuItemController)Items[(int)buttonIndex]).Activate();
+ Items[(int)buttonIndex].Activate();
}
}
}
double startingScale = 1;
var uiRecognizer = CreatePinchRecognizer(r =>
{
- var pinchGestureRecognizer = weakRecognizer.Target as IPinchGestureController;
+ var pinchGestureRecognizer = weakRecognizer.Target as PinchGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
- var panGestureRecognizer = weakRecognizer.Target as IPanGestureController;
+ var panGestureRecognizer = weakRecognizer.Target as PanGestureRecognizer;
if (panGestureRecognizer != null && view != null)
{
switch (r.State)
readonly bool _forceName;
readonly ToolbarItem _item;
- IMenuItemController Controller => _item;
-
public PrimaryToolbarItem(ToolbarItem item, bool forceName)
{
_forceName = forceName;
UpdateTextAndStyle();
UpdateIsEnabled();
- Clicked += (sender, e) => Controller.Activate();
+ Clicked += (sender, e) => _item.Activate();
item.PropertyChanged += OnPropertyChanged;
if (item != null && !string.IsNullOrEmpty(item.AutomationId))
void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
- if (e.PropertyName == Controller.IsEnabledPropertyName)
+ if (e.PropertyName == _item.IsEnabledPropertyName)
UpdateIsEnabled();
else if (e.PropertyName == MenuItem.TextProperty.PropertyName)
{
void UpdateIsEnabled()
{
- Enabled = Controller.IsEnabled;
+ Enabled = _item.IsEnabled;
}
void UpdateTextAndStyle()
sealed class SecondaryToolbarItem : UIBarButtonItem
{
readonly ToolbarItem _item;
- IMenuItemController Controller => _item;
public SecondaryToolbarItem(ToolbarItem item) : base(new SecondaryToolbarItemContent())
{
UpdateIcon();
UpdateIsEnabled();
- ((SecondaryToolbarItemContent)CustomView).TouchUpInside += (sender, e) => Controller.Activate();
+ ((SecondaryToolbarItemContent)CustomView).TouchUpInside += (sender, e) => _item.Activate();
item.PropertyChanged += OnPropertyChanged;
if (item != null && !string.IsNullOrEmpty(item.AutomationId))
UpdateText();
else if (e.PropertyName == MenuItem.IconProperty.PropertyName)
UpdateIcon();
- else if (e.PropertyName == Controller.IsEnabledPropertyName)
+ else if (e.PropertyName == _item.IsEnabledPropertyName)
UpdateIsEnabled();
}
void UpdateIsEnabled()
{
- ((UIControl)CustomView).Enabled = Controller.IsEnabled;
+ ((UIControl)CustomView).Enabled = _item.IsEnabled;
}
void UpdateText()
IImageSourceHandler handler;
- ((IImageController)Element).SetIsLoading(true);
+ Element.SetIsLoading(true);
if (source != null && (handler = Internals.Registrar.Registered.GetHandler<IImageSourceHandler>(source.GetType())) != null)
{
Control.Image = null;
if (!_isDisposed)
- ((IImageController)Element).SetIsLoading(false);
+ Element.SetIsLoading(false);
}
void SetOpacity()
bool _shouldEstimateRowHeight = true;
FormsUITableViewController _tableViewController;
- IListViewController Controller => Element;
+ ListView ListView => Element;
ITemplatedItemsView<Cell> TemplatedItemsView => Element;
public override UIViewController ViewController => _tableViewController;
bool _disposed;
_footerRenderer = null;
}
- var headerView = Controller?.HeaderElement as VisualElement;
+ var headerView = ListView?.HeaderElement as VisualElement;
if (headerView != null)
headerView.MeasureInvalidated -= OnHeaderMeasureInvalidated;
Control?.TableHeaderView?.Dispose();
- var footerView = Controller?.FooterElement as VisualElement;
+ var footerView = ListView?.FooterElement as VisualElement;
if (footerView != null)
footerView.MeasureInvalidated -= OnFooterMeasureInvalidated;
Control?.TableFooterView?.Dispose();
if (e.OldElement != null)
{
- var controller = (IListViewController)e.OldElement;
- var headerView = (VisualElement)controller.HeaderElement;
+ var listView = e.OldElement;
+ var headerView = (VisualElement)listView.HeaderElement;
if (headerView != null)
headerView.MeasureInvalidated -= OnHeaderMeasureInvalidated;
- var footerView = (VisualElement)controller.FooterElement;
+ var footerView = (VisualElement)listView.FooterElement;
if (footerView != null)
footerView.MeasureInvalidated -= OnFooterMeasureInvalidated;
- controller.ScrollToRequested -= OnScrollToRequested;
+ listView.ScrollToRequested -= OnScrollToRequested;
var templatedItems = ((ITemplatedItemsView<Cell>)e.OldElement).TemplatedItems;
templatedItems.CollectionChanged -= OnCollectionChanged;
}
_shouldEstimateRowHeight = true;
- var controller = (IListViewController)e.NewElement;
+ var listView = e.NewElement;
- controller.ScrollToRequested += OnScrollToRequested;
+ listView.ScrollToRequested += OnScrollToRequested;
var templatedItems = ((ITemplatedItemsView<Cell>)e.NewElement).TemplatedItems;
templatedItems.CollectionChanged += OnCollectionChanged;
protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(sender, e);
- if (e.PropertyName == ListView.RowHeightProperty.PropertyName)
+ if (e.PropertyName == Xamarin.Forms.ListView.RowHeightProperty.PropertyName)
UpdateRowHeight();
- else if (e.PropertyName == ListView.IsGroupingEnabledProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.IsGroupingEnabledProperty.PropertyName)
_dataSource.UpdateGrouping();
- else if (e.PropertyName == ListView.HasUnevenRowsProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.HasUnevenRowsProperty.PropertyName)
{
_estimatedRowHeight = false;
Control.Source = _dataSource = Element.HasUnevenRows ? new UnevenListViewDataSource(_dataSource) : new ListViewDataSource(_dataSource);
}
- else if (e.PropertyName == ListView.IsPullToRefreshEnabledProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.IsPullToRefreshEnabledProperty.PropertyName)
UpdatePullToRefreshEnabled();
- else if (e.PropertyName == ListView.IsRefreshingProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.IsRefreshingProperty.PropertyName)
UpdateIsRefreshing();
- else if (e.PropertyName == ListView.SeparatorColorProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.SeparatorColorProperty.PropertyName)
UpdateSeparatorColor();
- else if (e.PropertyName == ListView.SeparatorVisibilityProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.ListView.SeparatorVisibilityProperty.PropertyName)
UpdateSeparatorVisibility();
else if (e.PropertyName == "HeaderElement")
UpdateHeader();
void UpdateFooter()
{
- var footer = Controller.FooterElement;
+ var footer = ListView.FooterElement;
var footerView = (View)footer;
if (footerView != null)
void UpdateHeader()
{
- var header = Controller.HeaderElement;
+ var header = ListView.HeaderElement;
var headerView = (View)header;
if (headerView != null)
{
if (_tableViewController != null)
{
- var isPullToRequestEnabled = Element.IsPullToRefreshEnabled && Controller.RefreshAllowed;
+ var isPullToRequestEnabled = Element.IsPullToRefreshEnabled && ListView.RefreshAllowed;
_tableViewController.UpdatePullToRefreshEnabled(isPullToRequestEnabled);
}
}
UITableView _uiTableView;
FormsUITableViewController _uiTableViewController;
protected ListView List;
- IListViewController Controller => List;
protected ITemplatedItemsView<Cell> TemplatedItemsView => List;
bool _isDragging;
bool _selectionFromNative;
Cell cell;
UITableViewCell nativeCell;
- var cachingStrategy = Controller.CachingStrategy;
+ var cachingStrategy = List.CachingStrategy;
if (cachingStrategy == ListViewCachingStrategy.RetainElement)
{
cell = GetCellForPath(indexPath);
else
{
var templatedList = TemplatedItemsView.TemplatedItems.GetGroup(indexPath.Section);
+
cell = (Cell)((INativeElementView)nativeCell).Element;
- ICellController controller = cell;
- controller.SendDisappearing();
+ cell.SendDisappearing();
+
templatedList.UpdateContent(cell, indexPath.Row);
- controller.SendAppearing();
+ cell.SendAppearing();
}
}
else
return;
Cell formsCell = null;
- if (Controller.CachingStrategy == ListViewCachingStrategy.RecycleElement)
+ if (List.CachingStrategy == ListViewCachingStrategy.RecycleElement)
formsCell = (Cell)((INativeElementView)cell).Element;
SetCellBackgroundColor(cell, UIColor.Clear);
_selectionFromNative = true;
tableView.EndEditing(true);
- Controller.NotifyRowTapped(indexPath.Section, indexPath.Row, formsCell);
+ List.NotifyRowTapped(indexPath.Section, indexPath.Row, formsCell);
}
public override nint RowsInSection(UITableView tableview, nint section)
internal class FormsUITableViewController : UITableViewController
{
ListView _list;
- IListViewController Controller => _list;
UIRefreshControl _refresh;
bool _refreshAdded;
void OnRefreshingChanged(object sender, EventArgs eventArgs)
{
if (_refresh.Refreshing)
- Controller.SendRefreshing();
+ _list.SendRefreshing();
}
void RemoveRefresh()
_menu = menu;
}
- INavigationMenuController MenuController => _menu;
-
public override UICollectionViewCell GetCell(UICollectionView collectionView, NSIndexPath indexPath)
{
var cell = (NavigationCell)collectionView.DequeueReusableCell(new NSString("NavigationCell"), indexPath);
{
cell.Name = target.Title;
cell.Icon = target.Icon?.File;
- cell.Selected = () => MenuController.SendTargetSelected(target);
+ cell.Selected = () => _menu.SendTargetSelected(target);
}
else
{
"NavigationPage must have a root Page before being used. Either call PushAsync with a valid Page, or pass a Page to the constructor before usage.");
}
- var navController = ((INavigationPageController)navPage);
-
- navController.PushRequested += OnPushRequested;
- navController.PopRequested += OnPopRequested;
- navController.PopToRootRequested += OnPopToRootRequested;
- navController.RemovePageRequested += OnRemovedPageRequested;
- navController.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
+ navPage.PushRequested += OnPushRequested;
+ navPage.PopRequested += OnPopRequested;
+ navPage.PopToRootRequested += OnPopToRootRequested;
+ navPage.RemovePageRequested += OnRemovedPageRequested;
+ navPage.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
UpdateTint();
UpdateBarBackgroundColor();
UpdateBarTextColor();
// If there is already stuff on the stack we need to push it
- ((INavigationPageController)navPage).Pages.ForEach(async p => await PushPageAsync(p, false));
+ navPage.Pages.ForEach(async p => await PushPageAsync(p, false));
_tracker = new VisualElementTracker(this);
var navPage = (NavigationPage)Element;
navPage.PropertyChanged -= HandlePropertyChanged;
- var navController = ((INavigationPageController)navPage);
- navController.PushRequested -= OnPushRequested;
- navController.PopRequested -= OnPopRequested;
- navController.PopToRootRequested -= OnPopToRootRequested;
- navController.RemovePageRequested -= OnRemovedPageRequested;
- navController.InsertPageBeforeRequested -= OnInsertPageBeforeRequested;
+ navPage.PushRequested -= OnPushRequested;
+ navPage.PopRequested -= OnPopRequested;
+ navPage.PopToRootRequested -= OnPopToRootRequested;
+ navPage.RemovePageRequested -= OnRemovedPageRequested;
+ navPage.InsertPageBeforeRequested -= OnInsertPageBeforeRequested;
}
base.Dispose(disposing);
for (var i = 0; i < removed; i++)
{
// lets just pop these suckers off, do not await, the true is there to make this fast
- await ((INavigationPageController)Element).PopAsyncInner(animated, true);
+ await ((NavigationPage)Element).PopAsyncInner(animated, true);
}
// because we skip the normal pop process we need to dispose ourselves
controller.Dispose();
if (containerController == null)
return;
var currentChild = containerController.Child;
- var firstPage = ((INavigationPageController)Element).Pages.FirstOrDefault();
+ var firstPage = ((NavigationPage)Element).Pages.FirstOrDefault();
if ((firstPage != pageBeingRemoved && currentChild != firstPage && NavigationPage.GetHasBackButton(currentChild)) || _parentMasterDetailPage == null)
return;
{
if (disposing)
{
- ((IPageController)Child).SendDisappearing();
+ Child.SendDisappearing();
if (Child != null)
{
_displayLink = null;
if (Element != null)
- ((IOpenGlViewController)Element).DisplayRequested -= Display;
+ Element.DisplayRequested -= Display;
}
base.Dispose(disposing);
protected override void OnElementChanged(ElementChangedEventArgs<OpenGLView> e)
{
if (e.OldElement != null)
- ((IOpenGlViewController)e.OldElement).DisplayRequested -= Display;
+ e.OldElement.DisplayRequested -= Display;
if (e.NewElement != null)
{
var glkView = new GLKView(RectangleF.Empty) { Context = context, DrawableDepthFormat = GLKViewDrawableDepthFormat.Format24, Delegate = new Delegate(e.NewElement) };
SetNativeControl(glkView);
- ((IOpenGlViewController)e.NewElement).DisplayRequested += Display;
+ e.NewElement.DisplayRequested += Display;
SetupRenderLoop(false);
}
VisualElementPackager _packager;
VisualElementTracker _tracker;
- IPageController PageController => Element as IPageController;
+ Page Page => Element as Page;
public PageRenderer()
{
return;
_appeared = true;
- PageController.SendAppearing();
+ Page.SendAppearing();
UpdateStatusBarPrefersHidden();
}
return;
_appeared = false;
- PageController.SendDisappearing();
+ Page.SendDisappearing();
}
public override void ViewDidLoad()
Element.PropertyChanged -= OnHandlePropertyChanged;
Platform.SetRenderer(Element, null);
if (_appeared)
- PageController.SendDisappearing();
+ Page.SendDisappearing();
_appeared = false;
VisualElementTracker _tracker;
- IPageController PageController => Element as IPageController;
+ Page Page => Element as Page;
public PhoneMasterDetailRenderer()
{
}
- IMasterDetailPageController MasterDetailPageController => Element as IMasterDetailPageController;
+ MasterDetailPage MasterDetailPage => Element as MasterDetailPage;
bool Presented
{
else
RemoveClickOffView();
- ((IElementController)Element).SetValueFromRenderer(MasterDetailPage.IsPresentedProperty, value);
+ ((IElementController)Element).SetValueFromRenderer(Xamarin.Forms.MasterDetailPage.IsPresentedProperty, value);
}
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
- PageController.SendAppearing();
+ Page.SendAppearing();
}
public override void ViewDidDisappear(bool animated)
{
base.ViewDidDisappear(animated);
- PageController?.SendDisappearing();
+ Page?.SendDisappearing();
}
public override void ViewDidLayoutSubviews()
public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration)
{
- if (!MasterDetailPageController.ShouldShowSplitMode && _presented)
+ if (!MasterDetailPage.ShouldShowSplitMode && _presented)
Presented = false;
base.WillRotate(toInterfaceOrientation, duration);
EmptyContainers();
- PageController.SendDisappearing();
+ Page.SendDisappearing();
_disposed = true;
}
{
if (e.PropertyName == "Master" || e.PropertyName == "Detail")
UpdateMasterDetailContainers();
- else if (e.PropertyName == MasterDetailPage.IsPresentedProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.MasterDetailPage.IsPresentedProperty.PropertyName)
Presented = ((MasterDetailPage)Element).IsPresented;
- else if (e.PropertyName == MasterDetailPage.IsGestureEnabledProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.MasterDetailPage.IsGestureEnabledProperty.PropertyName)
UpdatePanGesture();
else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
UpdateBackground();
else
_detailController.View.Frame = target;
- MasterDetailPageController.MasterBounds = new Rectangle(0, 0, masterFrame.Width, masterFrame.Height);
- MasterDetailPageController.DetailBounds = new Rectangle(0, 0, frame.Width, frame.Height);
+ MasterDetailPage.MasterBounds = new Rectangle(0, 0, masterFrame.Width, masterFrame.Height);
+ MasterDetailPage.DetailBounds = new Rectangle(0, 0, frame.Width, frame.Height);
if (Presented)
_clickOffView.Frame = _detailController.View.Frame;
Scrolled += HandleScrolled;
}
- protected IScrollViewController Controller
- {
- get { return (IScrollViewController)Element; }
- }
-
ScrollView ScrollView
{
get { return Element as ScrollView; }
if (oldElement != null)
{
oldElement.PropertyChanged -= HandlePropertyChanged;
- ((IScrollViewController)oldElement).ScrollToRequested -= OnScrollToRequested;
+ ((ScrollView)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
element.PropertyChanged += HandlePropertyChanged;
- ((IScrollViewController)element).ScrollToRequested += OnScrollToRequested;
+ ((ScrollView)element).ScrollToRequested += OnScrollToRequested;
if (_packager == null)
{
_packager = new VisualElementPackager(this);
void HandleScrollAnimationEnded(object sender, EventArgs e)
{
- Controller.SendScrollFinished();
+ ScrollView.SendScrollFinished();
}
void HandleScrolled(object sender, EventArgs e)
SetContentOffset(new PointF((nfloat)e.ScrollX, (nfloat)e.ScrollY), e.ShouldAnimate);
else
{
- var positionOnScroll = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
+ var positionOnScroll = ScrollView.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
positionOnScroll.X = positionOnScroll.X.Clamp(0, ContentSize.Width - Bounds.Size.Width);
positionOnScroll.Y = positionOnScroll.Y.Clamp(0, ContentSize.Height - Bounds.Size.Height);
}
}
if (!e.ShouldAnimate)
- Controller.SendScrollFinished();
+ ScrollView.SendScrollFinished();
}
void UpdateDelaysContentTouches()
void UpdateScrollPosition()
{
if (ScrollView != null)
- Controller.SetScrolledPosition(ContentOffset.X, ContentOffset.Y);
+ ScrollView.SetScrolledPosition(ContentOffset.X, ContentOffset.Y);
}
void IEffectControlProvider.RegisterEffect(Effect effect)
void OnSearchButtonClicked(object sender, EventArgs e)
{
- ((ISearchBarController)Element).OnSearchButtonPressed();
+ Element.OnSearchButtonPressed();
Control.ResignFirstResponder();
}
bool _loaded;
Size _queuedSize;
- IPageController PageController => Element as IPageController;
- IElementController ElementController => Element as IElementController;
+ Page Page => Element as Page;
public override UIViewController SelectedViewController
{
public override void ViewDidAppear(bool animated)
{
- PageController.SendAppearing();
+ Page.SendAppearing();
base.ViewDidAppear(animated);
}
public override void ViewDidDisappear(bool animated)
{
base.ViewDidDisappear(animated);
- PageController.SendDisappearing();
+ Page.SendDisappearing();
}
public override void ViewDidLayoutSubviews()
var frame = View.Frame;
var tabBarFrame = TabBar.Frame;
- PageController.ContainerArea = new Rectangle(0, 0, frame.Width, frame.Height - tabBarFrame.Height);
+ Page.ContainerArea = new Rectangle(0, 0, frame.Width, frame.Height - tabBarFrame.Height);
if (!_queuedSize.IsZero)
{
{
if (disposing)
{
- PageController.SendDisappearing();
+ Page.SendDisappearing();
Tabbed.PropertyChanged -= OnPropertyChanged;
Tabbed.PagesChanged -= OnPagesChanged;
FinishedCustomizingViewControllers -= HandleFinishedCustomizingViewControllers;
void SetControllers()
{
var list = new List<UIViewController>();
- for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
+ for (var i = 0; i < Element.LogicalChildren.Count; i++)
{
- var child = ElementController.LogicalChildren[i];
+ var child = Element.LogicalChildren[i];
var v = child as VisualElement;
if (v == null)
continue;
var originalIndex = -1;
if (int.TryParse(viewControllers[i].TabBarItem.Tag.ToString(), out originalIndex))
{
- var page = (Page)((IPageController)Tabbed).InternalChildren[originalIndex];
+ var page = (Page)Tabbed.InternalChildren[originalIndex];
TabbedPage.SetIndex(page, i);
}
}
void UpdateCurrentPage()
{
- var count = ((IPageController)Tabbed).InternalChildren.Count;
+ var count = Tabbed.InternalChildren.Count;
var index = (int)SelectedIndex;
((TabbedPage)Element).CurrentPage = index >= 0 && index < count ? Tabbed.GetPageByIndex(index) : null;
}
{
readonly Dictionary<nint, Cell> _headerCells = new Dictionary<nint, Cell>();
- protected ITableViewController Controller => View;
-
protected bool HasBoundGestures;
protected UITableView Table;
public TableViewModelRenderer(TableView model)
{
View = model;
- Controller.ModelChanged += (s, e) =>
+ View.ModelChanged += (s, e) =>
{
if (Table != null)
Table.ReloadData();
public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
{
- var cell = Controller.Model.GetCell(indexPath.Section, indexPath.Row);
+ var cell = View.Model.GetCell(indexPath.Section, indexPath.Row);
var nativeCell = CellTableViewCell.GetNativeCell(tableView, cell);
return nativeCell;
public override nfloat GetHeightForHeader(UITableView tableView, nint section)
{
if (!_headerCells.ContainsKey((int)section))
- _headerCells[section] = Controller.Model.GetHeaderCell((int)section);
+ _headerCells[section] = View.Model.GetHeaderCell((int)section);
var result = _headerCells[section];
public override UIView GetViewForHeader(UITableView tableView, nint section)
{
if (!_headerCells.ContainsKey((int)section))
- _headerCells[section] = Controller.Model.GetHeaderCell((int)section);
+ _headerCells[section] = View.Model.GetHeaderCell((int)section);
var result = _headerCells[section];
if (indexPath == null)
return;
- Controller.Model.RowLongPressed(indexPath.Section, indexPath.Row);
+ View.Model.RowLongPressed(indexPath.Section, indexPath.Row);
}
public override nint NumberOfSections(UITableView tableView)
{
BindGestures(tableView);
- return Controller.Model.GetSectionCount();
+ return View.Model.GetSectionCount();
}
public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
{
- Controller.Model.RowSelected(indexPath.Section, indexPath.Row);
+ View.Model.RowSelected(indexPath.Section, indexPath.Row);
if (AutomaticallyDeselect)
tableView.DeselectRow(indexPath, true);
}
public override nint RowsInSection(UITableView tableview, nint section)
{
- return Controller.Model.GetRowCount((int)section);
+ return View.Model.GetRowCount((int)section);
}
public override string[] SectionIndexTitles(UITableView tableView)
{
- return Controller.Model.GetSectionIndexTitles();
+ return View.Model.GetSectionIndexTitles();
}
public override string TitleForHeader(UITableView tableView, nint section)
{
- return Controller.Model.GetSectionTitle((int)section);
+ return View.Model.GetSectionTitle((int)section);
}
void BindGestures(UITableView tableview)
VisualElementTracker _tracker;
- IPageController PageController => Element as IPageController;
- IElementController ElementController => Element as IElementController;
+ Page PageController => Element as Page;
+ Element ElementController => Element as Element;
protected MasterDetailPage MasterDetailPage => _masterDetailPage ?? (_masterDetailPage = (MasterDetailPage)Element);
- IMasterDetailPageController MasterDetailPageController => MasterDetailPage as IMasterDetailPageController;
-
UIBarButtonItem PresentButton
{
get { return _innerDelegate == null ? null : _innerDelegate.PresentButton; }
var masterBounds = _masterController.View.Frame;
if (!masterBounds.IsEmpty)
- MasterDetailPageController.MasterBounds = new Rectangle(0, 0, masterBounds.Width, masterBounds.Height);
+ MasterDetailPage.MasterBounds = new Rectangle(0, 0, masterBounds.Width, masterBounds.Height);
if (!detailsBounds.IsEmpty)
- MasterDetailPageController.DetailBounds = new Rectangle(0, 0, detailsBounds.Width, detailsBounds.Height);
+ MasterDetailPage.DetailBounds = new Rectangle(0, 0, detailsBounds.Width, detailsBounds.Height);
}
public override void ViewDidLoad()
{
// On IOS8 the MasterViewController ViewAppear/Disappear weren't being called correctly after rotation
// We now close the Master by using the new SplitView API, basicly we set it to hidden and right back to the Normal/AutomaticMode
- if (!MasterDetailPageController.ShouldShowSplitMode && _masterVisible)
+ if (!MasterDetailPage.ShouldShowSplitMode && _masterVisible)
{
- MasterDetailPageController.CanChangeIsPresented = true;
+ MasterDetailPage.CanChangeIsPresented = true;
PreferredDisplayMode = UISplitViewControllerDisplayMode.PrimaryHidden;
PreferredDisplayMode = UISplitViewControllerDisplayMode.Automatic;
}
- MasterDetailPageController.UpdateMasterBehavior();
+ MasterDetailPage.UpdateMasterBehavior();
MessagingCenter.Send<IVisualElementRenderer>(this, NavigationRenderer.UpdateToolbarButtons);
base.WillRotate(toInterfaceOrientation, duration);
}
if (e.PropertyName == "Master" || e.PropertyName == "Detail")
UpdateControllers();
- else if (e.PropertyName == MasterDetailPage.IsPresentedProperty.PropertyName)
+ else if (e.PropertyName == Xamarin.Forms.MasterDetailPage.IsPresentedProperty.PropertyName)
ToggleMaster();
- else if (e.PropertyName == MasterDetailPage.IsGestureEnabledProperty.PropertyName)
- PresentsWithGesture = MasterDetailPage.IsGestureEnabled;
+ else if (e.PropertyName == Xamarin.Forms.MasterDetailPage.IsGestureEnabledProperty.PropertyName)
+ base.PresentsWithGesture = this.MasterDetailPage.IsGestureEnabled;
MessagingCenter.Send<IVisualElementRenderer>(this, NavigationRenderer.UpdateToolbarButtons);
}
void MasterControllerWillAppear(object sender, EventArgs e)
{
_masterVisible = true;
- if (MasterDetailPageController.CanChangeIsPresented)
+ if (MasterDetailPage.CanChangeIsPresented)
ElementController.SetValueFromRenderer(MasterDetailPage.IsPresentedProperty, true);
}
void MasterControllerWillDisappear(object sender, EventArgs e)
{
_masterVisible = false;
- if (MasterDetailPageController.CanChangeIsPresented)
+ if (MasterDetailPage.CanChangeIsPresented)
ElementController.SetValueFromRenderer(MasterDetailPage.IsPresentedProperty, false);
}
void ToggleMaster()
{
- if (_masterVisible == MasterDetailPage.IsPresented || MasterDetailPageController.ShouldShowSplitMode)
+ if (_masterVisible == MasterDetailPage.IsPresented || MasterDetailPage.ShouldShowSplitMode)
return;
PerformButtonSelector();
{
}
- IWebViewController ElementController => Element as IWebViewController;
+ WebView WebView => Element as WebView;
public VisualElement Element { get; private set; }
var oldElement = Element;
Element = element;
Element.PropertyChanged += HandlePropertyChanged;
- ElementController.EvalRequested += OnEvalRequested;
- ElementController.GoBackRequested += OnGoBackRequested;
- ElementController.GoForwardRequested += OnGoForwardRequested;
+ WebView.EvalRequested += OnEvalRequested;
+ WebView.GoBackRequested += OnGoBackRequested;
+ WebView.GoForwardRequested += OnGoForwardRequested;
Delegate = new CustomWebViewDelegate(this);
BackgroundColor = UIColor.Clear;
StopLoading();
Element.PropertyChanged -= HandlePropertyChanged;
- ElementController.EvalRequested -= OnEvalRequested;
- ElementController.GoBackRequested -= OnGoBackRequested;
- ElementController.GoForwardRequested -= OnGoForwardRequested;
+ WebView.EvalRequested -= OnEvalRequested;
+ WebView.GoBackRequested -= OnGoBackRequested;
+ WebView.GoForwardRequested -= OnGoForwardRequested;
_tracker?.Dispose();
_packager?.Dispose();
void UpdateCanGoBackForward()
{
- ElementController.CanGoBack = CanGoBack;
- ElementController.CanGoForward = CanGoForward;
+ ((IWebViewController)WebView).CanGoBack = CanGoBack;
+ ((IWebViewController)WebView).CanGoForward = CanGoForward;
}
class CustomWebViewDelegate : UIWebViewDelegate
_renderer = renderer;
}
- IWebViewController WebViewController => WebView;
-
WebView WebView
{
get { return (WebView)_renderer.Element; }
public override void LoadFailed(UIWebView webView, NSError error)
{
var url = GetCurrentUrl();
- WebViewController.SendNavigated(new WebNavigatedEventArgs(_lastEvent, new UrlWebViewSource { Url = url }, url, WebNavigationResult.Failure));
+ WebView.SendNavigated(new WebNavigatedEventArgs(_lastEvent, new UrlWebViewSource { Url = url }, url, WebNavigationResult.Failure));
_renderer.UpdateCanGoBackForward();
}
_renderer._ignoreSourceChanges = true;
var url = GetCurrentUrl();
- ((IElementController)WebView).SetValueFromRenderer(WebView.SourceProperty, new UrlWebViewSource { Url = url });
+ WebView.SetValueFromRenderer(WebView.SourceProperty, new UrlWebViewSource { Url = url });
_renderer._ignoreSourceChanges = false;
var args = new WebNavigatedEventArgs(_lastEvent, WebView.Source, url, WebNavigationResult.Success);
- WebViewController.SendNavigated(args);
+ WebView.SendNavigated(args);
_renderer.UpdateCanGoBackForward();
}
var lastUrl = request.Url.ToString();
var args = new WebNavigatingEventArgs(navEvent, new UrlWebViewSource { Url = lastUrl }, lastUrl);
- WebViewController.SendNavigating(args);
+ WebView.SendNavigating(args);
_renderer.UpdateCanGoBackForward();
return !args.Cancel;
}
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Targets">
- <MemberSignature Language="C#" Value="public System.Collections.Generic.IEnumerable<Xamarin.Forms.Page> Targets { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IEnumerable`1<class Xamarin.Forms.Page> Targets" />
- <MemberType>Property</MemberType>
+ <Member MemberName="SendTargetSelected">
+ <MemberSignature Language="C#" Value="public void SendTargetSelected (Xamarin.Forms.Page target);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendTargetSelected(class Xamarin.Forms.Page target) cil managed" />
+ <MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
- <ReturnType>System.Collections.Generic.IEnumerable<Xamarin.Forms.Page></ReturnType>
+ <ReturnType>System.Void</ReturnType>
</ReturnValue>
+ <Parameters>
+ <Parameter Name="target" Type="Xamarin.Forms.Page" />
+ </Parameters>
<Docs>
+ <param name="target">To be added.</param>
<summary>To be added.</summary>
- <value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.INavigationMenuController.SendTargetSelected">
- <MemberSignature Language="C#" Value="void INavigationMenuController.SendTargetSelected (Xamarin.Forms.Page target);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.INavigationMenuController.SendTargetSelected(class Xamarin.Forms.Page target) cil managed" />
- <MemberType>Method</MemberType>
+ <Member MemberName="Targets">
+ <MemberSignature Language="C#" Value="public System.Collections.Generic.IEnumerable<Xamarin.Forms.Page> Targets { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IEnumerable`1<class Xamarin.Forms.Page> Targets" />
+ <MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
- <ReturnType>System.Void</ReturnType>
+ <ReturnType>System.Collections.Generic.IEnumerable<Xamarin.Forms.Page></ReturnType>
</ReturnValue>
- <Parameters>
- <Parameter Name="target" Type="Xamarin.Forms.Page" />
- </Parameters>
<Docs>
- <param name="target">To be added.</param>
<summary>To be added.</summary>
+ <value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="SetCurrentApplication">
- <MemberSignature Language="C#" Value="public static void SetCurrentApplication (Xamarin.Forms.Application value);" />
- <MemberSignature Language="ILAsm" Value=".method public static hidebysig void SetCurrentApplication(class Xamarin.Forms.Application value) cil managed" />
+ <Member MemberName="SetAppIndexingProvider">
+ <MemberSignature Language="C#" Value="public void SetAppIndexingProvider (Xamarin.Forms.IAppIndexingProvider provider);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SetAppIndexingProvider(class Xamarin.Forms.IAppIndexingProvider provider) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
- <Parameter Name="value" Type="Xamarin.Forms.Application" />
+ <Parameter Name="provider" Type="Xamarin.Forms.IAppIndexingProvider" />
</Parameters>
<Docs>
- <param name="value">To be added.</param>
+ <param name="provider">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IApplicationController.SetAppIndexingProvider">
- <MemberSignature Language="C#" Value="void IApplicationController.SetAppIndexingProvider (Xamarin.Forms.IAppIndexingProvider provider);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IApplicationController.SetAppIndexingProvider(class Xamarin.Forms.IAppIndexingProvider provider) cil managed" />
+ <Member MemberName="SetCurrentApplication">
+ <MemberSignature Language="C#" Value="public static void SetCurrentApplication (Xamarin.Forms.Application value);" />
+ <MemberSignature Language="ILAsm" Value=".method public static hidebysig void SetCurrentApplication(class Xamarin.Forms.Application value) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
- <Parameter Name="provider" Type="Xamarin.Forms.IAppIndexingProvider" />
+ <Parameter Name="value" Type="Xamarin.Forms.Application" />
</Parameters>
<Docs>
- <param name="provider">To be added.</param>
- <summary>Internal. Do not use.</summary>
+ <param name="value">To be added.</param>
+ <summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<remarks>The released event always occur before the clicked event.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendClicked">
+ <MemberSignature Language="C#" Value="public void SendClicked ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendClicked() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SendPressed">
+ <MemberSignature Language="C#" Value="public void SendPressed ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPressed() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SendReleased">
+ <MemberSignature Language="C#" Value="public void SendReleased ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendReleased() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Text">
<MemberSignature Language="C#" Value="public string Text { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Text" />
<AssemblyVersion>1.3.0.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IButtonController.SendPressed">
- <MemberSignature Language="C#" Value="void IButtonController.SendPressed ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IButtonController.SendPressed() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>Sends a press event.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IButtonController.SendReleased">
- <MemberSignature Language="C#" Value="void IButtonController.SendReleased ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IButtonController.SendReleased() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>Sends a release event.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator">
<MemberSignature Language="C#" Value="double IFontElement.FontSizeDefaultValueCreator ();" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance float64 Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator() cil managed" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="ForceUpdateSizeRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler ForceUpdateSizeRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler ForceUpdateSizeRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="HasContextActions">
<MemberSignature Language="C#" Value="public bool HasContextActions { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance bool HasContextActions" />
</remarks>
</Docs>
</Member>
- <Member MemberName="Tapped">
- <MemberSignature Language="C#" Value="public event EventHandler Tapped;" />
- <MemberSignature Language="ILAsm" Value=".event class System.EventHandler Tapped" />
- <MemberType>Event</MemberType>
+ <Member MemberName="SendAppearing">
+ <MemberSignature Language="C#" Value="public void SendAppearing ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendAppearing() cil managed" />
+ <MemberType>Method</MemberType>
<AssemblyInfo>
- <AssemblyVersion>1.0.0.0</AssemblyVersion>
- <AssemblyVersion>1.1.0.0</AssemblyVersion>
- <AssemblyVersion>1.2.0.0</AssemblyVersion>
- <AssemblyVersion>1.3.0.0</AssemblyVersion>
- <AssemblyVersion>1.4.0.0</AssemblyVersion>
- <AssemblyVersion>1.5.0.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
- <ReturnType>System.EventHandler</ReturnType>
+ <ReturnType>System.Void</ReturnType>
</ReturnValue>
+ <Parameters />
<Docs>
- <summary>Occurs when the Cell is Tapped.</summary>
- <remarks>
- </remarks>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.ICellController.SendAppearing">
- <MemberSignature Language="C#" Value="void ICellController.SendAppearing ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.ICellController.SendAppearing() cil managed" />
+ <Member MemberName="SendDisappearing">
+ <MemberSignature Language="C#" Value="public void SendDisappearing ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendDisappearing() cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
- <summary>This method is for internal use by platform renderers.</summary>
+ <summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.ICellController.SendDisappearing">
- <MemberSignature Language="C#" Value="void ICellController.SendDisappearing ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.ICellController.SendDisappearing() cil managed" />
- <MemberType>Method</MemberType>
+ <Member MemberName="Tapped">
+ <MemberSignature Language="C#" Value="public event EventHandler Tapped;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler Tapped" />
+ <MemberType>Event</MemberType>
<AssemblyInfo>
+ <AssemblyVersion>1.0.0.0</AssemblyVersion>
+ <AssemblyVersion>1.1.0.0</AssemblyVersion>
+ <AssemblyVersion>1.2.0.0</AssemblyVersion>
+ <AssemblyVersion>1.3.0.0</AssemblyVersion>
+ <AssemblyVersion>1.4.0.0</AssemblyVersion>
+ <AssemblyVersion>1.5.0.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
- <ReturnType>System.Void</ReturnType>
+ <ReturnType>System.EventHandler</ReturnType>
</ReturnValue>
- <Parameters />
<Docs>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
+ <summary>Occurs when the Cell is Tapped.</summary>
+ <remarks>
+ </remarks>
</Docs>
</Member>
</Members>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendCompleted">
+ <MemberSignature Language="C#" Value="public void SendCompleted ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendCompleted() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Text">
<MemberSignature Language="C#" Value="public string Text { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Text" />
</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IEditorController.SendCompleted">
- <MemberSignature Language="C#" Value="void IEditorController.SendCompleted ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IEditorController.SendCompleted() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>To be added.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator">
<MemberSignature Language="C#" Value="double IFontElement.FontSizeDefaultValueCreator ();" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance float64 Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator() cil managed" />
<AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
</Attribute>
<Attribute>
- <AttributeName>System.Runtime.CompilerServices.IteratorStateMachine(typeof(Xamarin.Forms.Element/<Descendants>d__81))</AttributeName>
+ <AttributeName>System.Runtime.CompilerServices.IteratorStateMachine(typeof(Xamarin.Forms.Element/<Descendants>d__82))</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="EffectControlProvider">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.IEffectControlProvider EffectControlProvider { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.IEffectControlProvider EffectControlProvider" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.IEffectControlProvider</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="EffectIsAttached">
+ <MemberSignature Language="C#" Value="public bool EffectIsAttached (string name);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool EffectIsAttached(string name) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Boolean</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="name" Type="System.String" />
+ </Parameters>
+ <Docs>
+ <param name="name">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Effects">
<MemberSignature Language="C#" Value="public System.Collections.Generic.IList<Xamarin.Forms.Effect> Effects { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IList`1<class Xamarin.Forms.Effect> Effects" />
<remarks>This value is generated at runtime and is not stable across runs of your app.</remarks>
</Docs>
</Member>
+ <Member MemberName="LogicalChildren">
+ <MemberSignature Language="C#" Value="public System.Collections.ObjectModel.ReadOnlyCollection<Xamarin.Forms.Element> LogicalChildren { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.ObjectModel.ReadOnlyCollection`1<class Xamarin.Forms.Element> LogicalChildren" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Collections.ObjectModel.ReadOnlyCollection<Xamarin.Forms.Element></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="OnBindingContextChanged">
<MemberSignature Language="C#" Value="protected override void OnBindingContextChanged ();" />
<MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void OnBindingContextChanged() cil managed" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="SetValueFromRenderer">
+ <MemberSignature Language="C#" Value="public void SetValueFromRenderer (Xamarin.Forms.BindableProperty property, object value);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetValueFromRenderer(class Xamarin.Forms.BindableProperty property, object value) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="property" Type="Xamarin.Forms.BindableProperty" />
+ <Parameter Name="value" Type="System.Object" />
+ </Parameters>
+ <Docs>
+ <param name="property">To be added.</param>
+ <param name="value">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SetValueFromRenderer">
+ <MemberSignature Language="C#" Value="public void SetValueFromRenderer (Xamarin.Forms.BindablePropertyKey property, object value);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SetValueFromRenderer(class Xamarin.Forms.BindablePropertyKey property, object value) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="property" Type="Xamarin.Forms.BindablePropertyKey" />
+ <Parameter Name="value" Type="System.Object" />
+ </Parameters>
+ <Docs>
+ <param name="property">To be added.</param>
+ <param name="value">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="StyleId">
<MemberSignature Language="C#" Value="public string StyleId { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string StyleId" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IElementController.EffectControlProvider">
- <MemberSignature Language="C#" Value="Xamarin.Forms.IEffectControlProvider Xamarin.Forms.IElementController.EffectControlProvider { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.IEffectControlProvider Xamarin.Forms.IElementController.EffectControlProvider" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.IEffectControlProvider</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>For internal use only.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IElementController.EffectIsAttached">
- <MemberSignature Language="C#" Value="bool IElementController.EffectIsAttached (string name);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance bool Xamarin.Forms.IElementController.EffectIsAttached(string name) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Boolean</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="name" Type="System.String" />
- </Parameters>
- <Docs>
- <param name="name">To be added.</param>
- <summary>For internal use only.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IElementController.LogicalChildren">
- <MemberSignature Language="C#" Value="System.Collections.ObjectModel.ReadOnlyCollection<Xamarin.Forms.Element> Xamarin.Forms.IElementController.LogicalChildren { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.ObjectModel.ReadOnlyCollection`1<class Xamarin.Forms.Element> Xamarin.Forms.IElementController.LogicalChildren" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Collections.ObjectModel.ReadOnlyCollection<Xamarin.Forms.Element></ReturnType>
- </ReturnValue>
- <Docs>
- <summary>For internal use only.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.IElementController.SetValueFromRenderer">
<MemberSignature Language="C#" Value="void IElementController.SetValueFromRenderer (Xamarin.Forms.BindableProperty property, object value);" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IElementController.SetValueFromRenderer(class Xamarin.Forms.BindableProperty property, object value) cil managed" />
<AssemblyVersion>1.3.3.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</remarks>
</Docs>
</Member>
+ <Member MemberName="SendCompleted">
+ <MemberSignature Language="C#" Value="public void SendCompleted ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendCompleted() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Text">
<MemberSignature Language="C#" Value="public string Text { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Text" />
</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IEntryController.SendCompleted">
- <MemberSignature Language="C#" Value="void IEntryController.SendCompleted ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IEntryController.SendCompleted() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This interface is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator">
<MemberSignature Language="C#" Value="double IFontElement.FontSizeDefaultValueCreator ();" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance float64 Xamarin.Forms.Internals.IFontElement.FontSizeDefaultValueCreator() cil managed" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="SendCompleted">
+ <MemberSignature Language="C#" Value="public void SendCompleted ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendCompleted() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Text">
<MemberSignature Language="C#" Value="public string Text { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Text" />
</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IEntryCellController.SendCompleted">
- <MemberSignature Language="C#" Value="void IEntryCellController.SendCompleted ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IEntryCellController.SendCompleted() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This interface is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>Overriden for Image.</remarks>
</Docs>
</Member>
+ <Member MemberName="SetIsLoading">
+ <MemberSignature Language="C#" Value="public void SetIsLoading (bool isLoading);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SetIsLoading(bool isLoading) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="isLoading" Type="System.Boolean" />
+ </Parameters>
+ <Docs>
+ <param name="isLoading">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Source">
<MemberSignature Language="C#" Value="public Xamarin.Forms.ImageSource Source { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.ImageSource Source" />
</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IImageController.SetIsLoading">
- <MemberSignature Language="C#" Value="void IImageController.SetIsLoading (bool isLoading);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IImageController.SetIsLoading(bool isLoading) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="isLoading" Type="System.Boolean" />
- </Parameters>
- <Docs>
- <param name="isLoading">To be added.</param>
- <summary>For internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="Children">
+ <MemberSignature Language="C#" Value="public System.Collections.Generic.IReadOnlyList<Xamarin.Forms.Element> Children { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IReadOnlyList`1<class Xamarin.Forms.Element> Children" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Collections.Generic.IReadOnlyList<Xamarin.Forms.Element></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="ForceLayout">
<MemberSignature Language="C#" Value="public void ForceLayout ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance void ForceLayout() cil managed" />
<AssemblyVersion>1.3.5.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Collections.Generic.IReadOnlyList<Xamarin.Forms.Element></ReturnType>
</remarks>
</Docs>
</Member>
+ <Member MemberName="CreateDefaultCell">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Cell CreateDefaultCell (object item);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.Cell CreateDefaultCell(object item) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Cell</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="item" Type="System.Object" />
+ </Parameters>
+ <Docs>
+ <param name="item">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="EndRefresh">
<MemberSignature Language="C#" Value="public void EndRefresh ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance void EndRefresh() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="FooterElement">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Element FooterElement { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Element FooterElement" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Element</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="FooterProperty">
<MemberSignature Language="C#" Value="public static readonly Xamarin.Forms.BindableProperty FooterProperty;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly class Xamarin.Forms.BindableProperty FooterProperty" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="GetDisplayTextFromGroup">
+ <MemberSignature Language="C#" Value="public string GetDisplayTextFromGroup (object cell);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance string GetDisplayTextFromGroup(object cell) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.String</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="cell" Type="System.Object" />
+ </Parameters>
+ <Docs>
+ <param name="cell">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="GroupDisplayBinding">
<MemberSignature Language="C#" Value="public Xamarin.Forms.BindingBase GroupDisplayBinding { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.BindingBase GroupDisplayBinding" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="HeaderElement">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Element HeaderElement { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Element HeaderElement" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Element</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="HeaderProperty">
<MemberSignature Language="C#" Value="public static readonly Xamarin.Forms.BindableProperty HeaderProperty;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly class Xamarin.Forms.BindableProperty HeaderProperty" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="NotifyRowTapped">
+ <MemberSignature Language="C#" Value="public void NotifyRowTapped (int index, Xamarin.Forms.Cell cell = null);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void NotifyRowTapped(int32 index, class Xamarin.Forms.Cell cell) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="index" Type="System.Int32" />
+ <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
+ </Parameters>
+ <Docs>
+ <param name="index">To be added.</param>
+ <param name="cell">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="NotifyRowTapped">
+ <MemberSignature Language="C#" Value="public void NotifyRowTapped (int groupIndex, int inGroupIndex, Xamarin.Forms.Cell cell = null);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void NotifyRowTapped(int32 groupIndex, int32 inGroupIndex, class Xamarin.Forms.Cell cell) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="groupIndex" Type="System.Int32" />
+ <Parameter Name="inGroupIndex" Type="System.Int32" />
+ <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
+ </Parameters>
+ <Docs>
+ <param name="groupIndex">To be added.</param>
+ <param name="inGroupIndex">To be added.</param>
+ <param name="cell">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="On<T>">
<MemberSignature Language="C#" Value="public Xamarin.Forms.IPlatformElementConfiguration<T,Xamarin.Forms.ListView> On<T> () where T : Xamarin.Forms.IConfigPlatform;" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.IPlatformElementConfiguration`2<!!T, class Xamarin.Forms.ListView> On<(class Xamarin.Forms.IConfigPlatform) T>() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="RefreshAllowed">
+ <MemberSignature Language="C#" Value="public bool RefreshAllowed { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance bool RefreshAllowed" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Boolean</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="RefreshCommand">
<MemberSignature Language="C#" Value="public System.Windows.Input.ICommand RefreshCommand { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance class System.Windows.Input.ICommand RefreshCommand" />
<see cref="P:Xamarin.Forms.ListView.IsGroupingEnabled" /> is <see langword="false" />.</exception>
</Docs>
</Member>
+ <Member MemberName="ScrollToRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.ScrollToRequestedEventArgs> ScrollToRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.ScrollToRequestedEventArgs> ScrollToRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.ScrollToRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="SelectedItem">
<MemberSignature Language="C#" Value="public object SelectedItem { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance object SelectedItem" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="SendCellAppearing">
+ <MemberSignature Language="C#" Value="public void SendCellAppearing (Xamarin.Forms.Cell cell);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendCellAppearing(class Xamarin.Forms.Cell cell) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
+ </Parameters>
+ <Docs>
+ <param name="cell">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SendCellDisappearing">
+ <MemberSignature Language="C#" Value="public void SendCellDisappearing (Xamarin.Forms.Cell cell);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendCellDisappearing(class Xamarin.Forms.Cell cell) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
+ </Parameters>
+ <Docs>
+ <param name="cell">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SendRefreshing">
+ <MemberSignature Language="C#" Value="public void SendRefreshing ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendRefreshing() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="SeparatorColor">
<MemberSignature Language="C#" Value="public Xamarin.Forms.Color SeparatorColor { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Color SeparatorColor" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IListViewController.CachingStrategy">
- <MemberSignature Language="C#" Value="Xamarin.Forms.ListViewCachingStrategy Xamarin.Forms.IListViewController.CachingStrategy { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.ListViewCachingStrategy Xamarin.Forms.IListViewController.CachingStrategy" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.ListViewCachingStrategy</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>This method is for internal use by platform renderers.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IListViewController.CreateDefaultCell">
- <MemberSignature Language="C#" Value="Xamarin.Forms.Cell IListViewController.CreateDefaultCell (object item);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance class Xamarin.Forms.Cell Xamarin.Forms.IListViewController.CreateDefaultCell(object item) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.Cell</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="item" Type="System.Object" />
- </Parameters>
- <Docs>
- <param name="item">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.IListViewController.FooterElement">
<MemberSignature Language="C#" Value="Xamarin.Forms.Element Xamarin.Forms.IListViewController.FooterElement { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Element Xamarin.Forms.IListViewController.FooterElement" />
<AssemblyVersion>1.3.5.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Xamarin.Forms.Element</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IListViewController.GetDisplayTextFromGroup">
- <MemberSignature Language="C#" Value="string IListViewController.GetDisplayTextFromGroup (object cell);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance string Xamarin.Forms.IListViewController.GetDisplayTextFromGroup(object cell) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.String</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="cell" Type="System.Object" />
- </Parameters>
- <Docs>
- <param name="cell">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.IListViewController.HeaderElement">
<MemberSignature Language="C#" Value="Xamarin.Forms.Element Xamarin.Forms.IListViewController.HeaderElement { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Element Xamarin.Forms.IListViewController.HeaderElement" />
<AssemblyVersion>1.3.5.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Xamarin.Forms.Element</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IListViewController.NotifyRowTapped">
- <MemberSignature Language="C#" Value="void IListViewController.NotifyRowTapped (int index, Xamarin.Forms.Cell cell);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IListViewController.NotifyRowTapped(int32 index, class Xamarin.Forms.Cell cell) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="index" Type="System.Int32" />
- <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
- </Parameters>
- <Docs>
- <param name="index">To be added.</param>
- <param name="cell">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IListViewController.NotifyRowTapped">
- <MemberSignature Language="C#" Value="void IListViewController.NotifyRowTapped (int index, int inGroupIndex, Xamarin.Forms.Cell cell);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IListViewController.NotifyRowTapped(int32 index, int32 inGroupIndex, class Xamarin.Forms.Cell cell) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="index" Type="System.Int32" />
- <Parameter Name="inGroupIndex" Type="System.Int32" />
- <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
- </Parameters>
- <Docs>
- <param name="index">To be added.</param>
- <param name="inGroupIndex">To be added.</param>
- <param name="cell">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IListViewController.RefreshAllowed">
- <MemberSignature Language="C#" Value="bool Xamarin.Forms.IListViewController.RefreshAllowed { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance bool Xamarin.Forms.IListViewController.RefreshAllowed" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Boolean</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IListViewController.SendCellAppearing">
- <MemberSignature Language="C#" Value="void IListViewController.SendCellAppearing (Xamarin.Forms.Cell cell);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IListViewController.SendCellAppearing(class Xamarin.Forms.Cell cell) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
- </Parameters>
- <Docs>
- <param name="cell">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IListViewController.SendCellDisappearing">
- <MemberSignature Language="C#" Value="void IListViewController.SendCellDisappearing (Xamarin.Forms.Cell cell);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IListViewController.SendCellDisappearing(class Xamarin.Forms.Cell cell) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="cell" Type="Xamarin.Forms.Cell" />
- </Parameters>
- <Docs>
- <param name="cell">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
<Member MemberName="Xamarin.Forms.IListViewController.SendRefreshing">
<MemberSignature Language="C#" Value="void IListViewController.SendRefreshing ();" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IListViewController.SendRefreshing() cil managed" />
<AssemblyVersion>1.3.5.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="BackButtonPressed">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.BackButtonPressedEventArgs> BackButtonPressed;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.BackButtonPressedEventArgs> BackButtonPressed" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.BackButtonPressedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="CanChangeIsPresented">
+ <MemberSignature Language="C#" Value="public bool CanChangeIsPresented { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance bool CanChangeIsPresented" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Boolean</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Detail">
<MemberSignature Language="C#" Value="public Xamarin.Forms.Page Detail { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Page Detail" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="DetailBounds">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Rectangle DetailBounds { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle DetailBounds" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="IsGestureEnabled">
<MemberSignature Language="C#" Value="public bool IsGestureEnabled { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance bool IsGestureEnabled" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="MasterBounds">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Rectangle MasterBounds { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle MasterBounds" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="On<T>">
<MemberSignature Language="C#" Value="public Xamarin.Forms.IPlatformElementConfiguration<T,Xamarin.Forms.MasterDetailPage> On<T> () where T : Xamarin.Forms.IConfigPlatform;" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.IPlatformElementConfiguration`2<!!T, class Xamarin.Forms.MasterDetailPage> On<(class Xamarin.Forms.IConfigPlatform) T>() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="ShouldShowToolbarButton">
- <MemberSignature Language="C#" Value="public virtual bool ShouldShowToolbarButton ();" />
- <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool ShouldShowToolbarButton() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>1.3.0.0</AssemblyVersion>
- <AssemblyVersion>1.4.0.0</AssemblyVersion>
- <AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Boolean</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>Returns a value that tells whether the list view should display a toolbar button.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IMasterDetailPageController.CanChangeIsPresented">
- <MemberSignature Language="C#" Value="bool Xamarin.Forms.IMasterDetailPageController.CanChangeIsPresented { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance bool Xamarin.Forms.IMasterDetailPageController.CanChangeIsPresented" />
+ <Member MemberName="ShouldShowSplitMode">
+ <MemberSignature Language="C#" Value="public bool ShouldShowSplitMode { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance bool ShouldShowSplitMode" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
- <summary>Internal.</summary>
+ <summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IMasterDetailPageController.DetailBounds">
- <MemberSignature Language="C#" Value="Xamarin.Forms.Rectangle Xamarin.Forms.IMasterDetailPageController.DetailBounds { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle Xamarin.Forms.IMasterDetailPageController.DetailBounds" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IMasterDetailPageController.MasterBounds">
- <MemberSignature Language="C#" Value="Xamarin.Forms.Rectangle Xamarin.Forms.IMasterDetailPageController.MasterBounds { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle Xamarin.Forms.IMasterDetailPageController.MasterBounds" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IMasterDetailPageController.ShouldShowSplitMode">
- <MemberSignature Language="C#" Value="bool Xamarin.Forms.IMasterDetailPageController.ShouldShowSplitMode { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance bool Xamarin.Forms.IMasterDetailPageController.ShouldShowSplitMode" />
- <MemberType>Property</MemberType>
+ <Member MemberName="ShouldShowToolbarButton">
+ <MemberSignature Language="C#" Value="public virtual bool ShouldShowToolbarButton ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool ShouldShowToolbarButton() cil managed" />
+ <MemberType>Method</MemberType>
<AssemblyInfo>
+ <AssemblyVersion>1.3.0.0</AssemblyVersion>
+ <AssemblyVersion>1.4.0.0</AssemblyVersion>
+ <AssemblyVersion>1.5.0.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
+ <Parameters />
<Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
+ <summary>Returns a value that tells whether the list view should display a toolbar button.</summary>
+ <returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IMasterDetailPageController.UpdateMasterBehavior">
- <MemberSignature Language="C#" Value="void IMasterDetailPageController.UpdateMasterBehavior ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IMasterDetailPageController.UpdateMasterBehavior() cil managed" />
+ <Member MemberName="UpdateMasterBehavior">
+ <MemberSignature Language="C#" Value="public void UpdateMasterBehavior ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void UpdateMasterBehavior() cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
- <summary>Internal.</summary>
+ <summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="Activate">
+ <MemberSignature Language="C#" Value="public void Activate ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void Activate() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Clicked">
<MemberSignature Language="C#" Value="public event EventHandler Clicked;" />
<MemberSignature Language="ILAsm" Value=".event class System.EventHandler Clicked" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="IsEnabledPropertyName">
+ <MemberSignature Language="C#" Value="public string IsEnabledPropertyName { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance string IsEnabledPropertyName" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.String</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="OnClicked">
<MemberSignature Language="C#" Value="protected virtual void OnClicked ();" />
<MemberSignature Language="ILAsm" Value=".method familyhidebysig newslot virtual instance void OnClicked() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IMenuItemController.Activate">
- <MemberSignature Language="C#" Value="void IMenuItemController.Activate ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IMenuItemController.Activate() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IMenuItemController.IsEnabledPropertyName">
- <MemberSignature Language="C#" Value="string Xamarin.Forms.IMenuItemController.IsEnabledPropertyName { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance string Xamarin.Forms.IMenuItemController.IsEnabledPropertyName" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.String</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="InsertPageBeforeRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs> InsertPageBeforeRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.NavigationRequestedEventArgs> InsertPageBeforeRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="On<T>">
<MemberSignature Language="C#" Value="public Xamarin.Forms.IPlatformElementConfiguration<T,Xamarin.Forms.NavigationPage> On<T> () where T : Xamarin.Forms.IConfigPlatform;" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.IPlatformElementConfiguration`2<!!T, class Xamarin.Forms.NavigationPage> On<(class Xamarin.Forms.IConfigPlatform) T>() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="Pages">
+ <MemberSignature Language="C#" Value="public System.Collections.Generic.IEnumerable<Xamarin.Forms.Page> Pages { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IEnumerable`1<class Xamarin.Forms.Page> Pages" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Collections.Generic.IEnumerable<Xamarin.Forms.Page></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="Peek">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Page Peek (int depth);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.Page Peek(int32 depth) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Page</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="depth" Type="System.Int32" />
+ </Parameters>
+ <Docs>
+ <param name="depth">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="PopAsync">
<MemberSignature Language="C#" Value="public System.Threading.Tasks.Task<Xamarin.Forms.Page> PopAsync ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance class System.Threading.Tasks.Task`1<class Xamarin.Forms.Page> PopAsync() cil managed" />
<AttributeName>System.Diagnostics.DebuggerStepThrough</AttributeName>
</Attribute>
<Attribute>
- <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PopAsync>d__44))</AttributeName>
+ <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PopAsync>d__42))</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="PopAsyncInner">
+ <MemberSignature Language="C#" Value="public System.Threading.Tasks.Task<Xamarin.Forms.Page> PopAsyncInner (bool animated, bool fast);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class System.Threading.Tasks.Task`1<class Xamarin.Forms.Page> PopAsyncInner(bool animated, bool fast) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ <Attribute>
+ <AttributeName>System.Diagnostics.DebuggerStepThrough</AttributeName>
+ </Attribute>
+ <Attribute>
+ <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PopAsyncInner>d__64))</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Threading.Tasks.Task<Xamarin.Forms.Page></ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="animated" Type="System.Boolean" />
+ <Parameter Name="fast" Type="System.Boolean" />
+ </Parameters>
+ <Docs>
+ <param name="animated">To be added.</param>
+ <param name="fast">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Popped">
<MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.NavigationEventArgs> Popped;" />
<MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.NavigationEventArgs> Popped" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="PopRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs> PopRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.NavigationRequestedEventArgs> PopRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="PopToRootAsync">
<MemberSignature Language="C#" Value="public System.Threading.Tasks.Task PopToRootAsync ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance class System.Threading.Tasks.Task PopToRootAsync() cil managed" />
<AttributeName>System.Diagnostics.DebuggerStepThrough</AttributeName>
</Attribute>
<Attribute>
- <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PopToRootAsync>d__52))</AttributeName>
+ <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PopToRootAsync>d__50))</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="PopToRootRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs> PopToRootRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.NavigationRequestedEventArgs> PopToRootRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="PushAsync">
<MemberSignature Language="C#" Value="public System.Threading.Tasks.Task PushAsync (Xamarin.Forms.Page page);" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance class System.Threading.Tasks.Task PushAsync(class Xamarin.Forms.Page page) cil managed" />
<AttributeName>System.Diagnostics.DebuggerStepThrough</AttributeName>
</Attribute>
<Attribute>
- <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PushAsync>d__54))</AttributeName>
+ <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<PushAsync>d__52))</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="PushRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs> PushRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.NavigationRequestedEventArgs> PushRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="RemovePageRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs> RemovePageRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.NavigationRequestedEventArgs> RemovePageRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.NavigationRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="RootPage">
<MemberSignature Language="C#" Value="public Xamarin.Forms.Page RootPage { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.Page RootPage" />
</remarks>
</Docs>
</Member>
+ <Member MemberName="StackDepth">
+ <MemberSignature Language="C#" Value="public int StackDepth { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance int32 StackDepth" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Int32</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Tint">
<MemberSignature Language="C#" Value="public Xamarin.Forms.Color Tint { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Color Tint" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.INavigationPageController.Pages">
- <MemberSignature Language="C#" Value="System.Collections.Generic.IEnumerable<Xamarin.Forms.Page> Xamarin.Forms.INavigationPageController.Pages { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IEnumerable`1<class Xamarin.Forms.Page> Xamarin.Forms.INavigationPageController.Pages" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Collections.Generic.IEnumerable<Xamarin.Forms.Page></ReturnType>
- </ReturnValue>
- <Docs>
- <summary>For internal use by platform renderers.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.INavigationPageController.Peek">
- <MemberSignature Language="C#" Value="Xamarin.Forms.Page INavigationPageController.Peek (int depth);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance class Xamarin.Forms.Page Xamarin.Forms.INavigationPageController.Peek(int32 depth) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.Page</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="depth" Type="System.Int32" />
- </Parameters>
- <Docs>
- <param name="depth">To be added.</param>
- <summary>For internal use by platform renderers.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.INavigationPageController.PopAsyncInner">
- <MemberSignature Language="C#" Value="System.Threading.Tasks.Task<Xamarin.Forms.Page> INavigationPageController.PopAsyncInner (bool animated, bool fast);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance class System.Threading.Tasks.Task`1<class Xamarin.Forms.Page> Xamarin.Forms.INavigationPageController.PopAsyncInner(bool animated, bool fast) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <Attributes>
- <Attribute>
- <AttributeName>System.Diagnostics.DebuggerStepThrough</AttributeName>
- </Attribute>
- <Attribute>
- <AttributeName>System.Runtime.CompilerServices.AsyncStateMachine(typeof(Xamarin.Forms.NavigationPage/<Xamarin-Forms-INavigationPageController-PopAsyncInner>d__69))</AttributeName>
- </Attribute>
- </Attributes>
- <ReturnValue>
- <ReturnType>System.Threading.Tasks.Task<Xamarin.Forms.Page></ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="animated" Type="System.Boolean" />
- <Parameter Name="fast" Type="System.Boolean" />
- </Parameters>
- <Docs>
- <param name="animated">To be added.</param>
- <param name="fast">To be added.</param>
- <summary>This method is for internal use by platform renderers.</summary>
- <returns>To be added.</returns>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.INavigationPageController.StackDepth">
- <MemberSignature Language="C#" Value="int Xamarin.Forms.INavigationPageController.StackDepth { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance int32 Xamarin.Forms.INavigationPageController.StackDepth" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Int32</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="DisplayRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler DisplayRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler DisplayRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="HasRenderLoop">
<MemberSignature Language="C#" Value="public bool HasRenderLoop { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance bool HasRenderLoop" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="ContainerArea">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Rectangle ContainerArea { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle ContainerArea" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Disappearing">
<MemberSignature Language="C#" Value="public event EventHandler Disappearing;" />
<MemberSignature Language="ILAsm" Value=".event class System.EventHandler Disappearing" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="IgnoresContainerArea">
+ <MemberSignature Language="C#" Value="public bool IgnoresContainerArea { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance bool IgnoresContainerArea" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Boolean</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="InternalChildren">
+ <MemberSignature Language="C#" Value="public System.Collections.ObjectModel.ObservableCollection<Xamarin.Forms.Element> InternalChildren { get; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.ObjectModel.ObservableCollection`1<class Xamarin.Forms.Element> InternalChildren" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Collections.ObjectModel.ObservableCollection<Xamarin.Forms.Element></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="IsBusy">
<MemberSignature Language="C#" Value="public bool IsBusy { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance bool IsBusy" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendAppearing">
+ <MemberSignature Language="C#" Value="public void SendAppearing ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendAppearing() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="SendBackButtonPressed">
<MemberSignature Language="C#" Value="public bool SendBackButtonPressed ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool SendBackButtonPressed() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendDisappearing">
+ <MemberSignature Language="C#" Value="public void SendDisappearing ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendDisappearing() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Title">
<MemberSignature Language="C#" Value="public string Title { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Title" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPageController.ContainerArea">
- <MemberSignature Language="C#" Value="Xamarin.Forms.Rectangle Xamarin.Forms.IPageController.ContainerArea { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.Rectangle Xamarin.Forms.IPageController.ContainerArea" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.Rectangle</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IPageController.IgnoresContainerArea">
- <MemberSignature Language="C#" Value="bool Xamarin.Forms.IPageController.IgnoresContainerArea { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance bool Xamarin.Forms.IPageController.IgnoresContainerArea" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Boolean</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IPageController.InternalChildren">
- <MemberSignature Language="C#" Value="System.Collections.ObjectModel.ObservableCollection<Xamarin.Forms.Element> Xamarin.Forms.IPageController.InternalChildren { get; }" />
- <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.ObjectModel.ObservableCollection`1<class Xamarin.Forms.Element> Xamarin.Forms.IPageController.InternalChildren" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Collections.ObjectModel.ObservableCollection<Xamarin.Forms.Element></ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Internal.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IPageController.SendAppearing">
- <MemberSignature Language="C#" Value="void IPageController.SendAppearing ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPageController.SendAppearing() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IPageController.SendDisappearing">
- <MemberSignature Language="C#" Value="void IPageController.SendDisappearing ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPageController.SendDisappearing() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This method is for internal use by platform renderers.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="TouchPoints">
- <MemberSignature Language="C#" Value="public int TouchPoints { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance int32 TouchPoints" />
- <MemberType>Property</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Int32</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Gets or sets the number of touch points in the gesture.</summary>
- <value>To be added.</value>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="TouchPointsProperty">
- <MemberSignature Language="C#" Value="public static readonly Xamarin.Forms.BindableProperty TouchPointsProperty;" />
- <MemberSignature Language="ILAsm" Value=".field public static initonly class Xamarin.Forms.BindableProperty TouchPointsProperty" />
- <MemberType>Field</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>Xamarin.Forms.BindableProperty</ReturnType>
- </ReturnValue>
- <Docs>
- <summary>Backing store for the <see cref="P:Xamarin.Forms.PanGestureRecognizer.TouchPoints" /> property.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IPanGestureController.SendPan">
- <MemberSignature Language="C#" Value="void IPanGestureController.SendPan (Xamarin.Forms.Element sender, double totalX, double totalY, int gestureId);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPanGestureController.SendPan(class Xamarin.Forms.Element sender, float64 totalX, float64 totalY, int32 gestureId) cil managed" />
+ <Member MemberName="SendPan">
+ <MemberSignature Language="C#" Value="public void SendPan (Xamarin.Forms.Element sender, double totalX, double totalY, int gestureId);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPan(class Xamarin.Forms.Element sender, float64 totalX, float64 totalY, int32 gestureId) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPanGestureController.SendPanCanceled">
- <MemberSignature Language="C#" Value="void IPanGestureController.SendPanCanceled (Xamarin.Forms.Element sender, int gestureId);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPanGestureController.SendPanCanceled(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
+ <Member MemberName="SendPanCanceled">
+ <MemberSignature Language="C#" Value="public void SendPanCanceled (Xamarin.Forms.Element sender, int gestureId);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPanCanceled(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPanGestureController.SendPanCompleted">
- <MemberSignature Language="C#" Value="void IPanGestureController.SendPanCompleted (Xamarin.Forms.Element sender, int gestureId);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPanGestureController.SendPanCompleted(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
+ <Member MemberName="SendPanCompleted">
+ <MemberSignature Language="C#" Value="public void SendPanCompleted (Xamarin.Forms.Element sender, int gestureId);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPanCompleted(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPanGestureController.SendPanStarted">
- <MemberSignature Language="C#" Value="void IPanGestureController.SendPanStarted (Xamarin.Forms.Element sender, int gestureId);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPanGestureController.SendPanStarted(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
+ <Member MemberName="SendPanStarted">
+ <MemberSignature Language="C#" Value="public void SendPanStarted (Xamarin.Forms.Element sender, int gestureId);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPanStarted(class Xamarin.Forms.Element sender, int32 gestureId) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="TouchPoints">
+ <MemberSignature Language="C#" Value="public int TouchPoints { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance int32 TouchPoints" />
+ <MemberType>Property</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>1.5.0.0</AssemblyVersion>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <ReturnValue>
+ <ReturnType>System.Int32</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>Gets or sets the number of touch points in the gesture.</summary>
+ <value>To be added.</value>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="TouchPointsProperty">
+ <MemberSignature Language="C#" Value="public static readonly Xamarin.Forms.BindableProperty TouchPointsProperty;" />
+ <MemberSignature Language="ILAsm" Value=".field public static initonly class Xamarin.Forms.BindableProperty TouchPointsProperty" />
+ <MemberType>Field</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>1.5.0.0</AssemblyVersion>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.BindableProperty</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>Backing store for the <see cref="P:Xamarin.Forms.PanGestureRecognizer.TouchPoints" /> property.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="PinchUpdated">
- <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.PinchGestureUpdatedEventArgs> PinchUpdated;" />
- <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.PinchGestureUpdatedEventArgs> PinchUpdated" />
- <MemberType>Event</MemberType>
+ <Member MemberName="IsPinching">
+ <MemberSignature Language="C#" Value="public bool IsPinching { get; set; }" />
+ <MemberSignature Language="ILAsm" Value=".property instance bool IsPinching" />
+ <MemberType>Property</MemberType>
<AssemblyInfo>
- <AssemblyVersion>1.5.0.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
- <ReturnType>System.EventHandler<Xamarin.Forms.PinchGestureUpdatedEventArgs></ReturnType>
+ <ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
- <summary>Event that is raised when a pinch gesture updates.</summary>
+ <summary>To be added.</summary>
+ <value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPinchGestureController.IsPinching">
- <MemberSignature Language="C#" Value="bool Xamarin.Forms.IPinchGestureController.IsPinching { get; set; }" />
- <MemberSignature Language="ILAsm" Value=".property instance bool Xamarin.Forms.IPinchGestureController.IsPinching" />
- <MemberType>Property</MemberType>
+ <Member MemberName="PinchUpdated">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.PinchGestureUpdatedEventArgs> PinchUpdated;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.PinchGestureUpdatedEventArgs> PinchUpdated" />
+ <MemberType>Event</MemberType>
<AssemblyInfo>
+ <AssemblyVersion>1.5.0.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
- <ReturnType>System.Boolean</ReturnType>
+ <ReturnType>System.EventHandler<Xamarin.Forms.PinchGestureUpdatedEventArgs></ReturnType>
</ReturnValue>
<Docs>
- <summary>To be added.</summary>
- <value>To be added.</value>
+ <summary>Event that is raised when a pinch gesture updates.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPinchGestureController.SendPinch">
- <MemberSignature Language="C#" Value="void IPinchGestureController.SendPinch (Xamarin.Forms.Element sender, double delta, Xamarin.Forms.Point currentScalePoint);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPinchGestureController.SendPinch(class Xamarin.Forms.Element sender, float64 delta, valuetype Xamarin.Forms.Point currentScalePoint) cil managed" />
+ <Member MemberName="SendPinch">
+ <MemberSignature Language="C#" Value="public void SendPinch (Xamarin.Forms.Element sender, double delta, Xamarin.Forms.Point currentScalePoint);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPinch(class Xamarin.Forms.Element sender, float64 delta, valuetype Xamarin.Forms.Point currentScalePoint) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPinchGestureController.SendPinchCanceled">
- <MemberSignature Language="C#" Value="void IPinchGestureController.SendPinchCanceled (Xamarin.Forms.Element sender);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPinchGestureController.SendPinchCanceled(class Xamarin.Forms.Element sender) cil managed" />
+ <Member MemberName="SendPinchCanceled">
+ <MemberSignature Language="C#" Value="public void SendPinchCanceled (Xamarin.Forms.Element sender);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPinchCanceled(class Xamarin.Forms.Element sender) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPinchGestureController.SendPinchEnded">
- <MemberSignature Language="C#" Value="void IPinchGestureController.SendPinchEnded (Xamarin.Forms.Element sender);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPinchGestureController.SendPinchEnded(class Xamarin.Forms.Element sender) cil managed" />
+ <Member MemberName="SendPinchEnded">
+ <MemberSignature Language="C#" Value="public void SendPinchEnded (Xamarin.Forms.Element sender);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPinchEnded(class Xamarin.Forms.Element sender) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IPinchGestureController.SendPinchStarted">
- <MemberSignature Language="C#" Value="void IPinchGestureController.SendPinchStarted (Xamarin.Forms.Element sender, Xamarin.Forms.Point initialScalePoint);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IPinchGestureController.SendPinchStarted(class Xamarin.Forms.Element sender, valuetype Xamarin.Forms.Point initialScalePoint) cil managed" />
+ <Member MemberName="SendPinchStarted">
+ <MemberSignature Language="C#" Value="public void SendPinchStarted (Xamarin.Forms.Element sender, Xamarin.Forms.Point initialScalePoint);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendPinchStarted(class Xamarin.Forms.Element sender, valuetype Xamarin.Forms.Point initialScalePoint) cil managed" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<remarks>This bindable property is read-only.</remarks>
</Docs>
</Member>
+ <Member MemberName="GetScrollPositionForElement">
+ <MemberSignature Language="C#" Value="public Xamarin.Forms.Point GetScrollPositionForElement (Xamarin.Forms.VisualElement item, Xamarin.Forms.ScrollToPosition pos);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance valuetype Xamarin.Forms.Point GetScrollPositionForElement(class Xamarin.Forms.VisualElement item, valuetype Xamarin.Forms.ScrollToPosition pos) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>Xamarin.Forms.Point</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="item" Type="Xamarin.Forms.VisualElement" />
+ <Parameter Name="pos" Type="Xamarin.Forms.ScrollToPosition" />
+ </Parameters>
+ <Docs>
+ <param name="item">To be added.</param>
+ <param name="pos">To be added.</param>
+ <summary>To be added.</summary>
+ <returns>To be added.</returns>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="LayoutChildren">
<MemberSignature Language="C#" Value="protected override void LayoutChildren (double x, double y, double width, double height);" />
<MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void LayoutChildren(float64 x, float64 y, float64 width, float64 height) cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="ScrollToRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.ScrollToRequestedEventArgs> ScrollToRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.ScrollToRequestedEventArgs> ScrollToRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.ScrollToRequestedEventArgs></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="ScrollX">
<MemberSignature Language="C#" Value="public double ScrollX { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance float64 ScrollX" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendScrollFinished">
+ <MemberSignature Language="C#" Value="public void SendScrollFinished ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendScrollFinished() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SetScrolledPosition">
+ <MemberSignature Language="C#" Value="public void SetScrolledPosition (double x, double y);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SetScrolledPosition(float64 x, float64 y) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="x" Type="System.Double" />
+ <Parameter Name="y" Type="System.Double" />
+ </Parameters>
+ <Docs>
+ <param name="x">To be added.</param>
+ <param name="y">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Xamarin.Forms.IScrollViewController.GetScrollPositionForElement">
<MemberSignature Language="C#" Value="Xamarin.Forms.Point IScrollViewController.GetScrollPositionForElement (Xamarin.Forms.VisualElement item, Xamarin.Forms.ScrollToPosition pos);" />
<MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance valuetype Xamarin.Forms.Point Xamarin.Forms.IScrollViewController.GetScrollPositionForElement(class Xamarin.Forms.VisualElement item, valuetype Xamarin.Forms.ScrollToPosition pos) cil managed" />
<AssemblyInfo>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Xamarin.Forms.Point</ReturnType>
<AssemblyInfo>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
<AssemblyInfo>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="OnSearchButtonPressed">
+ <MemberSignature Language="C#" Value="public void OnSearchButtonPressed ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void OnSearchButtonPressed() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Placeholder">
<MemberSignature Language="C#" Value="public string Placeholder { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance string Placeholder" />
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.ISearchBarController.OnSearchButtonPressed">
- <MemberSignature Language="C#" Value="void ISearchBarController.OnSearchButtonPressed ();" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.ISearchBarController.OnSearchButtonPressed() cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters />
- <Docs>
- <summary>This method is for internal use.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="ModelChanged">
+ <MemberSignature Language="C#" Value="public event EventHandler ModelChanged;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler ModelChanged" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="On<T>">
<MemberSignature Language="C#" Value="public Xamarin.Forms.IPlatformElementConfiguration<T,Xamarin.Forms.TableView> On<T> () where T : Xamarin.Forms.IConfigPlatform;" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance class Xamarin.Forms.IPlatformElementConfiguration`2<!!T, class Xamarin.Forms.TableView> On<(class Xamarin.Forms.IConfigPlatform) T>() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="NativeSizeChanged">
+ <MemberSignature Language="C#" Value="public void NativeSizeChanged ();" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void NativeSizeChanged() cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters />
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Navigation">
<MemberSignature Language="C#" Value="public Xamarin.Forms.INavigation Navigation { get; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.INavigation Navigation" />
<AssemblyVersion>1.3.0.0</AssemblyVersion>
<AssemblyVersion>1.4.0.0</AssemblyVersion>
<AssemblyVersion>1.5.0.0</AssemblyVersion>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="EvalRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.Internals.EvalRequested> EvalRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.Internals.EvalRequested> EvalRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler<Xamarin.Forms.Internals.EvalRequested></ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="GoBack">
<MemberSignature Language="C#" Value="public void GoBack ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance void GoBack() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="GoBackRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler GoBackRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler GoBackRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="GoForward">
<MemberSignature Language="C#" Value="public void GoForward ();" />
<MemberSignature Language="ILAsm" Value=".method public hidebysig instance void GoForward() cil managed" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="GoForwardRequested">
+ <MemberSignature Language="C#" Value="public event EventHandler GoForwardRequested;" />
+ <MemberSignature Language="ILAsm" Value=".event class System.EventHandler GoForwardRequested" />
+ <MemberType>Event</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.EventHandler</ReturnType>
+ </ReturnValue>
+ <Docs>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Navigated">
<MemberSignature Language="C#" Value="public event EventHandler<Xamarin.Forms.WebNavigatedEventArgs> Navigated;" />
<MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class Xamarin.Forms.WebNavigatedEventArgs> Navigated" />
<remarks>To be added.</remarks>
</Docs>
</Member>
+ <Member MemberName="SendNavigated">
+ <MemberSignature Language="C#" Value="public void SendNavigated (Xamarin.Forms.WebNavigatedEventArgs args);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendNavigated(class Xamarin.Forms.WebNavigatedEventArgs args) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="args" Type="Xamarin.Forms.WebNavigatedEventArgs" />
+ </Parameters>
+ <Docs>
+ <param name="args">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
+ <Member MemberName="SendNavigating">
+ <MemberSignature Language="C#" Value="public void SendNavigating (Xamarin.Forms.WebNavigatingEventArgs args);" />
+ <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void SendNavigating(class Xamarin.Forms.WebNavigatingEventArgs args) cil managed" />
+ <MemberType>Method</MemberType>
+ <AssemblyInfo>
+ <AssemblyVersion>2.0.0.0</AssemblyVersion>
+ </AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
+ <ReturnValue>
+ <ReturnType>System.Void</ReturnType>
+ </ReturnValue>
+ <Parameters>
+ <Parameter Name="args" Type="Xamarin.Forms.WebNavigatingEventArgs" />
+ </Parameters>
+ <Docs>
+ <param name="args">To be added.</param>
+ <summary>To be added.</summary>
+ <remarks>To be added.</remarks>
+ </Docs>
+ </Member>
<Member MemberName="Source">
<MemberSignature Language="C#" Value="public Xamarin.Forms.WebViewSource Source { get; set; }" />
<MemberSignature Language="ILAsm" Value=".property instance class Xamarin.Forms.WebViewSource Source" />
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<AssemblyInfo>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
+ <Attributes>
+ <Attribute>
+ <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+ </Attribute>
+ </Attributes>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<remarks>To be added.</remarks>
</Docs>
</Member>
- <Member MemberName="Xamarin.Forms.IWebViewController.SendNavigated">
- <MemberSignature Language="C#" Value="void IWebViewController.SendNavigated (Xamarin.Forms.WebNavigatedEventArgs args);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IWebViewController.SendNavigated(class Xamarin.Forms.WebNavigatedEventArgs args) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="args" Type="Xamarin.Forms.WebNavigatedEventArgs" />
- </Parameters>
- <Docs>
- <param name="args">To be added.</param>
- <summary>To be added.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
- <Member MemberName="Xamarin.Forms.IWebViewController.SendNavigating">
- <MemberSignature Language="C#" Value="void IWebViewController.SendNavigating (Xamarin.Forms.WebNavigatingEventArgs args);" />
- <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IWebViewController.SendNavigating(class Xamarin.Forms.WebNavigatingEventArgs args) cil managed" />
- <MemberType>Method</MemberType>
- <AssemblyInfo>
- <AssemblyVersion>2.0.0.0</AssemblyVersion>
- </AssemblyInfo>
- <ReturnValue>
- <ReturnType>System.Void</ReturnType>
- </ReturnValue>
- <Parameters>
- <Parameter Name="args" Type="Xamarin.Forms.WebNavigatingEventArgs" />
- </Parameters>
- <Docs>
- <param name="args">To be added.</param>
- <summary>To be added.</summary>
- <remarks>To be added.</remarks>
- </Docs>
- </Member>
</Members>
</Type>
projects / platform / upstream / xamarin-forms.git / commitdiff