path: root/Xamarin.Forms.Platform.Tizen/Native/ListView.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using ElmSharp;
using EColor = ElmSharp.Color;
using EBox = ElmSharp.Box;

namespace Xamarin.Forms.Platform.Tizen.Native
{
	/// <summary>
	/// Type alias which identifies list of cells whose data model was transformed by Xamarin.
	/// </summary>
	using GroupList = TemplatedItemsList<ItemsView<Cell>, Cell>;

	/// <summary>
	/// Native ListView implementation for Xamarin renderer
	/// </summary>
	/// <remarks> 
	/// This internally uses GenList class.
	/// One should note that it is optimized for displaying many elements which may be
	/// unavailable at first. This means that only currently visible elements will be constructed.
	/// Whenever element disappears from visible space its content is destroyed for time being.
	/// This is carried out by so called Cell Handlers.
	/// </remarks>
	public class ListView : GenList
	{
		/// <summary>
		/// ItemContext helper class. This represents the association between Xamarin.Forms.Cell and
		/// native elements. It also stores useful context for them.
		/// </summary>
		public class ItemContext
		{
			public ItemContext()
			{
				Item = null;
				Cell = null;
				ListOfSubItems = null;
			}

			public GenListItem Item;
			public Cell Cell;
			public bool IsGroupItem;
			internal TemplatedItemsList<ItemsView<Cell>, Cell> ListOfSubItems;
		}

		/// <summary>
		/// The item context list for each added element.
		/// </summary>
		readonly List<ItemContext> _itemContextList = new List<ItemContext>();

		/// <summary>
		/// Registered cell handlers.
		/// </summary>
		protected readonly IDictionary<Type, CellHandler> _cellHandlers = new Dictionary<Type, CellHandler>();

		/// <summary>
		/// Registered group handlers.
		/// </summary>
		protected readonly IDictionary<Type, CellHandler> _groupCellHandlers = new Dictionary<Type, CellHandler>();

		/// <summary>
		/// The header context.
		/// </summary>
		ItemContext _headerContext;

		/// <summary>
		/// The header element.
		/// </summary>
		VisualElement _headerElement;

		/// <summary>
		/// The footer context.
		/// </summary>
		ItemContext _footerContext;

		/// <summary>
		/// The footer element.
		/// </summary>
		VisualElement _footerElement;

		/// <summary>
		/// The item class for header and footer.
		/// </summary>
		GenItemClass _headerFooterItemClass = null;

		/// <summary>
		/// Gets or sets a value indicating whether this instance has grouping enabled.
		/// </summary>
		/// <value><c>true</c> if this instance has grouping enabled.</value>
		public bool IsGroupingEnabled { get; set; }

		/// <summary>
		/// Constructor of ListView native control.
		/// </summary>
		/// <param name="parent">ElmSharp object which is parent of particular list view</param>
		public ListView(EvasObject parent)
			: base(parent)
		{
			_cellHandlers[typeof(TextCell)] = new TextCellHandler();
			_cellHandlers[typeof(ViewCell)] = new ViewCellHandler();
			_cellHandlers[typeof(ImageCell)] = new ImageCellHandler();
			_cellHandlers[typeof(SwitchCell)] = new SwitchCellHandler();
			_cellHandlers[typeof(EntryCell)] = new EntryCellHandler();

			_groupCellHandlers[typeof(TextCell)] = new GroupTextCellHandler();

			ItemRealized += OnItemAppear;
			ItemUnrealized += OnItemDisappear;
		}

		/// <summary>
		/// Gets the item context based on Cell item.
		/// </summary>
		/// <returns>The item context.</returns>
		/// <param name="cell">Cell for which context should be found.</param>
		internal ItemContext GetItemContext(Cell cell)
		{
			if (cell == null)
			{
				return null;
			}
			else
			{
				return _itemContextList.Find(X => X.Cell == cell);
			}
		}

		/// <summary>
		/// Sets the HasUnevenRows property.
		/// </summary>
		/// <param name="hasUnevenRows">If <c>true</c>, the list will allow uneven sizes for its rows.</param>
		public void SetHasUnevenRows(bool hasUnevenRows)
		{
			Homogeneous = !hasUnevenRows;
			UpdateRealizedItems();
		}

		/// <summary>
		/// Adds elements to the list and defines its presentation based on Cell type.
		/// </summary>
		/// <param name="_source">IEnumerable on Cell collection.</param>
		/// <param name="beforeCell">Cell before which new items will be placed. 
		/// Null value may also be passed as this parameter, which results in appending new items to the end.
		/// </param>
		public void AddSource(IEnumerable _source, Cell beforeCell = null)
		{
			foreach (var data in _source)
			{
				if (data is GroupList)
				{
					GroupList groupList = data as GroupList;
					AddGroupItem(groupList, beforeCell);
					foreach (var item in groupList)
					{
						AddItem(item as Cell, groupList.HeaderContent);
					}
				}
				else
				{
					AddItem(data as Cell, null, beforeCell);
				}
			}
		}

