Пример #1
0
        private void IncrementarBloque(int posicion, int delta)
        {
            if (!_bloques.SinAsignar())
            {
                int suma = 0;
                for (int i = 0; i < _bloques.Cantidad; i++)
                {
                    Bloque b = _bloques.Obtener(i);
                    suma += b.Cantidad;
                    if (suma >= posicion)//||(_bloques[i].Cantidad==0&&suma==posicion))
                    {
                        int inc = i + 1;
                        while (inc < _bloques.Cantidad && _bloques.Obtener(inc).Cantidad == 0)
                        {
                            inc++;
                        }
                        inc = inc - 1;
                        Bloque bc = _bloques.Obtener(inc);
                        bc.IncrementarCantidad(delta);
                        _bloques.Guardar(inc, bc);
#if DEBUG
                        Verificar();
#endif
                        return;
                    }
                }
                Bloque bd = _bloques.Obtener(_bloques.Cantidad - 1);
                bd.IncrementarCantidad(delta);
                _bloques.Guardar(_bloques.Cantidad - 1, bd);
#if DEBUG
                Verificar();
#endif
            }
        }
Пример #2
0
        internal IEnumerable <IndiceBloque> ObtenerIndices()
        {
            int posicion = 0;

            for (int i = 0; i < ObtenerNumBloques(); i++)
            {
                Bloque b = ObtenerBloque(i);
                yield return(new IndiceBloque(posicion, b.Cantidad, b.Formato));

                posicion += b.Cantidad;
            }
        }
Пример #3
0
        internal void Remove(int posicion, int cantidad)
        {
            st.Remove(posicion, cantidad);
            if (!_bloques.SinAsignar())
            {
                int primerbloque, ultimobloque;
                int deltaini, deltafin;
                ObtenerRango(posicion, cantidad,
                             out primerbloque, out deltaini,
                             out ultimobloque, out deltafin);
                if (primerbloque == ultimobloque)
                {
                    Bloque b = _bloques.Obtener(primerbloque);
                    b.DisminuirCantidad(deltafin - deltaini);
                    if (b.Cantidad == 0)
                    {
                        _bloques.Eliminar(primerbloque);
                    }
                    else
                    {
                        _bloques.Guardar(primerbloque, b);
                    }
                }
                else
                {
                    Bloque b = _bloques.Obtener(primerbloque);
                    b.DisminuirCantidad((b.Cantidad - deltaini));
                    _bloques.Guardar(primerbloque, b);
                    Bloque b2 = _bloques.Obtener(ultimobloque);
                    b2.DisminuirCantidad(deltafin);
                    _bloques.Guardar(ultimobloque, b2);
                    int primerbloqueelim = primerbloque + 1;
                    if (b.Cantidad == 0)
                    {
                        primerbloqueelim--;
                    }
                    int ultimobloqueelim = ultimobloque - 1;
                    if (b2.Cantidad == 0)
                    {
                        ultimobloqueelim++;
                    }
                    int bloquesremover = ultimobloqueelim - primerbloqueelim + 1;//Incluir el último bloque si su cantidad es cero
                    if (bloquesremover > 0)
                    {
                        _bloques.EliminarRango(primerbloque + 1, bloquesremover);
                    }
#if DEBUG
                    Verificar();
#endif
                }
            }
        }
Пример #4
0
        private void ExtenderBloques(int delta)
        {
            if (!_bloques.SinAsignar())
            {
                Bloque b = _bloques.Obtener(_bloques.Cantidad - 1);
                b.IncrementarCantidad(delta);
                _bloques.Guardar(_bloques.Cantidad - 1, b);

#if DEBUG
                Verificar();
#endif
            }
        }
Пример #5
0
        public void AplicarFormato(Formato formato, int inicio, int cantidad)
        {
            Debug.Assert(inicio + cantidad <= Length);
            AsegurarBloques();
            int primerbloque, ultimobloque;
            int deltaini, deltafin;

            ObtenerRango(inicio, cantidad, out primerbloque, out deltaini, out ultimobloque, out deltafin);
            if (primerbloque == ultimobloque)
            {
                Bloque a = _bloques.Obtener(primerbloque);
                Bloque b = new Bloque(deltafin - deltaini, a.Formato);
                b.FusionarFormato(formato);
                Bloque c = new Bloque(a.Cantidad - deltafin, a.Formato);
                a.DisminuirCantidad(a.Cantidad - deltaini);
                _bloques.Guardar(primerbloque, a);
                _bloques.Insertar(primerbloque + 1, b);
                _bloques.Insertar(primerbloque + 2, c);
            }
            else
            {
                Bloque a = _bloques.Obtener(primerbloque);
                //disminuir el tamaño de los bloques e insertar nuevos bloques al medio combinados.
                if (a.Cantidad != deltaini)
                {
                    _bloques.Insertar(primerbloque + 1, new Bloque(a.Cantidad - deltaini, a.Formato));
                    ultimobloque++;
                }
                a.DisminuirCantidad(a.Cantidad - deltaini);
                _bloques.Guardar(primerbloque, a);
                Bloque b = _bloques.Obtener(ultimobloque);
                if (deltafin != 0)
                {
                    _bloques.Insertar(ultimobloque, new Bloque(deltafin, b.Formato));
                    ultimobloque++;
                }
                b.DisminuirCantidad(deltafin);
                _bloques.Guardar(ultimobloque, b);
                for (int i = primerbloque + 1; i < ultimobloque; i++)
                {
                    Bloque bq = _bloques.Obtener(i);
                    bq.FusionarFormato(formato);
                    _bloques.Guardar(i, bq);
                }

#if DEBUG
                Verificar();
#endif
            }
        }
