Esempio n. 1
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();
     }
 }
Esempio n. 2
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();
        }