Exemple #1
0
 private static Nodo buscarSiguiente(Pagina pagina, int indice)
 {
     pagina = pagina.hijos[indice + 1].pagina;
     while (pagina.hijos[0].pagina != null)
     {
         pagina = pagina.hijos[0].pagina;
     }
     return(pagina.nodos[0]);
 }
Exemple #2
0
        public async Task <string> Insertar(int value)
        {
            Tuple <Pagina, Nodo> pin = await raiz.Buscar(value);

            Nodo nodo = pin.Item2; Pagina pagina = pin.Item1;

            if (nodo != null)
            {
                return(string.Format("Valor {0} ya existe", value));
            }
            else
            {
                await pagina.Insertar(value);

                if (raiz.PaginaPadre != null)
                {
                    raiz = raiz.PaginaPadre;
                }
                await raiz.reajustarPocision(true);

                return(string.Format("Valor {0} insertado", value));
            }
        }
Exemple #3
0
 private void actualizarJerarquia()
 {
     if (Parent == null)
     {
         PaginaPadre.Children.Add(this);
         var transform = this.hijos[0].puntero.TransformToVisual(PaginaPadre);
         var pocision  = transform.Transform(new Point(0, 0));
         Canvas.SetTop(this, pocision.X);
         Canvas.SetLeft(this, pocision.Y);
     }
     foreach (var c in hijos)
     {
         Pagina pagina = c.pagina;
         if (pagina != null && pagina.Parent != this)
         {
             if (pagina.PaginaPadre != this)
             {
                 throw new Exception();
             }
             var transform = pagina.hijos[0].puntero.TransformToVisual(this);
             var posicion  = transform.Transform(new Point(0, 0));
             Canvas.SetLeft(pagina, posicion.X);
             Canvas.SetTop(pagina, posicion.Y);
             if (pagina.Parent != null)
             {
                 ((Pagina)pagina.Parent).Children.Remove(pagina);
             }
             this.Children.Add(pagina);
         }
         ((Canvas)Parent).UpdateLayout();
         if (pagina != null)
         {
             pagina.actualizarJerarquia();
         }
         UpdateLayout();
     }
 }
Exemple #4
0
        public async Task <Tuple <Pagina, Nodo> > Buscar(int valor)
        {
            if (nodos.Count() == 0)
            {
                return(new Tuple <Pagina, Nodo>(this, null));
            }

            int i;

            for (i = 0; i < nodos.Count(); i++)
            {
                await Estilos.highlight(nodos[i]);

                if (nodos[i].Value >= valor)
                {
                    break;
                }
            }

            if (i < nodos.Count() && nodos[i].Value == valor)
            {
                return(new Tuple <Pagina, Nodo>(this, nodos[i]));
            }

            if (hijos[i].pagina != null)
            {
                await Estilos.highlight(hijos[i].puntero);

                Pagina hijo = hijos[i].pagina;
                return(await hijo.Buscar(valor));
            }
            else
            {
                return(new Tuple <Pagina, Nodo>(this, null));
            }
        }
Exemple #5
0
 public PaginaHijo(Pagina parent)
 {
     paginaPadre = parent;
 }
Exemple #6
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();
        }