Saber el Style de una fuente
 

Buenas tardes a todos!!

Mi duda es esta, yo utilizo para designar el tipo de fuente a una caja de texto un fontdialog, se que la propiedad Style guarda todos los estilos seleccionados dentro del menu pero esta variable se compone de constantes (fsbold, bsitalic, etc.).

Lo que me gustaria saber es si puedo saber que estilos tiene una fuente seleccionada y guardarmelos en un String. Quiero hacer esto para almacenar mis preferencias sobre fuentes dentro del registro de windows y por eso me interesaria guardarlo en algun String y asi almacenarlo facilmente.

en caso de que no se pueda convertir a string podria tambien ir sacando uno por uno los estilos seleccionados pero no sé como.

¿Alguien me podria ayudar?

Declaración de tipos:

Código Delphi [-]
type
  TFontStyle = (fsBold, fsItalic, fsUnderline, fsStrikeOut);
  TFontStyles = set of TFontStyle;

La propiedad Style es de tipo TFontStyles. Tengo entendido que internamente un conjunto (set of) se guarda como un byte. Haciendo una prueba me ha funcionado esto:

Código Delphi [-]
var
  Style: Byte;

...

Style := Byte(Font.Style) // Para guardar el valor
Font.Style := TFontStyles(Style); // Para recuperar el valor

De esta manera simplemente guardas Style (un byte) en el registro de Windows.

// Saludos

Un string no es la forma mas óptima de guardar un conjunto de este tipo, ya que se podría guardar en un simple Byte, y en un string, podría ocupar algo similar a esto: "[fsBold,fsItalic,fsUnderline,fsStrikeOut]".
Aquí tienes algun ejemplo de lo que pides: http://www.clubdelphi.com/foros/showthread.php?t=7264

Otra opción "mas sencilla", puede ser mover el dato del TFontStyle mediante la función Move a un Byte, o bien utilizar variables con posición absoluta.

Y ¿por qué no hacer simplemente el "casting" tal como propuse? No estoy seguro pero me parece que la representación interna de un conjunto está oficialmente documentada. A ver si busco por ahí...

// Saludos

Primero no he leido tu mensaje, cuando ingresé no había ninguno, y despues probé hacer un Cast (en Delphi 5), pero falló... Me pareció extraño, pero sinceramente no le quise dar vueltas ;)


Saludos!

PD: Ahora porbé el cast, y funciona sin problemas... :) No se que habré hecho

Solo quiero acotar que no me parece que un set se guarde en un solo byte.

Esto limitaria el conjunto a solo ocho posibles elementos... y hay conjuntos con mas.

No puedo buscar ahora, pero estoy seguro que Delphi ajustará el tamaño de la variable a la cantidad de elementos del conjunto, por lo que en ocasiones se tratará de un tipo de 16 bits de longitud (como un Word), pero también puede ser de 32... un Longint o LongWord por ejemplo, o mas... con lo que ya quedaría bueno representarlo como un conjunto o como un Int64, etc.

Delphi, cuando almacena un conjunto, simplemente tiene una lista ordenada de todos los posibles valores que pueden pertenecer a este, y el conjunto no es mas que un BitMap que indica los valores presentes en el conjunto con 1 y los no presentes con 0.

Si los posibles valores son del tipo TFontStyle, que está definido por la siguiente enumeración (en ese orden):

fsBold, fsItalic, fsUnderline, fsStrikeOut

Se necesitarán solamente cuatro bits para representar un Set of TFontStyle, y un conjunto con los valores [fsBold, fsUnderline] será dado por el bitmap

1010

y un conjunto vacio, por el bitmap

0000

En fin... quizas sea buena idea hacer un SizeOf antes de decidir el tipo de datos a usar para almacenar el conjunto como un entero (o cualquier otro tipo escalar).

Hasta luego.

;)

Puedes hacer una prueba mas que sencilla:

