windows - tag - ¿Cómo cargo iconos desde un recurso sin sufrir aliasing?

tag folders

Question

Tengo una aplicación de GUI que incluye una serie de iconos utilizados para botones de la barra de herramientas, glifos de menú, iconos de notificación, etc. Estos iconos están vinculados a la aplicación como recursos y están disponibles una variedad de tamaños diferentes. Normalmente, para las imágenes del botón de la barra de herramientas, tengo disponibles versiones de 16px, 24px y 32px. Mis íconos son 32bpp con transparencia parcial.

La aplicación tiene un alto reconocimiento de DPI y ajusta el tamaño de todos los elementos visuales de acuerdo con la escala de la fuente predominante. Por lo tanto, por ejemplo, al escalar 100% de fuente, 96 ppp, el tamaño del icono de la barra de herramientas es 16px. Con una escala de 125%, 120 ppp, el tamaño del icono de la barra de herramientas es 20px. Necesito poder cargar un icono de tamaño 20px sin ningún efecto de aliasing. ¿Cómo puedo hacer esto? Tenga en cuenta que me gustaría apoyar Windows 2000 y versiones posteriores.

Answer 1

En Vista y hasta se agregaron una serie de funciones nuevas que hacen que esta tarea sea trivial. La función más adecuada aquí es LoadIconWithScaleDown .

Esta función buscará primero en el archivo de icono un ícono que tenga exactamente el mismo tamaño. Si no se encuentra una coincidencia, a menos que tanto cx como cy coincidan con uno de los tamaños de icono estándar: 16, 32, 48 o 256 píxeles, se selecciona el siguiente ícono más grande y luego se reduce al tamaño deseado. Por ejemplo, si la aplicación Callign solicita un icono con una dimensión x de 40 píxeles, el icono de 48 píxeles se usa y se reduce a 40 píxeles. Por el contrario, la función LoadImage selecciona el icono de 32 píxeles y lo escala hasta 40 píxeles.

Si la función no puede ubicar un ícono más grande, tiene el comportamiento estándar de buscar el siguiente ícono más pequeño y escalarlo al tamaño deseado.

En mi experiencia, esta función hace un excelente trabajo de escalado y los resultados no muestran signos de aliasing.

Para las versiones anteriores de Windows, a mi leal saber y entender, no hay ninguna función que pueda realizar esta tarea adecuadamente. Los resultados obtenidos de LoadImage son de muy mala calidad. En cambio, el mejor enfoque que he encontrado es el siguiente:

1. Examine las imágenes disponibles en el recurso para encontrar la imagen con el tamaño más grande que es menor que el tamaño del icono deseado.
2. Cree un nuevo ícono del tamaño deseado e inicialícelo para que sea completamente transparente.
3. Coloque el ícono más pequeño del recurso en el centro del ícono nuevo (más grande).

Esto significa que habrá un pequeño borde transparente alrededor del ícono, pero generalmente esto es lo suficientemente pequeño para ser insignificante. La opción ideal sería utilizar un código que pudiera reducirse al igual que LoadIconWithScaleDown , pero no es trivial de escribir.

Entonces, sin más preámbulos aquí está el código que uso.

unit uLoadIconResource;

interface

uses
  SysUtils, Math, Classes, Windows, Graphics, CommCtrl;

function LoadIconResourceSize(const ResourceName: string; IconSize: Integer): HICON;//will not throw an exception
function LoadIconResourceMetric(const ResourceName: string; IconMetric: Integer): HICON;

implementation

function IconSizeFromMetric(IconMetric: Integer): Integer;
begin
  case IconMetric of
  ICON_SMALL:
    Result := GetSystemMetrics(SM_CXSMICON);
  ICON_BIG:
    Result := GetSystemMetrics(SM_CXICON);
  else
    raise EAssertionFailed.Create(''Invalid IconMetric'');
  end;
end;

procedure GetDIBheaderAndBits(bmp: HBITMAP; out bih: BITMAPINFOHEADER; out bits: Pointer);
var
  pbih: ^BITMAPINFOHEADER;
  bihSize, bitsSize: DWORD;
begin
  bits := nil;
  GetDIBSizes(bmp, bihSize, bitsSize);
  pbih := AllocMem(bihSize);
  Try
    bits := AllocMem(bitsSize);
    GetDIB(bmp, 0, pbih^, bits^);
    if pbih.biSize<SizeOf(bih) then begin
      FreeMem(bits);
      bits := nil;
      exit;
    end;
    bih := pbih^;
  Finally
    FreeMem(pbih);
  End;
