Beispiel #1
0
        public Pagina(PaginaHijo _link = null)
        {
            Effect = Estilos.shadow;

            nodos = new List <Nodo>();
            hijos = new List <PaginaHijo>();
            link  = _link;
        }
Beispiel #2
0
        private async Task catenation()
        {
            if (nodos.Count >= BTree.D)
            {
                return;
            }

            if (PaginaPadre == null)
            {
                if (nodos.Count > 0)
                {
                    return;
                }

                var parent = (Canvas)Parent;

                if (hijos.Count == 0 || hijos[0].pagina == null)
                {
                    Children.Clear();
                    hijos.Clear();
                    return;
                }

                var nRoot    = hijos[0].pagina;
                var pocision = nRoot.TransformToVisual(parent).Transform(new Point(0, 0));
                Canvas.SetLeft(nRoot, pocision.X);
                Canvas.SetTop(nRoot, pocision.Y);
                parent.Children.Remove(this);
                this.Children.Remove(nRoot);
                nRoot.link = null;
                parent.Children.Add(nRoot);

                return;
            }

            int lIndex = link.puntero.Indice, rIndex = lIndex + 1;

            if (rIndex == PaginaPadre.hijos.Count)
            {
                rIndex = lIndex;
                lIndex = rIndex - 1;
            }

            PaginaHijo lHijo = PaginaPadre.hijos[lIndex], rHijo = PaginaPadre.hijos[rIndex];
            Nodo       mitadNodo = PaginaPadre.nodos[lIndex];

            var tarea = new List <Task>();

            tarea.Add(eliminar(mitadNodo, mitadNodo.Indice, true));

            mitadNodo.Indice      = lHijo.pagina.nodos.Count;
            mitadNodo.PaginaPadre = lHijo.pagina;
            lHijo.pagina.nodos.Add(mitadNodo);

            foreach (var nodo in rHijo.pagina.nodos)
            {
                nodo.Indice     += lHijo.pagina.nodos.Count;
                nodo.PaginaPadre = lHijo.pagina;
            }

            foreach (var hijo in rHijo.pagina.hijos)
            {
                hijo.puntero.Indice += lHijo.pagina.hijos.Count;
                hijo.PaginaPadre     = lHijo.pagina;
            }

            lHijo.pagina.nodos.AddRange(rHijo.pagina.nodos);
            lHijo.pagina.hijos.AddRange(rHijo.pagina.hijos);

            rHijo.pagina.nodos.Clear();
            rHijo.pagina.hijos.Clear();

            PaginaPadre.actualizarJerarquia();
            tarea.Add(lHijo.pagina.actualizarElementosVista(true));
            await Task.WhenAll(tarea);

            PaginaPadre.hijos.Remove(rHijo);
            PaginaPadre.Children.Remove(rHijo.pagina);

            await lHijo.pagina.dividir();

            await PaginaPadre.catenation();
        }
Beispiel #3
0
        public async Task dividir()
        {
            if (nodos.Count() <= BTree.D)
            {
                return;
            }

            Pagina     iPagina = PaginaPadre == null ? this : PaginaPadre;
            PaginaHijo lHijo = new PaginaHijo(iPagina), rHijo = new PaginaHijo(iPagina);
            Pagina     lPagina = new Pagina(lHijo), rPagina = new Pagina(rHijo);

            int     mitad     = nodos.Count / 2;
            Nodo    mitadNodo = nodos[mitad];
            Puntero lPointer  = new Puntero(mitad)
            {
                PaginaPadre = iPagina
            }, rPointer = new Puntero(mitad + 1)
            {
                PaginaPadre = iPagina
            };
            await lPointer.actualizar(); await rPointer.actualizar();

            for (int i = 0; i < mitad; i++)
            {
                lPagina.nodos.Add(nodos[i]);
                nodos[i].PaginaPadre = lPagina;

                lPagina.hijos.Add(hijos[i]);
                hijos[i].paginaPadre         = lPagina;
                hijos[i].puntero.PaginaPadre = lPagina;
            }
            lPagina.hijos.Add(hijos[mitad]);
            hijos[mitad].paginaPadre         = lPagina;
            hijos[mitad].puntero.PaginaPadre = lPagina;

            for (int i = mitad + 1; i < nodos.Count; i++)
            {
                rPagina.nodos.Add(nodos[i]);
                nodos[i].PaginaPadre = rPagina;

                rPagina.hijos.Add(hijos[i]);
                hijos[i].paginaPadre         = rPagina;
                hijos[i].puntero.PaginaPadre = rPagina;

                nodos[i].Indice         = i - mitad - 1;
                hijos[i].puntero.Indice = i - mitad - 1;
            }
            rPagina.hijos.Add(hijos.Last());
            hijos.Last().paginaPadre = rPagina;
            hijos.Last().puntero.PaginaPadre = rPagina;
            hijos.Last().puntero.Indice = hijos.Count - mitad - 2;

            lHijo.pagina = lPagina;
            rHijo.pagina = rPagina;

            rHijo.pagina.MouseDown += (s, e) => { };

            lHijo.puntero = lPointer;
            rHijo.puntero = rPointer;

            nodos.Clear();
            hijos.Clear();

            if (PaginaPadre == null)
            {
                mitadNodo.Indice = 0;
                iPagina.nodos.Add(mitadNodo);
                lPointer.Indice = 0;
                rPointer.Indice = 1;
                iPagina.hijos.Add(lHijo);
                iPagina.hijos.Add(rHijo);

                iPagina.actualizarJerarquia();
                await Task.WhenAll(iPagina.actualizarElementosVista(true),
                                   lPagina.actualizarElementosVista(true),
                                   rPagina.actualizarElementosVista(true),
                                   iPagina.reajustarPocision(true));
            }
            else
            {
                await iPagina.Insertar_Nodo(mitadNodo, lHijo, rHijo);

                iPagina.UpdateLayout();
                iPagina.actualizarJerarquia();
                await Task.WhenAll(iPagina.reajustarPocision(true),
                                   lPagina.actualizarElementosVista(true),
                                   rPagina.actualizarElementosVista(true));

                if (PaginaPadre != null)
                {
                    ((Canvas)Parent).Children.Remove(this);
                }
            }
            await iPagina.dividir();
        }
