/// <summary>
        /// Remove an item from the <see cref="IPagedDataSet"/> with the specified position
        /// </summary>
        /// <param name="dataSet">The dataset to modify</param>
        /// <param name="offset">The position to remove relative to the dataset's caret</param>
        /// <returns></returns>
        public static async Task RemoveAtOffset(this IRemovable removable, IPagedDataSet dataSet, int offset)
        {
            var pi = await dataSet.GetCurrentPageIndex();

            var ps = await dataSet.GetPageSize();

            var sel = await dataSet.GetSelector();

            if (sel == null)
            {
                throw new InvalidOperationException("The paged data set does not support selecting items that is required for this method to work");
            }

            await removable.RemoveAt(dataSet, pi *ps + offset + await sel.GetCaretPosition());
        }
        /// <summary>
        /// Add an item into the <see cref="IPagedDataSet"/> with the position relative to the <see cref="ISelectable"/>'s caret
        /// </summary>
        /// <param name="addable">The adder to perform</param>
        /// <param name="item">The item to add</param>
        /// <param name="dataSet">the dataset to modify</param>
        /// <param name="offset">The position to add relative to the <see cref="IPagedDataSet{TItem, TResult}"/> caret</param>
        /// <returns></returns>
        public static async Task AddOffset(this IAddable addable, IPagedDataSet dataSet, object item, int offset)
        {
            var selector = await dataSet.GetSelector();

            if (selector == null)
            {
                throw new InvalidOperationException("PagedDataSet must support selector to use this function!");
            }
            var pi = await dataSet.GetCurrentPageIndex();

            var ps = await dataSet.GetPageSize();

            var caret = await selector.GetCaretPosition();

            await addable.Add(item, pi *ps + caret + offset);
        }
 /// <summary>
 /// Add an item into the <see cref="IPagedDataSet{TItem, TResult}"/> with the position relative to the <see cref="ISelectable{TItem}"/>'s caret
 /// </summary>
 /// <param name="addable">The adder to perform</param>
 /// <param name="item">The item to add</param>
 /// <param name="dataSet">the dataset to modify</param>
 /// <param name="offset">The position to add relative to the <see cref="IPagedDataSet{TItem, TResult}"/> caret</param>
 /// <returns></returns>
 public static Task AddOffset <TItem>(this IAddable <TItem> addable, IPagedDataSet dataSet, TItem item, int offset) where TItem : class
 => AddOffset(addable, dataSet, item, offset);
Beispiel #4
0
        // TODO: BIGTODO Find a better way to move through pages. This is a very smelly code!
        /// <summary>
        /// Jump the caret to a new position
        /// </summary>
        /// <param name="offset">the number of item to jump. A positive value will jump forward, a negative value will jump backward</param>
        /// <param name="dataSet">The data set to move caret</param>
        /// <param name="throughPage">should overflow offset move to a new page</param>
        /// <returns></returns>
        public static async Task MoveCaretBy(this ISelectable selectable, IPagedDataSet dataSet, int offset, bool throughPage = false)
        {
            if (throughPage)
            {
                var pageCount = await dataSet.GetPageCount();

                if (offset > 0)
                {
                    var tempCaret = await selectable.GetCaretPosition();

                    var tempPageIndex = await dataSet.GetCurrentPageIndex();

                    var currentPageSize = (await dataSet.GetPageItems()).Count();
                    if (currentPageSize == 0)
                    {
                        return;
                    }
                    if (currentPageSize - tempCaret - offset <= 0)
                    {
                        offset       -= currentPageSize - tempCaret;
                        tempPageIndex = (tempPageIndex + 1).NormalizeIndex(pageCount);
                    }
                    else
                    {
                        await selectable.SetCaretPosition(tempCaret + offset);

                        return;
                    }

                    while (true)
                    {
                        await dataSet.SetCurrentPageIndex(tempPageIndex);

                        currentPageSize = (await dataSet.GetPageItems()).Count();
                        if (offset - currentPageSize >= 0)
                        {
                            offset       -= currentPageSize;
                            tempPageIndex = (tempPageIndex + 1).NormalizeIndex(pageCount);
                        }
                        else
                        {
                            break;
                        }
                    }
                    await dataSet.SetCurrentPageIndex(tempPageIndex);

                    await selectable.SetCaretPosition(offset);
                }
                else
                {
                    var tempCaret = await selectable.GetCaretPosition();

                    var tempPageIndex = await dataSet.GetCurrentPageIndex();

                    int currentPageSize;
                    if (tempCaret + offset < 0)
                    {
                        offset        = Math.Abs(offset) - tempCaret - 1;
                        tempPageIndex = (tempPageIndex - 1).NormalizeIndex(pageCount);
                        await dataSet.SetCurrentPageIndex(tempPageIndex);

                        currentPageSize = (await dataSet.GetPageItems()).Count();
                        if (currentPageSize == 0)
                        {
                            return;
                        }
                        tempCaret = currentPageSize - 1;
                    }
                    else
                    {
                        await selectable.SetCaretPosition(tempCaret + offset);

                        return;
                    }

                    while (true)
                    {
                        if (offset - currentPageSize >= 0)
                        {
                            offset       -= currentPageSize;
                            tempPageIndex = (tempPageIndex - 1).NormalizeIndex(pageCount);
                            await dataSet.SetCurrentPageIndex(tempPageIndex);

                            currentPageSize = (await dataSet.GetPageItems()).Count();
                            tempCaret       = currentPageSize - 1;
                        }
                        else
                        {
                            break;
                        }
                    }

                    await selectable.SetCaretPosition(tempCaret - offset);
                }
            }
            else
            {
                await selectable.SetCaretPosition(await selectable.GetCaretPosition() + offset);
            }
        }