end;

function CreateIconFromSmallerIcon(IconSize: Integer; SmallerIcon: HICON): HICON;

  procedure InitialiseBitmapInfoHeader(var bih: BITMAPINFOHEADER);
  begin
    bih.biSize := SizeOf(BITMAPINFOHEADER);
    bih.biWidth := IconSize;
    bih.biHeight := 2*IconSize;//height of xor bitmap plus height of and bitmap
    bih.biPlanes := 1;
    bih.biBitCount := 32;
    bih.biCompression := BI_RGB;
  end;

  procedure CreateXORbitmap(const sbih, dbih: BITMAPINFOHEADER; sptr, dptr: PDWORD);
  var
    line, xOffset, yOffset: Integer;
  begin
    xOffset := (IconSize-sbih.biWidth) div 2;
    yOffset := (IconSize-sbih.biHeight) div 2;
    inc(dptr, xOffset + IconSize*yOffset);
    for line := 0 to sbih.biHeight-1 do begin
      Move(sptr^, dptr^, sbih.biWidth*SizeOf(DWORD));
      inc(dptr, IconSize);//relies on the fact that no padding is needed for RGBA scanlines
      inc(sptr, sbih.biWidth);//likewise
    end;
  end;

var
  SmallerIconInfo: TIconInfo;
  sBits, xorBits: PDWORD;
  xorScanSize, andScanSize: Integer;
  xorBitsSize, andBitsSize: Integer;
  sbih: BITMAPINFOHEADER;
  dbih: ^BITMAPINFOHEADER;
  resbitsSize: DWORD;
  resbits: Pointer;

begin
  Result := 0;
  Try
    if not GetIconInfo(SmallerIcon, SmallerIconInfo) then begin
      exit;
    end;
    Try
      GetDIBheaderAndBits(SmallerIconInfo.hbmColor, sbih, Pointer(sBits));
      if Assigned(sBits) then begin
        Try
          if (sbih.biWidth>IconSize) or (sbih.biHeight>IconSize) or (sbih.biPlanes<>1) or (sbih.biBitCount<>32) then begin
            exit;
          end;

          xorScanSize := BytesPerScanline(IconSize, 32, 32);
          Assert(xorScanSize=SizeOf(DWORD)*IconSize);
          andScanSize := BytesPerScanline(IconSize, 1, 32);
          xorBitsSize := IconSize*xorScanSize;
          andBitsSize := IconSize*andScanSize;
          resbitsSize := SizeOf(BITMAPINFOHEADER) + xorBitsSize + andBitsSize;
          resbits := AllocMem(resbitsSize);//AllocMem zeroises the memory
          Try
            dbih := resbits;
            InitialiseBitmapInfoHeader(dbih^);

            xorBits := resbits;
            inc(PByte(xorBits), SizeOf(BITMAPINFOHEADER));
            CreateXORbitmap(sbih, dbih^, sBits, xorBits);

            //don''t need to fill in the mask bitmap when using RGBA
            Result := CreateIconFromResourceEx(resbits, resbitsSize, True, $00030000, IconSize, IconSize, LR_DEFAULTCOLOR);
          Finally
            FreeMem(resbits);
          End;
        Finally
          FreeMem(sBits);
        End;
      end;
    Finally
      if SmallerIconInfo.hbmMask<>0 then begin
        DeleteObject(SmallerIconInfo.hbmMask);
      end;
      if SmallerIconInfo.hbmColor<>0 then begin
        DeleteObject(SmallerIconInfo.hbmColor);
      end;
    End;
  Finally
    DestroyIcon(SmallerIcon);
  End;
end;

function LoadIconResourceSize(const ResourceName: string; IconSize: Integer): HICON;//will not throw an exception

  function LoadImage(IconSize: Integer): HICON;
  begin
    Result := Windows.LoadImage(HInstance, PChar(ResourceName), IMAGE_ICON, IconSize, IconSize, LR_DEFAULTCOLOR);
  end;

type
  TGrpIconDir = packed record
    idReserved: Word;
    idType: Word;
    idCount: Word;
  end;

  TGrpIconDirEntry = packed record
    bWidth: Byte;
    bHeight: Byte;
    bColorCount: Byte;
    bReserved: Byte;
    wPlanes: Word;
    wBitCount: Word;
    dwBytesInRes: DWORD;
    wID: WORD;
  end;