Código Delphi [-]
Format('FontStyle: %d ComponentState: %d', [SizeOf(TFontStyles), SizeOf(TComponentState)]);

Un comentario, yo he probado eso para poder sugerir un cast, pero no se poqué falló, me dio un error como que no era posible este tipo de cast, voy a morir con la duda de que había echo :D

Saludos!

Hasta donde he visto es cierto lo que dices. El tamaño depende de el rango máximo de valores. En este caso es un byte pero en otros habrá que hacer el moldeo a otro tipo de entero.

// Saludos

Eso lo aseguro, que el compilador lo reduce a la mínima expresión, tenía la idea de que había una directiva al compilador para modificar esto, pero no la encotré.

Por otro lado, aquí tienen un ejemplo como otros conjuntro extaños siguen ocupando lo mínimo indispensable:

Código Delphi [-]
type
  TMiTipo1 = (msValorA1, msValorA2, msValorA3);
  TMiSet1  = set of TMiTipo1;

  TMiTipo2 = (msValorB1 = 253, msValorB2, msValorB3);
  TMiSet2  = set of TMiTipo2;

  {$MINENUMSIZE 4}
  TMiTipo3 = (msValorC1, msValorC2, msValorC3);
  TMiSet3  = set of TMiTipo3;
  {$MINENUMSIZE 1}

  TMiTipo4 = 0..31;
  TMiSet4  = set of TMiTipo4;

  TMiTipo5 = 1..32;
  TMiSet5  = set of TMiTipo5;

  TMiTipo6 = 'a'..'z';
  TMiSet6  = set of TMiTipo6;
....

procedure TForm1.FormCreate(Sender: TObject);
begin
  Memo1.Lines.Add(Format('1> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet1), SizeOf(TMiTipo1), Integer(msValorA1)]));
  Memo1.Lines.Add(Format('2> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet2), SizeOf(TMiTipo2), Integer(msValorB1)]));
  Memo1.Lines.Add(Format('3> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet3), SizeOf(TMiTipo3), Integer(msValorC1)]));
  Memo1.Lines.Add(Format('4> Tamaño: %d Tipo: %d', [SizeOf(TMiSet4), SizeOf(TMiTipo4)]));
  Memo1.Lines.Add(Format('5> Tamaño: %d Tipo: %d', [SizeOf(TMiSet5), SizeOf(TMiTipo5)]));
  Memo1.Lines.Add(Format('6> Tamaño: %d Tipo: %d', [SizeOf(TMiSet6), SizeOf(TMiTipo6)]));
end;

Saludos!

jejeje... me has hecho cargar delphi para probar, y de paso refrescar un poco la memoria con los conjuntos.

El compilador reduce el tamaño del conjunto a su minima expresión. Al contrario tuyo, yo no recuerdo ninguna directiva para cambiar este comportamiento...

Un conjunto no puede tener mas de 256 posibles elementos... con lo que el tamaño máximo de este tipo de dato en memoria será de 32 bytes (256 bits).

Me he atrevido a agregar un par de tipos mas a tu código, siendo estos:

Código Delphi [-]
  TMiTipo7 = 0..255;
  TMiSet7  = set of TMiTipo7;

  TMiTipo8 = 1..256;
  TMiSet8  = set of TMiTipo7;

...
// y por supuesto, 
  Memo1.Lines.Add(Format('7> Tamaño: %d Tipo: %d', [SizeOf(TMiSet7), SizeOf(TMiTipo7)]));
  Memo1.Lines.Add(Format('8> Tamaño: %d Tipo: %d', [SizeOf(TMiSet8), SizeOf(TMiTipo8)]));

Los resultados obtenidos son:

Me llama poderosamente la atención el caso 5>, en que el compilador ha usado 5 bytes para almacenar el conjunto, cuando en realidad es posible hacerlo solamente en 4. Precisamente por ello he incluido los dos últimos tipos... para ver si se animaba a usar mas de 32 bytes... :p

Hasta luego.

;)