Beispiel #5
0
        public static Task MovePagedDataSetOffset(this IPaginatorController pie, IPagedDataSet pd, int offset)
        {
            var index = pie.IndexOf(pd);

            return(pie.MovePagedDataSet(pd, index != -1 ? index + offset : offset));
        }
 public StringPageContentGenerator(IPagedDataSet <TItem, string> pagedDataSet)
 {
     PagedDataSet = pagedDataSet;
 }
Beispiel #7
0
 public Selectable(IPagedDataSet <TItem, TResult> pagedDataSet)
 {
     PagedDataSet = pagedDataSet;
 }
Beispiel #8
0
 /// <summary>
 /// Move item to the last position in the <see cref="IPagedDataSet"/>
 /// </summary>
 /// <param name="dataSet">the dataset to move item</param>
 /// <param name="item">The item to move</param>
 /// <returns></returns>
 public static async Task MoveToLast(this IMovable movable, IPagedDataSet dataSet, object item)
 => await movable.Move(item, (await dataSet.GetDataSource()).Count() - 1);
Beispiel #9
0
 /// <summary>
 /// Move item to the first position in the <see cref="IPagedDataSet"/>
 /// </summary>
 /// <param name="dataSet">the dataset to move item</param>
 /// <param name="item">The item to move</param>
 /// <returns></returns>
 public static async Task MoveToTop(this IMovable movable, IPagedDataSet dataSet, object item)
 => await movable.Move(item, 0);
Beispiel #10
0
 /// <summary>
 /// Move a item into a new position relative to the current position in the <see cref="IPagedDataSet"/>
 /// </summary>
 /// <param name="dataSet">the dataset to move item</param>
 /// <param name="item">The item to move</param>
 /// <param name="offset">a new position relative to the current item position</param>
 /// <returns></returns>
 public static async Task MoveOffset(this IMovable movable, IPagedDataSet dataSet, object item, int offset)
 => await movable.Move(item, (await dataSet.GetDataSource()).FindIndex(item) + offset);
Beispiel #11
0
 /// <summary>
 /// Move item to the last position in the <see cref="IPagedDataSet{TItem, TResult}"/>
 /// </summary>
 /// <param name="dataSet">the dataset to move item</param>
 /// <param name="item">The item to move</param>
 /// <returns></returns>
 public static async Task MoveToLast <TItem>(this IMovable <TItem> movable, IPagedDataSet dataSet, TItem item)
 => await movable.MoveToLast(dataSet, item);
