problemas con las comparaciones "num1 in [num2 .. num3]" en Delphi 2009
 

Hola compañeros, recurro a ustedes para que me ayuden a aclarar una duda que tengo. Es con respecto a las evaluaciones del tipo "if num1 in [num2 .. num3]" específicamente evaluaciones de rangos. Resulta que ayer estaba escribiendo este algoritmo:

Código Delphi [-]
/ Calcula si el punto donde será dibujado TextToDraw será bajo el puntero del Ratón.
// PARÁMETROS:
//  CanvasHandle:       Handle del canvas donde se está haciendo el dibujo.
//  TextToDraw:         Texto que se va dibujar.
//  ConstrolOrigin:     Punto relativo a la pantalla en donde se inicia el 
//                      control sobre el que se está haciendo el dibujado. 
//                      (Propiedad "ClientOrigin" de TControl).
//  MainRectTopLeft:    Rect principal del canvas
//  ExtraDrawingRect:   Rect del buffered bitmap que se está utilizando para
//                      hacer el dibujado. Rect compuesto de 0's si no se está
//                      usando un buffered bitmap.  
function MouseOverTextCanvas(const CanvasHandle: HDC;
                             const TextToDraw: String;
                             const ControlOrigin: TPoint;
                             const MainRectTopLeft: TRect;
                             const ExtraDrawingRect: TRect): boolean;
var
    CalcRect: TRect;
    TextRect: TRect;
begin

    // calcular el la posición y dimensión del texto a dibujar
    TextRect := Rect((ControlOrigin.X + MainRectTopLeft.Left + ExtraDrawingRect.Left),
                     (ControlOrigin.Y + MainRectTopLeft.Top + ExtraDrawingRect.Top),
                     0, 0);
    CalcRect := Rect(0, 0, 0, 0);
    DrawText(CanvasHandle,
             PChar(TextToDraw),
             Length(TextToDraw),
             CalcRect, DT_CALCRECT);
    TextRect.Right := TextRect.Left + CalcRect.Right;
    TextRect.Bottom := TextRect.Top + CalcRect.Bottom;

    // el problema es con la evaluación en la línea siguiente. Hasta donde llegan
    // mis conocimientos esta evaluación debería funcionar, pero no lo hace
    // en Delphi 2009 sin Updates
    Result := ((Mouse.CursorPos.X in [TextRect.Left .. TextRect.Right]) and
               (Mouse.CursorPos.Y in [TextRect.Top .. TextRect.Bottom]));

end;

El anterior algoritmo es para probar si un texto dibujado está sobre cierta región del Canvas, para dibujar el texto con estilo "Underline" por ejemplo, al estilo Web.

El problema no es con el algoritmo en si, sino es con la evaluación. Ya que luego de quebrarme la cabeza por gran rato modifiqué la anterior evaluación y me quedé con el mismo algoritmo, pero con una evaluación más de principiante :p:

Código Delphi [-]
function MouseOverTextCanvas(const CanvasHandle: HDC;
                             const TextToDraw: String;
                             const ControlOrigin: TPoint;
                             const MainRectTopLeft: TRect;
                             const ExtraDrawingRect: TRect): boolean;
var
    CalcRect: TRect;
    TextRect: TRect;
    X, L, R, Y, T, B: Integer;
begin

    // calcular el la posición y dimensión del texto a dibujar
    TextRect := Rect((ControlOrigin.X + MainRectTopLeft.Left + ExtraDrawingRect.Left),
                     (ControlOrigin.Y + MainRectTopLeft.Top + ExtraDrawingRect.Top),
                     0, 0);
    CalcRect := Rect(0, 0, 0, 0);
    DrawText(CanvasHandle,
             PChar(TextToDraw),
             Length(TextToDraw),
             CalcRect, DT_CALCRECT);
    TextRect.Right := TextRect.Left + CalcRect.Right;
    TextRect.Bottom := TextRect.Top + CalcRect.Bottom;

    X := Mouse.CursorPos.X;
    Y := Mouse.CursorPos.Y;
    L := TextRect.Left;
    R := TextRect.Right;
    T := TextRect.Top;
    B := TextRect.Bottom;

    Result := (((x >= l) and (x <= r)) and ((Y >= T) and (Y <= B)));

end;

Un dato curioso también, la existencia de las variables X, Y, L, R, T y B se debe a que la anterior evaluación hecha directamente con las variables Mouse.CursorPos y TextRect no funcionaba tampoco.

No sé si es que estoy equivocado sobre la función de in o es que realmente mi suposición de que es un problema de Delphi 2009 es correcta.

Quisiera saber sus opiniones al respecto.

Saludos,
Chris

Me jugaría la cabeza a que es un problema de rango de los conjuntos.

Verás, un conjunto en Delphi tiene un máximo de 255 elementos, porque la estructura interna del conjunto usa 8 bits.

Cuando uno crea un conjunto "al vuelo" (con "[" y "]") si los valores sobrepasan el máximo de 8 bits ocurreo overflow y por eso si uno intenta evaluar valores mayores a 255, pues... no funciona porque los valores fueron truncados.

Por ejemplo:

Código Delphi [-]
var a, b, c: Integer;
begin
  a:= 270;
  b:= 345;
  c:= 30;
  if c in [a..b] then ShowMessage('sí');
end;

Da que 30 está entre 270 y 345 :eek:. Eso es porque en realidad el conjunto [a..b] quedó formado por los valores 14 y 89.

Así, si uno hace:

Código Delphi [-]
var a, b, c: Integer;
begin
  a:= 270;
  b:= 345;
  c:= 300;
  if c in [a..b] then ShowMessage('sí');
end;

Va a decir que 300 no está entre 14 y 89, aunque uno pensó que era entre 270 y 345...

EDITO: Esto es en Delphi 7, no sé si los conjuntos de D2009 serán igual.

Gracias Delfos por la explicación. No sabía ese datos de los conjuntos. Seguramente la limitación sigue existiendo en D2009. Aunque no quedé claro porque A queda en 14 y B en 89?????? :confused:

Saludos,
Chris

1) En delphi 2010 persiste esa limitación en los conjuntos. Extraido de la ayuda de Delphi 2010:

Sets
A set is a collection of values of the same ordinal type.
The values have no inherent order, nor is it meaningful for a value to be included twice in a set.

The range of a set type is the power set of a specific ordinal type, called the base type;
that is, the possible values of the set type are all the subsets of the base type, including the empty set.
The base type can have no more than 256 possible values, and their ordinalities must fall between 0 and 255.


2) Se queda entre 14 y 89 porque se trunca el valor (270 - 256 = 14).
Si representas 270 en binario = 100001100, al guardarlo en 8 bits, el digito más significativo se pierde,
y se guarda solo el valor 00001100, que es el 14 en decimal.

Satamente, no lo podría haber explicado mejor.