		/// <summary>
		/// Deletes all items from a given group.
		/// </summary>
		/// <param name="group">Group of items to be deleted.</param>
		internal void ResetGroup(GroupList group)
		{
			var items = _itemContextList.FindAll(x => x.ListOfSubItems == group && x.Cell != group.HeaderContent);
			foreach (var item in items)
			{
				item.Item?.Delete();
			}
		}

		/// <summary>
		/// Adds items to the group.
		/// </summary>
		/// <param name="itemGroup">Group to which elements will be added.</param>
		/// <param name="newItems">New list items to be added.</param>
		/// <param name="cellBefore">A reference to the Cell already existing in a ListView.
		///  Newly added cells will be put just before this cell.</param>
		public void AddItemsToGroup(IEnumerable itemGroup, IEnumerable newItems, Cell cellBefore = null)
		{
			ItemContext groupCtx = GetItemContext((itemGroup as GroupList)?.HeaderContent);
			if (groupCtx != null)
			{
				foreach (var item in newItems)
				{
					AddItem(item as Cell, groupCtx.Cell, cellBefore);
				}
			}
		}

		/// <summary>
		/// Removes the specified cells.
		/// </summary>
		/// <param name="cells">Cells to be removed.</param>
		public void Remove(IEnumerable cells)
		{
			foreach (var data in cells)
			{
				var group = data as GroupList;
				if (group != null)
				{
					ItemContext groupCtx = GetItemContext(group.HeaderContent);
					Remove(groupCtx.ListOfSubItems);
					groupCtx.Item.Delete();
				}
				else
				{
					ItemContext itemCtx = GetItemContext(data as Cell);
					itemCtx?.Item?.Delete();
				}
			}
		}

		/// <summary>
		/// Scrolls the list to a specified cell.
		/// </summary>
		/// <remarks>
		/// Different scrolling behaviors are also possible. The element may be positioned in the center,
		/// top or bottom of the visible part of the list depending on the value of the <c>position</c> parameter.
		/// </remarks>
		/// <param name="cell">Cell which will be displayed after scrolling .</param>
		/// <param name="position">This will defines scroll to behavior based on ScrollToPosition values.</param>
		/// <param name="animated">If <c>true</c>, scrolling will be animated. Otherwise the cell will be moved instantaneously.</param>
		public void ApplyScrollTo(Cell cell, ScrollToPosition position, bool animated)
		{
			GenListItem item = GetItemContext(cell)?.Item;
			if (item != null)
				this.ScrollTo(item, position.ToNative(), animated);
		}

		/// <summary>
		/// Selects the specified cell.
		/// </summary>
		/// <param name="cell">Cell to be selected.</param>
		public void ApplySelectedItem(Cell cell)
		{
			GenListItem item = GetItemContext(cell)?.Item;
			if (item != null)
				item.IsSelected = true;
		}

		/// <summary>
		/// Sets the header.
		/// </summary>
		/// <param name="header">Header of the list.</param>
		public void SetHeader(VisualElement header)
		{
			if (header == null)
			{
				if (HasHeader())
				{
					RemoveHeader();
				}

				return;
			}

			GenItemClass headerTemplate = GetHeaderFooterItemClass();

			_headerElement = header;
			if (HasHeader())
			{
				FirstItem.UpdateItemClass(headerTemplate, header);
			}
			else
			{
				_headerContext = new ItemContext();
				_headerContext.Item = _itemContextList.Count > 0 ? InsertBefore(headerTemplate, header, FirstItem) : Append(headerTemplate, header);
				_headerContext.Item.SelectionMode = GenListSelectionMode.None;
				_headerContext.Item.Deleted += HeaderDeletedHandler;
				_itemContextList.Insert(0, _headerContext);
			}
		}

		/// <summary>
		/// Sets the footer.
		/// </summary>
		/// <param name="footer">Footer of the list.</param>
		public void SetFooter(VisualElement footer)
		{
			if (footer == null)
			{
				if (HasFooter())
				{
					RemoveFooter();
				}
				return;
			}

			GenItemClass footerTemplate = GetHeaderFooterItemClass();

			_footerElement = footer;
			if (HasFooter())
			{
				_footerContext.Item.UpdateItemClass(footerTemplate, footer);
			}
			else
			{
				_footerContext = new ItemContext();
				_footerContext.Item = Append(footerTemplate, footer);
				_footerContext.Item.SelectionMode = GenListSelectionMode.None;
				_footerContext.Item.Deleted += FooterDeletedHandler;
				_itemContextList.Add(_footerContext);
			}
		}

