FAQ

void CMyWin::PreCreate(CREATESTRUCT &cs)
{
  // Sets the CREATESTRUCT parameters prior to window creation
  cs.style = 0; // No WS_VISIBLE style is set
}

CFrameApp* pApp = (CFrameApp*)GetApp();
CStatusBar* pStatus = pApp->GetMainFrame()->GetStatusBar();

If the NO_USING_NAMESPACE macro is defined, the Win32xx namespace will not be added to the global namespace.

How can I tell what type of window a CWnd or HWND is?

We can use dynamic cast to identify the type of CWnd our CWnd* points to. For example:

if ( dynamic_cast<CToolBar*>(pWnd) )
{
  TRACE( _T("pWnd is a CToolBar*\n") );
}

if (lstrcmp(GetParent()->GetClassName(), _T("ReBarWindow32")) == 0)
{
  TRACE( _T("The Parent window is a ReBar control\n") );
}

Should I use PostMessage or SendMessage, and what is the difference?

The SendMessage function calls the window procedure for the specified window and does not return until the window procedure has processed the message. The PostMessage function places (posts) a message in the message queue associated with the thread that created the window and returns without waiting for the thread to process the message.

Normally we would use SendMessage for windows in the current thread, and PostMessage for windows in a different thread. In multi-threaded applications it is usually undesirable to hold up a thread with a window, waiting for a window in a different thread to respond.

How do I get a WM_LBUTTONDBLCLK message for left button double clicks?

The CS_DBLCLKS class style allows the window to send the WM_LBUTTONDBLCLK message in response to a double left button click. Use the PreRegisterClass to register a window class with the CS_DBLCLKS style.

How do I add icons to menu items?

There are two functions used to add icons to menu items. The AddMenuIcons functions adds a group of icons to menu items from a bitmap, and AddMenuIcon adds an individual icon.

How do I theme my popup menu?

The CWnd we specify in TrackPopupMenu or TrackPopupMenuEx receives notifications from the menu. When we specify CFrame's CWnd in these functions, CFrame will perform the drawing of the menu for us.

How do I create a Wizard?

A wizard is a type of property sheet. Wizards are designed to present pages one at a time in a sequence that is controlled by the application. Refer to the propertysheet sample for a demonstration of how to create a wizard..

How do I avoid memory leaks?

Memory leaks are generated when memory is allocated from the heap, and not returned properly. C++ code we should always allocate dynamic memory by using new, and delete it with delete, or delete[] for arrays.

It is wise to store the pointer returned by new in a smart pointer. Shared_Ptr is a smart pointer provided by the Win32++ framework for this purpose. It can be safely stored in a vector. Storing the pointer in a smart pointer like Shared_Ptr eliminates the need for delete. The Shared_Ptr deletes the pointer for us when it goes out of scope. Storing the pointer in a smart pointer also helps ensure the code doesn't leak memory in the event of an exception, without additional of try catch blocks.

How do I test for memory leaks?

If you are using a Microsoft compiler, Visual Leak Detector can be used to identify memory leaks. Visual Leak Detector is a free utility. It can be downloaded from https://vld.codeplex.com/.

How do I avoid GDI resource leaks?

GDI resources are limited. If the code leaks GDI resources, it will ultimately fail when no more GDI resources are available. The best way to avoid GDI leaks is to use the CDC and GDI object classes provided with Win32++. These automatically release the device contexts and GDI resources.

How do I check if my program is leaking memory or GDI resources?

The window's taskmgr.exe is a very useful tool for identifying memory leaks and GDI resource leaks. It ships with windows and can be configured to display extra columns including GDI objects and working set memory.

If the amount of memory used or number of GDI objects increase without limit when we do things like resize the window, we have a leak.

Why does my program assert?

Asserts are only triggered in debug mode. They are always caused by programming errors, so the cause of the assert should be identified and fixed.

Win32++ will assert to warn that the library has been used improperly. The following sorts of things will cause Win32++ to assert.

