Setting the resize limits for a client window

By Bill Lamkin

Most Windows applications allow users to resize their main client window. To do so, users simply press the mouse button with the cursor over the window's border, then stretch the border to the new size. These applications allow users to set practically any size they want for the client window.

In some cases, Windows applications shouldn't allow users to resize the client window. For example, none of the common dialog boxes allow users to resize their client window. Their client window simply doesn't supply the wide sizable border of a normal window.

You may think you have only two alternatives: allowing users to specify any size window or not allowing users to change the window size at all. Fortunately, there's a third option.

In this article, we'll show you how to let users resize your application's client window but limit how much they can stretch or shrink the window. To do so, we'll discuss the special WM_GETMINMAXINFO Windows message and its related GETMINMAXINFO structure. Then we'll show you how to respond to this message by using the ObjectWindows 2.0 Message Response Tables.

Sizing up the problem

If you write an application you don't want users to resize, you should specify nonsizable borders. One application that does so is the well-known Windows Calculator application. Figure A shows Calculator, which is found in the Windows Accessories group.

Figure A - You can't modify Calculator's client window size.

As you can see, the Calculator application doesn't allow users to modify its client window size. Because you can't resize its window, the Calculator application's controls will always be visible.

Without this limitation, users may become confused when they can't access important client window information. Figure B shows an Employee application in which a user has resized the client window over some push buttons and edit controls.

Figure B - The Employee application isn't malfunctioning-a user has resized its main client window over some important controls.

Instead of prohibiting all window resizing, you may choose to write your application so it allows limited resizing. In fact, your application can specify minimum and maximum window sizes, and Windows will handle the details for you.

A special message

When a user clicks the left mouse button on a nonclient area of an application, Windows sends the application a WM_NCHITTEST message. Along with this message, Windows sets the wParam variable equal to a constant your application can use to determine exactly which part of the nonclient area the mouse pointer is on.

Users can select several different nonclient areas of an application's main window to resize windows. We've marked these nonclient areas by name in the window shown in Figure C.

Figure C - These are the nonclient areas and their corresponding captions.

If your application lets the DefWndProc() function handle the WM_NCHITTEST message, and that function determines the mouse pointer is in one of the sizing areas we show in Figure C, Windows sends the application a special message:

WM_GETMINMAXINFO

Figure D - This is the MINMAXINFO structure and its related POINT structure.

/* Struct pointed to by WM_GETMINMAXINFO lParam */
typedef struct tagMINMAXINFO
{
    POINT ptReserved;
    POINT ptMaxSize;
    POINT ptMaxPosition;
    POINT ptMinTrackSize;
    POINT ptMaxTrackSize;
} MINMAXINFO;

typedef struct tagPOINT
{
    int x;
    int y;
} POINT;

For example, in a typical window procedure that responds to the WM_GETMINMAXINFO message, you would declare a pointer to a MINMAXINFO structure with something similar to

MINMAXINFO FAR *lpMinMaxInfo;   

Then, inside a switch statement for different message types, you'd set the minimum tracking size by writing

case WM_GETMINMAXINFO:

  // set the MINMAXINFO structure pointer 
  lpMinMaxInfo = (MINMAXINFO FAR *) lParam;
  lpMinMaxInfo->ptMinTrackSize.x = 100;
  lpMinMaxInfo->ptMinTrackSize.y = 100;
  break; 

Listing A: LIMITS.CPP

#include <owl\applicat.h>
#include <owl\checkbox.h>
#include <owl\dc.h>
#include <owl\framewin.h>
#include <owl\owlpch.h>
#include <owl\eventhan.h>

class TLimitsApp : public TApplication
{
  public:
   TLimitsApp(){}
   ~TLimitsApp() {};

   void
   InitMainWindow()
   { SetMainWindow(new TFrameWindow( 0, "Limits")); 
   }

   void
   EvGetMinMaxInfo(MINMAXINFO far & minMaxStruct)
   {
     minMaxStruct.ptMinTrackSize.x =
       100 + (GetSystemMetrics(SM_CXFRAME) * 2);

     minMaxStruct.ptMinTrackSize.y =
       100 + (GetSystemMetrics(SM_CYFRAME) * 2) +
       GetSystemMetrics(SM_CYCAPTION) +
       GetSystemMetrics(SM_CYMENU);

     minMaxStruct.ptMaxTrackSize.x = 300;
     minMaxStruct.ptMaxTrackSize.y = 300;
   }
  DECLARE_RESPONSE_TABLE(TLimitsApp);
};

DEFINE_RESPONSE_TABLE1(TLimitsApp,TApplication)
  EV_WM_GETMINMAXINFO,
END_RESPONSE_TABLE;

int
OwlMain(int /*argc*/, char* /*argv*/ [])
{
  return TLimitsApp ().Run();
}

Listing B: LIMITS.DEF

NAME          LIMITS
DESCRIPTION   'Limit Windows Application'
EXETYPE       WINDOWS
CODE          PRELOAD MOVEABLE
DATA          PRELOAD MOVEABLE MULTIPLE
HEAPSIZE      1024
STACKSIZE     5120