		/// <summary>
		/// Removes the header.
		/// </summary>
		public void RemoveHeader()
		{
			_itemContextList.Remove(_headerContext);
			_headerContext?.Item?.Delete();
			_headerContext = null;
			_headerElement = null;
		}

		/// <summary>
		/// Removes the footer.
		/// </summary>
		public void RemoveFooter()
		{
			_itemContextList.Remove(_footerContext);
			_footerContext?.Item?.Delete();
			_footerContext = null;
			_footerElement = null;
		}

		/// <summary>
		/// Determines whether this instance has a header.
		/// </summary>
		/// <returns><c>true</c> if the header is present.</returns>
		public bool HasHeader()
		{
			return _headerContext != null;
		}

		/// <summary>
		/// Determines whether this instance has a footer.
		/// </summary>
		/// <returns><c>true</c> if the footer is present.</returns>
		public bool HasFooter()
		{
			return _footerContext != null;
		}

		/// <summary>
		/// Gets the header.
		/// </summary>
		/// <returns>The header.</returns>
		public VisualElement GetHeader()
		{
			return _headerElement;
		}

		/// <summary>
		/// Gets the footer.
		/// </summary>
		/// <returns>The footer.</returns>
		public VisualElement GetFooter()
		{
			return _footerElement;
		}

		/// <summary>
		/// Handles the header deleted event.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="e">Empty argument.</param>
		void HeaderDeletedHandler(object sender, EventArgs e)
		{
			_itemContextList.Remove(_headerContext);
			_headerContext = null;
		}

		/// <summary>
		/// Handles the footer deleted event.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="e">Empty argument.</param>
		void FooterDeletedHandler(object sender, EventArgs e)
		{
			_itemContextList.Remove(_footerContext);
			_footerContext = null;
		}

		/// <summary>
		/// Called every time an object gets realized.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="evt">GenListItemEventArgs.</param>
		void OnItemAppear(object sender, GenListItemEventArgs evt)
		{
			ItemContext itemContext = (evt.Item.Data as ItemContext);

			if (itemContext != null && itemContext.Cell != null)
			{
				(itemContext.Cell as ICellController).SendAppearing();
			}
		}

		/// <summary>
		/// Called every time an object gets unrealized.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="evt">GenListItemEventArgs.</param>
		void OnItemDisappear(object sender, GenListItemEventArgs evt)
		{
			ItemContext itemContext = (evt.Item.Data as ItemContext);
			if (itemContext != null && itemContext.Cell != null)
			{
				(itemContext.Cell as ICellController).SendDisappearing();
				GetCellHandler(itemContext.Cell, itemContext.IsGroupItem)?.HandleUnrealizedView(evt.Item);
			}
		}


		/// <summary>
		/// A convenience shorthand method for derivate classes.
		/// </summary>
		/// <param name="cell">Cell to be added.</param>
		protected void AddCell(Cell cell)
		{
			AddItem(cell);
		}

		/// <summary>
		/// Gets the cell handler for given cell type.
		/// </summary>
		/// <returns>The cell handler.</returns>
		/// <param name="cell">Cell to be added.</param>
		/// <param name="isGroup">If <c>true</c>, then group handlers will be included in the lookup as well.</param>
		CellHandler GetCellHandler(Cell cell, bool isGroup = false)
		{
			Type type = cell.GetType();

			while (true)
			{
				if (isGroup && _groupCellHandlers.ContainsKey(type))
					return _groupCellHandlers[type];

				if (_cellHandlers.ContainsKey(type))
					return _cellHandlers[type];

				type = type.GetTypeInfo().BaseType;
				if (type == null)
					break;
			}

			Log.Error("Cell type is not handled: {0}", cell.GetType());
			throw new ArgumentNullException("Unsupported cell type");
		}

		/// <summary>
		/// Adds the group item. Group item is actually of class GroupList because
		/// group item has sub items (can be zero) which needs to be added.
		/// If beforeCell is not null, new group will be added just before it.
		/// </summary>
		/// <param name="groupList">Group to be added.</param>
		/// <param name="beforeCell">Before cell.</param>
		void AddGroupItem(GroupList groupList, Cell beforeCell = null)
		{
			Cell groupCell = groupList.HeaderContent;
			CellHandler groupHandler = GetCellHandler(groupCell, true);
			ItemContext groupItemContext = new ItemContext();
			groupItemContext.Cell = groupCell;

			if (beforeCell != null)
			{
				GenListItem beforeItem = GetItemContext(beforeCell)?.Item;
				groupItemContext.Item = InsertBefore(groupHandler.Class, groupItemContext, beforeItem, GenListItemType.Group);
			}
			else
			{
				groupItemContext.Item = Append(groupHandler.Class, groupItemContext, GenListItemType.Group);
			}

			groupItemContext.Item.SelectionMode = GenListSelectionMode.None;
			groupItemContext.IsGroupItem = true;

			groupItemContext.ListOfSubItems = groupList;
			groupItemContext.Item.Deleted += ItemDeletedHandler;
			_itemContextList.Add(groupItemContext);
		}