Beispiel #4
0
        public async Task Insertar_Nodo(Nodo nodo, PaginaHijo previo = null, PaginaHijo siguiente = null)
        {
            int valor = nodo.Value;

            Puntero pizquierdo, pderecho;

            if (previo == null)
            {
                pizquierdo = new Puntero(0);
                pderecho   = new Puntero(1);
                previo     = new PaginaHijo(this)
                {
                    puntero = pizquierdo
                };
                siguiente = new PaginaHijo(this)
                {
                    puntero = pderecho
                };
            }
            else
            {
                pizquierdo = previo.puntero;
                pderecho   = siguiente.puntero;
            }

            previo.paginaPadre = siguiente.paginaPadre = nodo.PaginaPadre = pizquierdo.PaginaPadre = pderecho.PaginaPadre = this;

            if (nodos.Count() == 0)
            {
                foreach (var hijo in hijos)
                {
                    Children.Remove(hijo.puntero);
                }
                hijos.Clear();

                UpdateLayout();

                nodo.Indice       = 0;
                pizquierdo.Indice = 0;
                pderecho.Indice   = 1;

                nodos.Add(nodo);
                hijos.Add(previo);
                hijos.Add(siguiente);

                await Task.WhenAll(reajustarPocision(true), actualizarElementosVista());
            }
            else
            {
                int i = 0;
                for (i = 0; i < nodos.Count(); i++)
                {
                    if (nodos[i].Value >= valor)
                    {
                        break;
                    }
                }
                nodo.Indice       = i;
                pizquierdo.Indice = i;
                pderecho.Indice   = i + 1;

                if (i < nodos.Count())
                {
                    if (nodos[i].Value == valor)
                    {
                        return;
                    }

                    Children.Remove(hijos[i].puntero);
                    hijos[i] = siguiente;
                    pderecho.Indice--;
                    await Task.WhenAll(pizquierdo.actualizar(), pderecho.actualizar());

                    List <Task> tarea = new List <Task>();

                    for (int j = i; j < nodos.Count(); j++)
                    {
                        tarea.Add(nodos[j].incrementoProgreso(1));
                        tarea.Add(hijos[j].puntero.incrementoProgreso(1));
                    }
                    tarea.Add(hijos.Last().puntero.incrementoProgreso(1));
                    hijos.Insert(i, previo);

                    nodos.Insert(i, nodo);
                    nodo.Indice = i;

                    tarea.Add(reajustarPocision(true));
                    tarea.Add(actualizarElementosVista());

                    await Task.WhenAll(tarea);
                }
                else
                {
                    Children.Remove(hijos[i].puntero);
                    hijos[i] = previo;

                    hijos.Insert(i + 1, siguiente);

                    nodos.Insert(i, nodo);
                    nodo.Indice = i;

                    actualizarJerarquia();
                    await Task.WhenAll(reajustarPocision(true), actualizarElementosVista());
                }
            }
        }