• A CWnd creating a window, when it already has a window assigned to it. If this is intended, the current window should be destroyed first.
• A CWnd performing a window operation (such as ShowWindow) before the window is created.
• Attaching a GDI handle (e.g. a HPEN) to a CGDIObject when it already has a handle attached. If this is intended, the current handle should be deleted or detached first.

Remember asserts our our friend. They give us early warning of bugs that might otherwise go unnoticed or be difficult to track down. They help us build robust, reliable code. For this reason, they should be used liberally in the code we write.

Why does my program throw an exception?

Exceptions should indicate that an unexpected error occurred. They may not necessarily indicate a programming error, but programming errors can certainly cause exceptions. If the exception is "handled", the program will continue to run. If the exception is unhandled, the program will abort. For example, C++ will generate an exception if an attempt to allocate memory dynamically using "new" fails.

Win32++ generates an exception when an attempt to create a window fails (in which case it will attempt to indicate why). It will also generate and handle an exception if an attempt to save values in the registry fails.

You may choose to generate and handle exceptions in your own code. As the name suggests though, the generation of exceptions should be the exception, not the rule.

Why are none of my resources working?

Resources are defined in a resource script file, often called "resource.rc" This file needs to be added to the set of files compiled by our compiler.

How do I avoid flicker in my program?

Flicker is an annoying visual effect caused when a window is rapidly redrawn differently. It may show up when we resize the window. Depending on the cause of the flicker, these techniques might help.

• Use double buffering. With this technique we do all the drawing on a memory device context. When the drawing is complete, copy this to the window with BitBlt so we only draw to the window once.
• Suppress the redrawing of the window background by handling OnEraseBkgnd.
• Use DeferWindowPos to reposition a set of windows simultaneously.
• Avoid invalidating the window unnecessarily.
• Use of SetRedraw to turn window drawing off and on.

/////////////////////////////////////////////////////////////////////////////
//
// RT_MANIFEST
//

1                       RT_MANIFEST             "res/Win32++.manifest"

virtual CToolBar* GetToolBar() const
{
  return const_cast<CMyToolBar*>(&m;_MyToolBar);
}

CMainFrame will now use your CMyToolBar class in place of CToolBar. You could use the same technique for overriding CStatusBar.

How do I implement a wait cursor?

SetCurser is the Windows API function which sets the cursor. By default, windows will set the cursor back to the one defined in the window class each time the mouse is moved. We can handle the WM_SETCURSOR message to determine which cursor should be displayed when the mouse is moved.

We can implement a wait cursor like this:

void CView::DoWaitCursor(BOOL bWait)
{
  m_bWait = bWait;	// m_bWait is a member variable

  if (m_bWait)
    SetCursor(LoadCursor(NULL, IDC_WAIT));
  else
    SetCursor(LoadCursor(NULL, IDC_ARROW));
}

	
LRESULT CView::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
  {
  case WM_SETCURSOR:
    if (m_bWait)
    {
        SetCursor(LoadCursor(NULL, IDC_WAIT));
			
        // Prevent setting the cursor back to default
        return 0L;
    }
    else
      SetCursor(LoadCursor(NULL, IDC_ARROW));
		
    break;
  }
	
  // Do default processing for other messages
  return WndProcDefault(uMsg, wParam, lParam);
}

How do I create a vertical ToolBar?

There are two rather similar methods for achieving this:

Method 1:

• Define a toolbar as you would for a horizontal toolbar
• Add the CCS_LEFT (or CCS_VERT or CCS_RIGHT styles)
• Add the TBSTATE_WRAP style to each ToolBar button.

The ToolBar will be automatically placed on the side of the parent window, specified by the style (e.g CCS_LEFT).

Method 2:

• Define a toolbar as you would for a horizontal toolbar
• Add the CCS_LEFT (or CCS_VERT or CCS_RIGHT styles)
• Add the TBSTATE_WRAP style to each ToolBar button.
• Position the ToolBar manually using SetWindowPos

Note:

• Method 2 is required for vertical ToolBars within ReBars
• CCS_NODIVIDER can be added to suppress the drawing of the ToolBar's divider
• Use DeferWindowPos to reposition a group of windows simultaneously.