		/// <summary>
		/// Adds the item.
		/// </summary>
		/// <param name="cell">Cell to be added.</param>
		/// <param name="groupCell">Group to which the new item should belong.</param>
		/// <remark>If the value of <c>groupCell</c> is not null, the new item will be put into the requested group. </remark>
		/// <param name="beforeCell">The cell before which the new item should be placed.</param>
		/// <remarks> If the value of <c>beforeCell</c> is not null, the new item will be placed just before the requested cell. </remarks>
		void AddItem(Cell cell, Cell groupCell = null, Cell beforeCell = null)
		{
			CellHandler handler = GetCellHandler(cell);
			GenListItem parentItem = null;

			ItemContext itemContext = new ItemContext();
			itemContext.Cell = cell;

			if (IsGroupingEnabled && groupCell != null)
			{
				var groupContext = GetItemContext(groupCell);
				itemContext.ListOfSubItems = groupContext.ListOfSubItems;
				parentItem = groupContext.Item;
			}

			if (beforeCell != null)
			{
				GenListItem beforeItem = GetItemContext(beforeCell)?.Item;
				itemContext.Item = InsertBefore(handler.Class, itemContext, beforeItem, GenListItemType.Normal, parentItem);
			}
			else
			{
				itemContext.Item = Append(handler.Class, itemContext, GenListItemType.Normal, parentItem);
			}

			itemContext.Item.SelectionMode = GenListSelectionMode.Always;

			cell.PropertyChanged += OnCellPropertyChanged;
			(cell as ICellController).ForceUpdateSizeRequested += OnForceUpdateSizeRequested;
			itemContext.Item.Deleted += ItemDeletedHandler;
			_itemContextList.Add(itemContext);
		}

		/// <summary>
		/// Handles item deleted event.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="e">Empty argument.</param>
		void ItemDeletedHandler(object sender, EventArgs e)
		{
			ItemContext itemContext = (sender as GenListItem).Data as ItemContext;
			if (itemContext.Cell != null)
			{
				itemContext.Cell.PropertyChanged -= OnCellPropertyChanged;
				(itemContext.Cell as ICellController).ForceUpdateSizeRequested -= OnForceUpdateSizeRequested;
			}
			_itemContextList.Remove(itemContext);
		}

		/// <summary>
		/// Invoked whenever the properties of data model change.
		/// </summary>
		/// <param name="sender">Sender of the event.</param>
		/// <param name="e">PropertyChangedEventArgs.</param>
		/// <remarks>
		/// The purpose of this method is to propagate these changes to the presentation layer.
		/// </remarks>
		void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			var cell = sender as Cell;
			var context = GetItemContext(cell);

			GetCellHandler(cell, context.IsGroupItem)?.HandlePropertyChanged(cell, context.Item, e.PropertyName);
		}

		private void OnForceUpdateSizeRequested(object sender, EventArgs e)
		{
			var cell = sender as Cell;
			var itemContext = GetItemContext(cell);
			if (itemContext.Item != null)
				itemContext.Item.Update();
		}

		/// <summary>
		/// Gets the item class used for header and footer cells.
		/// </summary>
		/// <returns>The header and footer item class.</returns>
		GenItemClass GetHeaderFooterItemClass()
		{
			if (_headerFooterItemClass == null)
			{
				_headerFooterItemClass = new GenItemClass("full")
				{
					GetContentHandler = (data, part) =>
					{
						VisualElement element = data as VisualElement;
						var renderer = Platform.GetOrCreateRenderer(element);
						renderer.NativeView.MinimumHeight = (int)element.MinimumHeightRequest;
						return renderer.NativeView;
					}
				};
			}
			return _headerFooterItemClass;
		}

		/// <summary>
		/// Base class for cell handlers.
		/// </summary>
		protected abstract class CellHandler
		{
			/// <summary>
			/// The stored objects ensure that content of list items will live just as long as it is needed and not
			/// being garbage collected since it is necessary by native layer.
			/// </summary>
			readonly IDictionary<object, List<EvasObject>> _storedObjects = new Dictionary<object, List<EvasObject>>();

