Fitting an Image to a Window

To fit an image to a window, you only have to calculate a display rectangle that fits the window's client area, while preserving the image's aspect ratio. The following code snippets from the EZFUNC example program show how this can be done. (This example code includes some palette handling, which is explained more fully in Handling Palette Changes).

Variable declarations

/* Global declarations */   
RECT rWndSize;   /* RECT for sizing the window. */   
RECT rClientSize;   /* RECT for the client area. */   
RECT rLeadDest;   /* RECT for the destination rectangle for painting. */        
RECT rLeadSource;   /* RECT for the source rectangle for painting. */     
HPALETTE hpalPaint;   /* Paint palette handle. */   
BITMAPHANDLE LeadBitmap;  /* Bitmap handle for the loaded image. */   
L_INT DisplayWidth, DisplayHeight;  /* Dimensions of the displayed image */   
/* Local declarations in the message-processing function */   
PAINTSTRUCT ps; /* Structure for processing the WM_PAINT message */   
HPALETTE hPalette = NULL; /* Temporary copy of the current system palette */   
HDC hdc; /* Device context used with the palette functions */   
int AdjustedWidth, AdjustedHeight; /* Adjusted dimensions of the window */ 

Code that sets the rectangles

In this snippet from the message-processing function, the bitmap (LeadBitmap) has been loaded, but has not been displayed.

/* Get the current window size and client area */   
GetWindowRect(hWnd, &rWndSize);   
/* Use this user-defined function to fit the displayed image in the client area. */   
CalcDisplay (  rClientSize.right,   /* Width allowed */   
               rClientSize.bottom,  /* Height allowed */   
               BITMAPWIDTH(&LeadBitmap),    /* Width factor, for aspect ratio */   
               BITMAPHEIGHT(&LeadBitmap),   /* Height factor, for aspect ratio */      
               NULL,                /* Resulting left value, not used */   
               NULL,                /* Resulting top value, not used */   
               &DisplayWidth,       /* Resulting width value */   
               &DisplayHeight);     /* Resulting height value */   
/* Adjust the window size to remove blank space at the right or bottom */   
AdjustedWidth = rWndSize.right - rWndSize.left + DisplayWidth - rClientSize.right;   
AdjustedHeight = rWndSize.bottom - + DisplayHeight - rClientSize.bottom;   
MoveWindow(hWnd, rWndSize.left,, AdjustedWidth, AdjustedHeight, FALSE);   
/* Get the client area of the adjusted window */   
/* Make the destination rectangle for painting the same as the client area */   
rLeadDest = rClientSize;   
/* Set the source rectangle to use the whole bitmap */   
SetRect(&rLeadSource, 0, 0, LeadBitmap.Width, LeadBitmap.Height); 

Code that paints the image

case WM_PAINT: 
/* Get the handle to the device context */ 
hdc = BeginPaint (hWnd, &ps); 
if (LeadBitmap.Flags.Allocated)  /* Do we have an image? */ 
   if (hpalPaint) /* If we have a paint palette, select it */ 
      hPalette = SelectPalette (hdc, hpalPaint, FALSE); 
      /* Uncomment this if you do not process WM_QUERYNEWPALETTE */ 
      /* RealizePalette (hdc); */ 
   /* Paint the image */ 
   L_PaintDC (hdc, 
   &rLeadSource,   /* Source rectangle */ 
   NULL,           /* Default source clip area */ 
   &rLeadDest,     /* Destination rectangle */ 
   &ps.rcPaint,    /* Dest clip set by WM_PAINT */ 
   SRCCOPY);       /* Normal Paint */ 
   if (hpalPaint)         /* Return the old palette */ 
      SelectPalette (hdc, hPalette, FALSE); 
EndPaint (hWnd, &ps);     /* Return the DC */ 
return (0); 

Local function for calculating the display rectangle



Maximum width.


Maximum height.


For preserving aspect ratio, usually bitmap width.


For preserving aspect ratio, usually bitmap height.


Pass NULL if you do not care about centering. Otherwise, this is updated with the X offset.


Pass NULL if you do not care about centering. Otherwise, this is updated with the Y offset.


Address of the width variable to update.


Address of the height variable to update.

Notes: Use this function to fit a displayed image in a particular space, while preserving the aspect ratio.

void CalcDisplay (L_INT WidthAllowed, L_INT HeightAllowed, 
L_INT WidthFactor, L_INT HeightFactor, 
L_INT *ResultLeft, L_INT *ResultTop, 
L_INT *ResultWidth, L_INT *ResultHeight) 
   /* Local variables for calculating results */ 
   L_INT Left, Top, Width, Height; 
   /* See if using the maximum width will make the image too tall */ 
   if(MulDiv(WidthAllowed, HeightFactor, WidthFactor) < HeightAllowed) 
   { /* Use the maximum width, and calculate the height and top values */ 
      Left = 0; 
      Width = WidthAllowed; 
      Height = MulDiv(Width, HeightFactor, WidthFactor); 
      Top = (HeightAllowed - Height) / 2; 
   { /* Use the maximum height, and calculate the width and left values */ 
      Top = 0; 
      Height = HeightAllowed; 
      Width = MulDiv(Height, WidthFactor, HeightFactor); 
      Left = (WidthAllowed - Width) / 2; 
   /* Update the top and left results, if the caller did not pass NULL */ 
   if (ResultTop != NULL) 
      *ResultTop = Top; 
   if (ResultLeft != NULL) 
      *ResultLeft = Left; 
   /* Update the width and height results */ 
   *ResultWidth = Width; 
   *ResultHeight = Height; 

Help Version 23.0.2024.2.29
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2024 LEAD Technologies, Inc. All Rights Reserved.

LEADTOOLS Raster Imaging C API Help

Products | Support | Contact Us | Intellectual Property Notices
© 1991-2023 LEAD Technologies, Inc. All Rights Reserved.