var
  i, BestAvailableIconSize, ThisSize: Integer;
  ResourceNameWide: WideString;
  Stream: TResourceStream;
  IconDir: TGrpIconDir;
  IconDirEntry: TGrpIconDirEntry;

begin
  //LoadIconWithScaleDown does high quality scaling and so we simply use it if it''s available
  ResourceNameWide := ResourceName;
  if Succeeded(LoadIconWithScaleDown(HInstance, PWideChar(ResourceNameWide), IconSize, IconSize, Result)) then begin
    exit;
  end;

  //XP: find the closest sized smaller icon and draw without stretching onto the centre of a canvas of the right size
  Try
    Stream := TResourceStream.Create(HInstance, ResourceName, RT_GROUP_ICON);
    Try
      Stream.Read(IconDir, SizeOf(IconDir));
      Assert(IconDir.idCount>0);
      BestAvailableIconSize := high(BestAvailableIconSize);
      for i := 0 to IconDir.idCount-1 do begin
        Stream.Read(IconDirEntry, SizeOf(IconDirEntry));
        Assert(IconDirEntry.bWidth=IconDirEntry.bHeight);
        ThisSize := IconDirEntry.bHeight;
        if ThisSize=0 then begin//indicates a 256px icon
          continue;
        end;
        if ThisSize=IconSize then begin
          //a perfect match, no need to continue
          Result := LoadImage(IconSize);
          exit;
        end else if ThisSize<IconSize then begin
          //we''re looking for the closest sized smaller icon
          if BestAvailableIconSize<IconSize then begin
            //we''ve already found one smaller
            BestAvailableIconSize := Max(ThisSize, BestAvailableIconSize);
          end else begin
            //this is the first one that is smaller
            BestAvailableIconSize := ThisSize;
          end;
        end;
      end;
      if BestAvailableIconSize<IconSize then begin
        Result := CreateIconFromSmallerIcon(IconSize, LoadImage(BestAvailableIconSize));
        if Result<>0 then begin
          exit;
        end;
      end;
    Finally
      FreeAndNil(Stream);
    End;
  Except
    ;//swallow because this routine is contracted not to throw exceptions
  End;

  //final fallback: make do without
  Result := 0;
end;

function LoadIconResourceMetric(const ResourceName: string; IconMetric: Integer): HICON;
begin
  Result := LoadIconResourceSize(ResourceName, IconSizeFromMetric(IconMetric));
end;

end.

Usar estas funciones es bastante obvio. Suponen que el recurso se encuentra en el mismo módulo que el código. El código podría generalizarse fácilmente para recibir un HMODULE en caso de que necesite soporte para ese nivel de generalidad.

Llame a LoadIconResourceMetric si desea cargar iconos de tamaño igual al icono pequeño del sistema o al icono grande del sistema. El parámetro IconMetric debe ser ICON_SMALL o ICON_BIG . Para barras de herramientas, menús e iconos de notificación, se debe usar ICON_SMALL .

Si desea especificar el tamaño del icono en términos absolutos, use LoadIconResourceSize .

Estas funciones devuelven un HICON . Por supuesto, puede asignar esto a la propiedad Handle de una instancia de TIcon . Es más probable que desee agregar a una lista de imágenes. La forma más sencilla de hacerlo es llamar a ImageList_AddIcon pasando el Handle de la instancia TImageList .

Nota 1: las versiones anteriores de Delphi no tienen definido CommCtrl en CommCtrl . Para tales versiones de Delphi necesita llamar a GetProcAddress para cargarlo. Tenga en cuenta que esta es una API única de Unicode, por lo que debe enviarle un PWideChar para el nombre del recurso. De esta manera: LoadIconWithScaleDown(..., PWideChar(WideString(ResourceName)),...) .

Nota 2: La definición de LoadIconWithScaleDown es defectuosa. Si lo llama después de que se haya inicializado la biblioteca de controles comunes, entonces no tendrá problemas. Sin embargo, si llama a la función desde el principio en la vida de su proceso, entonces LoadIconWithScaleDown puede fallar. Acabo de presentar QC#101000 para informar este problema. Nuevamente, si está afligido por esto, entonces tiene que llamar a GetProcAddress usted mismo.