			/// <summary>
			/// Gets the item class.
			/// </summary>
			/// <value>The item class.</value>
			public GenItemClass Class
			{
				get;
				private set;
			}

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.CellHandler"/> class.
			/// </summary>
			/// <param name="style">A string specifying the style of a CellHandler.</param>
			/// <param name="callType">Call type.</param>
			protected CellHandler(string style, CellCallType callType)
			{
				Class = new GenItemClass(style)
				{
					GetTextHandler = (callType & CellCallType.Text) == CellCallType.Text ? GetTextHandler : (GenItemClass.GetTextDelegate)null,
					GetContentHandler = (callType & CellCallType.Content) == CellCallType.Content ? OnGetContent : (GenItemClass.GetContentDelegate)null,
					DeleteHandler = OnDelete,
				};
			}

			/// <summary>
			/// This indicates handler types used by the item class.
			/// </summary>
			[FlagsAttribute]
			protected enum CellCallType
			{
				Text = 1,
				Content = 2,
				Both = Text | Content
			}

			/// <summary>
			/// Handles the property changed event.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			public void HandlePropertyChanged(Cell cell, GenListItem item, string property)
			{
				OnPropertyChanged(cell, item, property);
			}

			/// <summary>
			/// Handles the unrealized view event.
			/// </summary>
			/// <param name="item">Item which disappeared.</param>
			public void HandleUnrealizedView(GenListItem item)
			{
				RemoveAllEvasObjects(item.Data);
			}

			/// <summary>
			/// Handles the property changed event.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			protected virtual void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				if (property == Cell.IsEnabledProperty.PropertyName)
				{
					item.IsEnabled = cell.IsEnabled;
				}
			}

			/// <summary>
			/// Callback invoked for all the text-based cells.
			/// </summary>
			/// <param name="data">It is Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected virtual Span OnGetText(object data, string part)
			{
				return null;
			}

			/// <summary>
			/// Callback invoked for all non text-based cells.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected virtual EvasObject OnGetContent(object data, string part)
			{
				return null;
			}

			/// <summary>
			/// Handles the deleted event.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance whose content is being disposed of.</param>
			protected virtual void OnDelete(object data)
			{
				RemoveAllEvasObjects(data);
			}

			/// <summary>
			/// Gets the height of the row.
			/// </summary>
			/// <returns>The row height.</returns>
			/// <param name="cell">Cell whose row height is to be calculated.</param>
			protected int GetRowHeight(Cell cell)
			{
				return cell.RenderHeight > 0 ? (int)cell.RenderHeight : FindCellContentHeight(cell);
			}

			private int FindCellContentHeight(Cell cell)
			{
				if (cell is ViewCell)
				{
					var parentWidth = (cell.Parent as VisualElement).Width;
					var view = (cell as ViewCell).View;
					return (int)view.Measure(parentWidth, double.PositiveInfinity).Request.Height;
				}
				else
					return -1;
			}

			/// <summary>
			/// Stores the content parts.
			/// </summary>
			/// <param name="key">Cell which uses the native parts.</param>
			/// <param name="obj">Native elements which are being used to construct given cell.</param>
			protected void StoreEvasObject(object key, EvasObject obj)
			{
				List<EvasObject> list;

				if (!_storedObjects.TryGetValue(key, out list))
				{
					list = new List<EvasObject>();
					_storedObjects.Add(key, list);
				}

				list.Add(obj);
			}

			/// <summary>
			/// Allows the access to the content parts.
			/// </summary>
			/// <returns>Native elements which are being used to construct given cell.</returns>
			/// <param name="key">Cell which uses the native parts.</param>
			protected IReadOnlyList<EvasObject> GetEvasObjects(object key)
			{
				List<EvasObject> list;
				_storedObjects.TryGetValue(key, out list);

				return list;
			}

			/// <summary>
			/// Removes all content parts.
			/// </summary>
			/// <param name="key">Cell which uses the native parts.</param>
			protected void RemoveAllEvasObjects(object key)
			{
				_storedObjects.Remove(key);
			}