Beispiel #12
0
 /// <summary>
 /// Move a item into a new position relative to the current position in the <see cref="IPagedDataSet{TItem, TResult}"/>
 /// </summary>
 /// <param name="dataSet">the dataset to move item</param>
 /// <param name="item">The item to move</param>
 /// <param name="offset">a new position relative to the current item position</param>
 /// <returns></returns>
 public static async Task MoveOffset <TItem>(this IMovable <TItem> movable, IPagedDataSet dataSet, TItem item, int offset)
 => await movable.MoveOffset(dataSet, item, offset);
 public Movable(IPagedDataSet <TItem, TResult> pagedDataSet)
 {
     PagedDataSet = pagedDataSet;
 }
Beispiel #14
0
        static async Task OldTestCode(IPagedDataSet eventPd)
        {
            while (true)
            {
                Console.Clear();
                var t = await eventPd.GetPageContent();

                Console.WriteLine($"Header: {await t.GetHeader()}");
                Console.WriteLine($"Content: {await t.GetContent()}");

                Console.Write("Command: ");
                var input = Console.ReadKey(true);
                if (input.Key == ConsoleKey.RightArrow)
                {
                    await eventPd.MovePageBy(1);
                }
                else if (input.Key == ConsoleKey.LeftArrow)
                {
                    await eventPd.MovePageBy(-1);
                }
                else if (input.Key == ConsoleKey.DownArrow)
                {
                    await(await eventPd.GetSelector()).MoveCaretBy(eventPd, 1, true);
                }
                else if (input.Key == ConsoleKey.UpArrow)
                {
                    await(await eventPd.GetSelector()).MoveCaretBy(eventPd, -1, true);
                }
                else if (input.Key == ConsoleKey.Spacebar)
                {
                    await(await eventPd.GetSelector()).SetSelectedItem("20");
                }
                else if (input.Key == ConsoleKey.A)
                {
                    await(await eventPd.GetAdder()).AddOffset(eventPd, $"{DateTime.Now}", 0);
                }
                else if (input.Key == ConsoleKey.D)
                {
                    await(await eventPd.GetAdder()).Add($"{DateTime.Now}", 0);
                }
                else if (input.Key == ConsoleKey.X)
                {
                    await(await eventPd.GetRemover()).RemoveAtOffset(eventPd, 0);
                }
                else if (input.Key == ConsoleKey.Z)
                {
                    await(await eventPd.GetRemover()).RemoveAt(eventPd, 0);
                }
                else if (input.Key == ConsoleKey.B)
                {
                    await(await eventPd.GetRemover()).Remove("20");
                }
                else if (input.Key == ConsoleKey.W)
                {
                    await(await eventPd.GetMover()).MoveOffset(eventPd, await(await eventPd.GetSelector()).GetSelectedItem(), -1);
                    await(await eventPd.GetSelector()).MoveCaretBy(eventPd, -1);
                }
                else if (input.Key == ConsoleKey.Q)
                {
                    await(await eventPd.GetMover()).MoveToTop(eventPd, await(await eventPd.GetSelector()).GetSelectedItem());
                    await(await eventPd.GetSelector()).SetCaretPosition(0);
                    await eventPd.SetCurrentPageIndex(0);
                }
                else if (input.Key == ConsoleKey.E)
                {
                    await(await eventPd.GetMover()).MoveToLast(eventPd, await(await eventPd.GetSelector()).GetSelectedItem());
                    await eventPd.SetCurrentPageIndex(await eventPd.GetPageCount() - 1);

                    await(await eventPd.GetSelector()).SetCaretPosition((await eventPd.GetPageItems()).Count() - 1);
                }
                else if (input.Key == ConsoleKey.S)
                {
                    await(await eventPd.GetMover()).MoveOffset(eventPd, await(await eventPd.GetSelector()).GetSelectedItem(), 1);
                    await(await eventPd.GetSelector()).MoveCaretBy(eventPd, 1);
                }
                else if (input.Key == ConsoleKey.Escape)
                {
                    break;
                }
            }
        }
 /// <summary>
 /// Remove an item from the <see cref="IPagedDataSet"/> with the specified position
 /// </summary>
 /// <param name="dataSet">The dataset to modify</param>
 /// <param name="index">The position to remove</param>
 /// <returns></returns>
 public static async Task RemoveAt(this IRemovable removable, IPagedDataSet dataSet, int index)
 => await removable.Remove((await dataSet.GetDataSource()).ElementAtOrDefault(index));