Exemple #1
0
        public Formato Fusionar(Formato formato2)
        {
            Formato f;

            if (formato2 != null)
            {
                if (formatoConstructor == null)
                {
                    formatoConstructor = new Formato();
                }
                f = formatoConstructor;
                f.FamiliaLetra      = formato2.FamiliaLetra ?? FamiliaLetra;
                f.TamLetra          = formato2.TamLetra ?? TamLetra;
                f.Negrilla          = formato2.Negrilla ?? Negrilla;
                f.Cursiva           = formato2.Cursiva ?? Cursiva;
                f.Subrayado         = formato2.Subrayado ?? Subrayado;
                f.ColorFondo        = formato2.ColorFondo ?? ColorFondo;
                f.ColorLetra        = formato2.ColorLetra ?? ColorLetra;
                f.FactorEscalaLetra = (float)Math.Round(formato2.FactorEscalaLetra * FactorEscalaLetra, 2);
                return(ObtenerDeCache(f));
            }
            else
            {
                return(this);
            }
        }
Exemple #2
0
 public Bloque(int cantidad, Formato formato) : this()
 {
     Cantidad = cantidad;
     Debug.Assert(cantidad >= 0);
     if (formato != null)
     {
         formato = formato.Clonar();
     }
     _Formato = formato;
 }
Exemple #3
0
 internal void FusionarFormato(Formato formato)
 {
     if (Formato == null)
     {
         _Formato = formato.Fusionar(null);
     }
     else
     {
         _Formato = Formato.Fusionar(formato);
     }
 }
Exemple #4
0
        public override bool Equals(object obj)
        {
            Formato f = obj as Formato;

            if (f == null)
            {
                return(false);
            }
            return(f.Flags == Flags && TamLetra.Equals(f.TamLetra) && f.FamiliaLetra == FamiliaLetra &&
                   ColorFondo.Equals(f.ColorFondo) && ColorLetra.Equals(f.ColorLetra) &&
                   FactorEscalaLetra == f.FactorEscalaLetra);
        }
Exemple #5
0
 static Formato()
 {
     Contexto = new Formato();
     Contexto.FamiliaLetra      = "Arial";
     Contexto.TamLetra          = new Medicion(12, Unidad.Puntos);
     Contexto.Subrayado         = false;
     Contexto.Negrilla          = false;
     Contexto.Cursiva           = false;
     Contexto.ColorLetra        = ColorDocumento.Negro;
     Contexto.ColorFondo        = ColorDocumento.Transparente;
     Contexto.FactorEscalaLetra = 1;
 }
Exemple #6
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
            }
        }
Exemple #7
0
        public void EscribirTexto(string texto, SWPEditor.Dominio.TextoFormato.Formato formato)
        {
            bool formatoigual = false;

            //if (!formato.Equals(Formato.ObtenerPredefinido()))
            //{
            _html.Append("<span ");
            _html.Append(" style=\"");
            if (estiloslin.ContainsKey(formato))
            {
                _html.Append(estiloslin[formato]);
            }
            else
            {
                AgregarEstilo(formato);
                _html.Append(estiloslin[formato]);
            }
            _html.Append("\"");
            //int numestilo = 0;
            //if (cadestilos.ContainsKey(formato))
            //{
            //    numestilo = cadestilos[formato];
            //}
            //else
            //{
            //    numestilo = AgregarEstilo(formato);

            //}
            //_html.Append(" class=\"e" + numestilo + "\"");
            _html.Append(">");
            //}
            //else
            formatoigual = true;
            _html.Append(texto);
            //if (!formatoigual)
            //{
            _html.Append("</span>");
            //}
        }
Exemple #8
0
 static Formato ObtenerDeCache(Formato f)
 {
     if (m_Formatos.ContainsKey(f))
     {
         lock (m_Formatos)
         {
             return(m_Formatos[f]);
         }
     }
     else
     {
         lock (m_Formatos)
         {
             if (f == formatoConstructor)
             {
                 f = f.Clonar();
             }
             m_Formatos.Add(f, f);
             return(f);
         }
     }
 }
Exemple #9
0
        public Formato ObtenerInterseccion(Formato formato2)
        {
            if (formatoConstructor == null)
            {
                formatoConstructor = new Formato();
            }
            Formato f = formatoConstructor;

            if (FamiliaLetra == formato2.FamiliaLetra)
            {
                f.FamiliaLetra = FamiliaLetra;
            }
            if (TamLetra.Equals(formato2.TamLetra))
            {
                f.TamLetra = TamLetra;
            }
            if (Negrilla.Equals(formato2.Negrilla))
            {
                f.Negrilla = Negrilla;
            }
            if (Cursiva.Equals(formato2.Cursiva))
            {
                f.Cursiva = Cursiva;
            }
            if (Subrayado.Equals(formato2.Subrayado))
            {
                f.Subrayado = Subrayado;
            }
            if (ColorFondo.Equals(formato2.ColorFondo))
            {
                f.ColorFondo = ColorFondo;
            }
            if (ColorLetra.Equals(formato2.ColorLetra))
            {
                f.ColorLetra = ColorLetra;
            }
            return(ObtenerDeCache(f));
        }
Exemple #10
0
        private static Formato Crear(
            string familiaLetra, Medicion?tamLetra,
            bool?negrilla, bool?cursiva, bool?subrayado,
            ColorDocumento?colorFondo, ColorDocumento?colorLetra,
            float?factorEscala)
        {
            if (formatoConstructor == null)
            {
                formatoConstructor = new Formato();
            }
            Formato f = formatoConstructor;

            f.FamiliaLetra      = familiaLetra;
            f.TamLetra          = tamLetra;
            f.ColorFondo        = colorFondo;
            f.Negrilla          = negrilla;
            f.Subrayado         = subrayado;
            f.Cursiva           = cursiva;
            f.ColorLetra        = colorLetra;
            f.ColorFondo        = colorFondo;
            f.FactorEscalaLetra = factorEscala ?? 1;

            return(ObtenerDeCache(f));
        }
Exemple #11
0
 public IndiceBloque(int inicio, int cantidad, Formato formato)
 {
     Debug.Assert(cantidad >= 0);
     Debug.Assert(inicio >= 0);
     Inicio = inicio; Cantidad = cantidad; Formato = formato;
 }
Exemple #12
0
 internal Formato ObtenerFormatoTexto()
 {
     return(FormatoTexto ?? Formato.ObtenerPredefinido());
 }
Exemple #13
0
 public void EscribirTexto(string texto, SWPEditor.Dominio.TextoFormato.Formato formato)
 {
 }
Exemple #14
0
 public void Agregar(int cantidad, Formato formato)
 {
     _bloques.Add(new Bloque(cantidad, formato));
 }