Пример #6
0
        internal Texto Dividir(int posicionDivision)
        {
            Texto texto2 = new Texto();

            texto2.Iniciar();
            if (!_bloques.SinAsignar())
            {
                int primerbloque, ultimobloque;
                int deltaini, deltafin;
                ObtenerRango(posicionDivision, st.Length - posicionDivision, out primerbloque, out deltaini, out ultimobloque, out deltafin);
                Bloque bloqueinicio      = _bloques.Obtener(primerbloque);
                int    saldoprimerbloque = bloqueinicio.Cantidad - deltaini;
                bloqueinicio.CambiarCantidad(deltaini);
                _bloques.Guardar(primerbloque, bloqueinicio);
                texto2.AsegurarBloques();
                int deltaelim = 0;
                if (saldoprimerbloque != 0)
                {
                    Bloque clon = _bloques.Obtener(primerbloque);//.Clonar();
                    texto2._bloques.Agregar(saldoprimerbloque, clon.Formato);
                    deltaelim++;
                }
                for (int i = primerbloque + 1; i < _bloques.Cantidad; i++)
                {
                    Bloque b = _bloques.Obtener(i);
                    texto2._bloques.Agregar(b.Cantidad, b.Formato);
                }
                if (primerbloque + 1 != _bloques.Cantidad)
                {
                    _bloques.EliminarRango(primerbloque + 1, _bloques.Cantidad - (primerbloque + 1));
                }
            }
            texto2.st.Append(st.ToString(posicionDivision, st.Length - posicionDivision));
            st.Remove(posicionDivision, st.Length - posicionDivision);
#if DEBUG
            Verificar();
            texto2.Verificar();
#endif
            return(texto2);
        }
Пример #7
0
 internal void Insertar(int indice, Bloque bloque)
 {
     _bloques.Insert(indice, bloque);
 }
Пример #8
0
 public void Guardar(int i, Bloque bloque)
 {
     _bloques[i] = bloque;
 }
Пример #9
0
        public IEnumerable <Bloque> ObtenerRangoBloques(int inicio, int cantidad)
        {
            Bloque bc = new Bloque(0, null);

            if (_bloques.SinAsignar())
            {
                if (st.Length == 0)
                {
                    yield return(_BloqueVacio);
                }
                else
                {
                    bc.CambiarCantidad(cantidad);
                    yield return(bc);
                }
            }
            else
            {
                if (_bloques.Cantidad == 1)
                {
                    Bloque b = _bloques.Obtener(0);
                    bc.CambiarCantidad(b.Cantidad);
                    bc.Formato = b.Formato;
                    yield return(bc);

                    yield break;
                }
                int inicioBloque = 0;
                int finSeleccion = inicio + cantidad;
                for (int i = 0; i < _bloques.Cantidad; i++)
                {
                    Bloque b              = _bloques.Obtener(i);
                    int    finBloque      = inicioBloque + b.Cantidad;
                    bool   inicioEnBloque = inicio >= inicioBloque && inicio < finBloque;
                    bool   enmedio        = inicioBloque > finSeleccion && finBloque > finSeleccion;
                    bool   finEnBloque    = finSeleccion >= inicioBloque && finSeleccion <= finBloque;
                    if (inicioEnBloque)
                    {
                        if (finEnBloque)
                        {
                            bc.CambiarCantidad(finBloque - inicioBloque);
                            bc.Formato = b.Formato;
                            yield return(bc);

                            yield break;
                        }
                        else
                        {
                            bc.Formato = b.Formato;
                            bc.CambiarCantidad(b.Cantidad);
                            bc.DisminuirCantidad(inicio - inicioBloque);
                            yield return(bc);
                        }
                    }
                    else
                    {
                        if (finEnBloque)
                        {
                            bc.Formato = b.Formato;
                            bc.CambiarCantidad(finSeleccion - inicioBloque);
                            yield return(bc);

                            yield break;
                        }
                        else if (enmedio)
                        {
                            bc.Formato = b.Formato;
                            bc.CambiarCantidad(b.Cantidad);
                            yield return(bc);
                        }
                    }
                }
            }
        }