			/// <summary>
			/// Handles the GetText callback.
			/// </summary>
			/// <returns>The text handler.</returns>
			/// <param name="data">Xamarin.Forms.Cell from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			string GetTextHandler(object data, string part)
			{
				var span = OnGetText(data, part);
				return span == null ? "" : span.GetMarkupText();
			}
		}

		/// <summary>
		/// View cell handler. It is used to represent custom ViewCells.
		/// </summary>
		protected class ViewCellHandler : CellHandler
		{
			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.ViewCellHandler"/> class.
			/// </summary>
			public ViewCellHandler()
				: base("full", CellCallType.Content)
			{
			}

			/// <summary>
			/// Handles changes of properties.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			protected override void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				if (property == "View")
				{
					item.Update();
				}
				else
				{
					base.OnPropertyChanged(cell, item, property);
				}
			}

			/// <summary>
			/// Callback creating content for ViewCell.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override EvasObject OnGetContent(object data, string part)
			{
				if (part == "elm.swallow.content")
				{
					var cell = ((data as ItemContext)?.Cell as ViewCell);
					if (cell != null)
					{
						var renderer = Platform.GetOrCreateRenderer(cell.View);

						renderer.NativeView.MinimumHeight = GetRowHeight(cell);
						return renderer.NativeView;
					}
					return null;
				}
				else
				{
					return null;
				}
			}
		}

		/// <summary>
		/// Base class for custom text-based cells' handlers.
		/// </summary>
		protected abstract class TextHandler : CellHandler
		{
			/// <summary>
			/// The default text color.
			/// </summary>
			static readonly EColor s_defaultTextColor = EColor.Black;

			/// <summary>
			/// Holds formatted text.
			/// </summary>
			readonly Span _span = new Span();

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.TextHandler"/> class.
			/// </summary>
			/// <param name="style">Specifies the style of a TextHandler.</param>
			/// <param name="callType">Describes the set of callbacks supported by the handler.</param>
			protected TextHandler(string style, CellCallType callType)
				: base(style, callType)
			{
			}

			/// <summary>
			/// Creates a Span object containing formatted text corresponding to the one passed as a parameter.
			/// </summary>
			/// <returns>Span object containing the formatted text.</returns>
			/// <param name="text">Raw text.</param>
			protected Span GetSpan(string text)
			{
				return GetSpan(text, Xamarin.Forms.Color.Default);
			}

			/// <summary>
			/// Creates a Span object containing formatted text corresponding to the one passed as a parameter.
			/// The formatting includes the specified color.
			/// </summary>
			/// <returns>The span.</returns>
			/// <param name="text">Raw text.</param>
			/// <param name="color">Text color.</param>
			protected Span GetSpan(string text, Color color)
			{
				_span.Text = text;
				_span.ForegroundColor = color.IsDefault ? s_defaultTextColor : color.ToNative();

				return _span;
			}
		}

		/// <summary>
		/// Group text cell handler.
		/// </summary>
		protected class GroupTextCellHandler : TextCellHandler
		{
			const string _detailPart = "elm.text.end";

			public GroupTextCellHandler() : base("group_index", detailPart : _detailPart)
			{
			}
		}

		/// <summary>
		/// Text cell handler. This is used for representing TextCell.
		/// </summary>
		protected class TextCellHandler : TextHandler
		{
			/// <summary>
			/// EDJ hardcoded internals.
			/// </summary>
			const string _textPart = "elm.text";
			readonly string _detailPart;

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.TextCellHandler"/> class.
			/// </summary>
			public TextCellHandler()
				: this("double_label")
			{
			}

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.TextCellHandler"/> class.
			/// </summary>
			/// <param name="style">Specifies the style of a TextCellHandler.</param>
			/// <param name="calltype">Describes the set of callbacks supported by this handler.</param>
			/// <param name="detailPart">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected TextCellHandler(string style, CellCallType calltype = CellCallType.Text, string detailPart = "elm.text.sub")
				: base(style, calltype)
			{
				_detailPart = detailPart;
			}

			/// <summary>
			/// Handles properties change.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by cell.</param>
			protected override void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				if (property == TextCell.TextProperty.PropertyName ||
					property == TextCell.TextColorProperty.PropertyName ||
					property == TextCell.DetailProperty.PropertyName ||
					property == TextCell.DetailColorProperty.PropertyName)
				{
					item.Update();
				}
				else
				{
					base.OnPropertyChanged(cell, item, property);
				}
			}

			/// <summary>
			/// Callback invoked for all text-based cells.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override Span OnGetText(object data, string part)
			{
				var context = (ItemContext)data;
				var cell = (TextCell)(context.Cell);

				if (part == _textPart)
				{
					return GetSpan(cell.Text, cell.TextColor);
				}
				else if (part == _detailPart)
				{
					return GetSpan(cell.Detail, cell.DetailColor);
				}
				else
				{
					return null;
				}
			}
		}

		/// <summary>
		/// The cell with an image widget.
		/// </summary>
		protected class ImageCellHandler : TextCellHandler
		{
			/// <summary>
			/// The default height.
			/// </summary>
			const int _defaultHeight = 100;

			/// <summary>
			/// EDJ hardcoded internals.
			/// </summary>
			const string _imagePart = "elm.swallow.icon";

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.ImageCellHandler"/> class.
			/// </summary>
			public ImageCellHandler()
				: base("type1", CellCallType.Both)
			{
			}

			/// <summary>
			/// Handles properties change.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			protected override void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				if (property == ImageCell.ImageSourceProperty.PropertyName)
				{
					GetImage(item.Data)?.LoadFromImageSourceAsync((cell as ImageCell)?.ImageSource);
				}
				else
				{
					base.OnPropertyChanged(cell, item, property);
				}
			}

			/// <summary>
			/// Callback for the non-text-based cells.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override EvasObject OnGetContent(object data, string part)
			{
				if (part == _imagePart)
				{
					var cell = (data as ItemContext)?.Cell as ImageCell;
					RemoveAllEvasObjects(data);
					var size = GetRowHeight(cell);

					if (size <= 0)
					{
						size = _defaultHeight;
					}

					var image = new Image(Forms.Context.MainWindow)
					{
						MinimumWidth = size,
						MinimumHeight = size
					};
					image.SetAlignment(-1.0, -1.0); // fill
					image.SetWeight(1.0, 1.0); // expand

					image.LoadFromImageSourceAsync(cell.ImageSource);

					StoreEvasObject(data, image);

					return image;
				}
				else
				{
					return null;
				}
			}

			/// <summary>
			/// Gets the image.
			/// </summary>
			/// <returns>The image.</returns>
			/// <param name="data">Xamarin.Forms.Cell from which image will be accessed.</param>
			Image GetImage(object data)
			{
				IReadOnlyList<EvasObject> list = GetEvasObjects(data);
				return list == null ? null : list[0] as Image;
			}
		}

		/// <summary>
		/// The cell with a switch widget.
		/// </summary>
		protected class SwitchCellHandler : TextHandler
		{
			/// <summary>
			/// Hard coded EDJ internals.
			/// </summary>
			const string _textPart = "elm.text";

			/// <summary>
			/// Initializes a new instance of the <see cref="Xamarin.Forms.Platform.Tizen.Native.ListView.SwitchCellHandler"/> class.
			/// </summary>
			public SwitchCellHandler()
				: base("end_icon", CellCallType.Both)
			{
			}

			/// <summary>
			/// Handles properties change.
			/// </summary>
			/// <param name="cell">The cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			protected override void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				if (property == SwitchCell.TextProperty.PropertyName)
				{
					item.Update();
				}
				else if (property == SwitchCell.OnProperty.PropertyName)
				{
					var checkbox = GetCheckbox(item.Data);
					if (checkbox != null)
					{
						checkbox.IsChecked = (cell as SwitchCell).On;
					}
				}
				else
				{
					base.OnPropertyChanged(cell, item, property);
				}
			}

			/// <summary>
			/// Callback invoked for every text-based cell.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override Span OnGetText(object data, string part)
			{
				var cell = (data as ItemContext)?.Cell;
				if (part == _textPart && cell != null)
				{
					return GetSpan((cell as SwitchCell)?.Text);
				}
				else
				{
					return null;
				}
			}

			/// <summary>
			/// Callback invoked for every non text-based cell.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Describes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override EvasObject OnGetContent(object data, string part)
			{
				if (part == "elm.swallow.end")
				{
					RemoveAllEvasObjects(data);

					var cell = (data as ItemContext)?.Cell as SwitchCell;
					var checkbox = new Check(Forms.Context.MainWindow)
					{
						Style = "on&off",
						IsChecked = cell.On,
					};

					checkbox.StateChanged += (sender, e) =>
					{
						cell.On = e.NewState;
					};

					checkbox.SetAlignment(-1.0, -1.0);  // fill
					checkbox.SetWeight(1.0, 1.0);  // expand

					StoreEvasObject(data, checkbox);

					return checkbox;
				}
				else
				{
					return null;
				}
			}

			/// <summary>
			/// Returns the Check element associated with the specified Cell.
			/// </summary>
			/// <returns>The checkbox.</returns>
			/// <param name="data">Xamarin.Forms.Cell instance from which the Check element will be accessed.</param>
			Check GetCheckbox(object data)
			{
				IReadOnlyList<EvasObject> list = GetEvasObjects(data);
				return list == null ? null : list[0] as Check;
			}
		}

		/// <summary>
		/// The cell with an Entry widget.
		/// </summary>
		protected class EntryCellHandler : ViewCellHandler
		{
			/// <summary>
			/// The default text color.
			/// </summary>
			static readonly EColor s_defaultTextColor = EColor.Black;

			/// <summary>
			/// The default height.
			/// </summary>
			const int _defaultHeight = 120;

			/// <summary>
			/// Handles the changing of Cell's properties.
			/// </summary>
			/// <param name="cell">The Cell whose property changed event will be handled.</param>
			/// <param name="item">The native item to which the property change event will be propagated.</param>
			/// <param name="property">Bindable property name supported by the cell.</param>
			protected override void OnPropertyChanged(Cell cell, GenListItem item, string property)
			{
				var entryCell = cell as EntryCell;

				if (property == EntryCell.HorizontalTextAlignmentProperty.PropertyName)
				{
					var entry = GetEntry(item.Data);
					if (entry != null)
					{
						entry.HorizontalTextAlignment = entryCell.HorizontalTextAlignment.ToNative();
					}
				}
				else if (property == EntryCell.KeyboardProperty.PropertyName)
				{
					var entry = GetEntry(item.Data);
					if (entry != null)
					{
						entry.Keyboard = entryCell.Keyboard.ToNative();
					}
				}
				else if (property == EntryCell.PlaceholderProperty.PropertyName)
				{
					var entry = GetEntry(item.Data);
					if (entry != null)
					{
						entry.Placeholder = entryCell.Placeholder;
					}
				}
				else if (property == EntryCell.TextProperty.PropertyName)
				{
					var entry = GetEntry(item.Data);
					if (entry != null)
					{
						entry.Text = entryCell.Text;
					}
				}
				else if (property == EntryCell.LabelProperty.PropertyName)
				{
					var label = GetLabel(item.Data);
					if (label != null)
					{
						label.Text = entryCell.Label;
					}
				}
				else if (property == EntryCell.LabelColorProperty.PropertyName)
				{
					var label = GetLabel(item.Data);
					if (label != null)
					{
						label.TextColor = GetLabelColor(entryCell);
					}
				}
				else
				{
					base.OnPropertyChanged(cell, item, property);
				}
			}

			/// <summary>
			/// This is callback for each non text-based cells.
			/// </summary>
			/// <param name="data">Xamarin.Forms.Cell instance from which the content will be created.</param>
			/// <param name="part">Ddescribes the exact place in the layout (defined in edj files) where content will be added.</param>
			protected override EvasObject OnGetContent(object data, string part)
			{
				if (part == "elm.swallow.content")
				{
					RemoveAllEvasObjects(data);

					var cell = (data as ItemContext)?.Cell as EntryCell;
					var height = GetRowHeight(cell);
					if (height <= 0)
					{
						height = _defaultHeight;
					}

					var box = new EBox(Forms.Context.MainWindow)
					{
						IsHorizontal = true,
						MinimumHeight = height,
					};
					box.SetAlignment(-1.0, -1.0);  // fill
					box.SetWeight(1.0, 1.0);  // expand

					var label = new Label(box)
					{
						Text = cell.Label,
						TextColor = GetLabelColor(cell),
					};
					label.SetAlignment(0.0, 0.5);
					label.SetWeight(0.0, 1.0);

					var entry = new Entry(box)
					{
						IsSingleLine = true,
						Text = cell.Text,
						TextColor = s_defaultTextColor,
						Placeholder = cell.Placeholder,
						PlaceholderColor = s_defaultTextColor,
						Keyboard = cell.Keyboard.ToNative(),
						HorizontalTextAlignment = cell.HorizontalTextAlignment.ToNative(),
					};
					entry.SetAlignment(-1.0, 0.5);
					entry.SetWeight(1.0, 1.0);

					box.PackEnd(label);
					box.PackEnd(entry);

					label.Show();
					entry.Show();

					entry.TextChanged += (sender, e) =>
					{
						cell.Text = e.NewTextValue;
					};
					entry.Activated += (sender, e) =>
					{
						(cell as IEntryCellController).SendCompleted();
					};

					StoreEvasObject(data, box);
					StoreEvasObject(data, label);
					StoreEvasObject(data, entry);

					return box;
				}
				else
				{
					return null;
				}
			}

			/// <summary>
			/// Gets the color of the label.
			/// </summary>
			/// <returns>The label color.</returns>
			/// <param name="cell">Xamarin.Forms.Cell from which label color will be accessed.</param>
			EColor GetLabelColor(EntryCell cell)
			{
				return cell.LabelColor.IsDefault ? s_defaultTextColor : cell.LabelColor.ToNative();
			}

			/// <summary>
			/// Gets the label.
			/// </summary>
			/// <returns>The label.</returns>
			/// <param name="data">Xamarin.Forms.Cell from which label will be accessed.</param>
			Native.Label GetLabel(object data)
			{
				IReadOnlyList<EvasObject> list = GetEvasObjects(data);
				return list == null ? null : list[1] as Native.Label;
			}

			/// <summary>
			/// Gets the entry.
			/// </summary>
			/// <returns>The entry.</returns>
			/// <param name="data">Xamarin.Forms.Cell from which entry will be accessed.</param>
			Native.Entry GetEntry(object data)
			{
				IReadOnlyList<EvasObject> list = GetEvasObjects(data);
				return list == null ? null : list[2] as Native.Entry;
			}
		}
	}
}