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();
}
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();
}
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());
}
}
}