Both icons sizes are new in Windows XP. Their use is the following:

• 24x24 (true color) icon is used in start menu (right-side panel).
• 48x48 (true color) icon is used as thumbnail image in Windows Explorer. Notice that in Window 2K it was usually enough to have 32x32, and 16x16 16-color icons for your application. Windows XP had dramitically changed this picture, and MFC application icon generated by default with MFC application wizard has 9 icons (16x16, 32x32, 48x48 with 16, 256, 16 millions colors) instead of two.

From programming perspective, Windows 2K requires just two icons: 32x32 (16-color) and 16x16 (16-color). Look at icons that Visual Studio 98 provides for MFC applications by default:

Both in Window Windows 2K and XP, 16x16 icons are used as/at:

1. Application title bar.
2. Start/Programs (right side).
3. Window Explorer's small icons view (also list, details views).
4. System tray controls.
5. Status bar (when minimized).
6. Add/Remove programs list.

Windows selects the icon with lowest resource ID as application icon. You can see what icon has lowest resource ID in resource.h.

When an application registeres its own file type in registry, it can setup DefaultIcon registry key under HKCR\<applicationtype> and specify file type icon by setting <iconnumber>:

Value Name: (Default)
Value Key: <name>.exe, <iconnumber>

In this case icon number is not a resource ID, but one-based number of icon resource listed in RC file counted from the begining of the icon resources list!

Windows XP introduced new control styles with rounded angles and dynamic appearance. Compare:

That's it. You don't even need to derive your dialog classes from CDhmlDialog to use Windows XP control styles!

Interestigly, the locations of version 5 and version 6 of comctl32.dll on Windows XP are different. While older version located in %windir%/system32, the newer version located inside %windir%/WinSxS.

You might need a "conversion" of CWnd pointer to HWND handle when Win32 funtions are used in MFC application. Because every MFC window class derived from CWnd and CWnd has m_hWnd member, the answer to the first part of the question is to use m_hWnd. As simple as that!

To obtain CWnd from HWND, there is a little bit more complicated standard solution: use FromHandle member function of CWnd, which returns pointer to CWnd provided that HWND handle passed as an argument.

To update dialog class data from dialog UI data use:

UpdateData(TRUE);

To make an update in opposite direction, i.e. update values of controls in dialog UI from dialog class data, use:

UpdateData(FALSE);

Recall that dynamic linking relies on calling two functions: LoadLibrary, which returns a handle to a DLL, and GetProcAddress, which returns an address of a function having a DLL's handle. There are two major benefits for dynamic linking:

• There is no need in LIB file. In opposite, while doing implicit linking you should statically link LIB satellite of a DLL in project settings.
• Dynamic linking can dramatically reduce memory that a program takes. For example, if a user of your program can select with UI one module (DLL) at a time from a list of many optional DLLs the choice of dynamic linking would be right. Why? This is because once a program is started all implicitly linked DLL are loaded into memory even if they would have not be ever used. In opposite, a library linked dynamically loaded into memory when a program really needs it, and unloaded (it is programmer responsibility not to forget it!) when there is no longer need in it.
  
  Notice that resource-only DLLs are, in fact, always loaded dynamically. They do not have LIB-file (/NOENTRY linker option must be specified to say linker that a DLL does not have functions). Such DLLs are loaded simply with a LoadLibrary call, and subsequent calls to functions like LoadResource, LoadString etc, which are used to load resources required.

You might need bulk GUID generation when, for example, you've decided to use GUID as registration code for your program, and need to generate a lot for different users. The solution is to use uuidgen command line utility:

uuidgen -n100 > c:\guids.txt

The output is like:

30295ce5-a175-4a83-84b1-d6fa12b24bb6
853b045e-d02f-4d98-8119-e32f189cd7af
6fe48533-1ea1-46a5-aecc-7db2c03734b1
45131cd4-1b46-4b07-bb6f-277ccca0af40
177e257f-42fc-415b-a891-3fd768040f9f
...

Notice that uuidgen.exe can be located under:

%programfiles%\Microsoft Visual Studio .NET 2003\Common7\Tools (VS.NET 2003)
%programfiles%\Microsoft Visual Studio\Common\Tools (VS'98)

Unfortunately, MFC does not provide a separate class for directory picker (or folder picker). Interestingly, this kind of UI is pretty popular. Directory picker is a feature of WinZip, WinZip Self-Extractor etc. You can find it even in Microsoft VS.NET 2003, written in C++: go to File/New/New Project, then click on Browse button to bring up Project Location, which is directory picker UI!

So, how to implement directory picker in your own program? There are 2 solutions:

• Modify standard MFC CFileDialog, which by default provides functionality for File Open, Save As actions, by using custom dialog template or/and dialog hook procedure.
• Write your own directory picker class using SHBrowseForFolder function.

In C++ project, you can use simple Image Editor that bundled with VS.NET, and available also in previous versions. A trick to make image backgroung color transparent, or other words force this color to take destination colors, takes two steps:

• Paint designated areas with a special system color called "screen color".
• Repeat previous step for all icon images (or devices).

Standard icon file is composed of several bitmap files (BMP). The number of files depend on operation system you are using.
Generally you need source BMP files and a program tool to make a single ICO file. You can download trial versions:

Icon Book (version 4.22 at the time of writing)
GIF Movie Gear (version 4.02 at the time)

First tool is an icon browser, it also provides sample icon collections. The secong tool converts a set of images into a single ICO file. Here are the simple steps to create an icon:

• Open dll, exe etc file containing icons (i.e. shell32.dll) in IconBook. IconBook shows all images for an icon in separate window. For example, if your OS is Windows XP and you choose an icon, the window shows 12 separate images depending on image size an color depth:
  
  48x48, 32x32, 24x24, 16x16 (24-bit color)
  48x48, 32x32, 24x24, 16x16 (16-bit color, or 256 colors)
  48x48, 32x32, 24x24, 16x16 (4-bit color, or 16 colors)
  
  
• Open Movie Gear (you can start from any icon file).
• In IconBook choose an image of necessary size/color depth and copy/paste it into Movie Gear. Choose next image of different size/color depth and copy/paste it too.
• If sure that you have all required images save the set of Movie Gear images as ICO file.

This operation is opposite to extracting low-word/high-word parts from DWORD value performed by LOWORD, HIWORD macros. One example when you might need this conversion is to persist application hot keys into the registry. In fact, registry has REG_DWORD type, but does not have a type for WORD. On the other hand, if you use CHotKeyCtrl control you would extract hotkey value by the code like this:

WORD wVirtualKey;
WORD wModifier;
m_ctlHotKey.GetHotKey(wVirtualKey, wModifier);

Notice that wVirtualKey and wModifier are both WORD values. Naturally, it is convenient to store in registry one value instead of two. The following macros gives the answer:

DWORD dwValue = MAKELONG(<low-order word>, <hi-order word>);

This task might be demanding when you need, for example, update controls state in one property page immediately after changes were made in another property page.The answer is to call member function CPropertyPage::QueryPages in the controling page and intercept PSM_QUERYSIBLINGS related event in the listening page. In MFC, another words, message map should be updated with new element:

ON_MESSAGE(PSM_QUERYSIBLINGS, OnQuerySiblings)

Notice that it is logical to guess that for this purpose one simply should use a pointer to another property page. Seeing following picture, you can futher suggest that if CPropertyPage2 has back pointer to CPropertySheet, which aggregates property pages, this pointer can be used for navigation to CPropertyPage1.



Interestingly, MFC does not provide member functions/properties to get a back pointer or directly obtain a pointer to page of interest. The CPropertyPage::QueryPages should be used instead.

.PCH files can eat up more then 50-60% of hard disk space taken by your VC++ project files. Likely the next biggest disk space eaters are .BSC, .SBR, .PDB, .IDB, .NCB, and .OBJ files. If you systematically backup your project files with these unnecessary files, you are wasting about 75-80% of your space on backup media!

You can find/delete these files manually, or you can make a batch file with following lines to delete redundant files in root project folder, release, and debug folders correspondingly:

for %%c in
(*.ncb *.opt *.aps *.clw *.dsw *.dep *.tlh *.tli)
do del %%c

for %%c in
(*.pch *.idb *.obj *.res *.dep *.tlh *.tli)
do del %%c

for %%c in
(*.pch *.idb *.pdb *.sbr *.bsc *.obj *.res *.ilk *.map *.pbi *.pbt *.pbo *.tlh *.tli)
do del %%c

C-strings are C/C++ character arrays. This is an important notion sometimes missed by novice programmers. C/C++ does not have a special fundamental data type for C-strings. In practical terms, one of the most frequenly features of C/C++ arrays used with C-strings is that the name of array is also a constant pointer to the first element in array (since arrays are zero-based, it is actually a pointer to its zero member).

As an example, consider the strcpy function signature:

char* strcpy(char* szDestination, const char* szSource);

We make a routine copy like this:

char szSource[] = "Source";
char szDestination[100];
strcpy(szDestination, szSource);

Did you notice that you just used array name "szSource" as argument in function, which has const char* type. Again, this is because the name of C-string is also a constant pointer!

dynamic_cast and static_cast are both used for downcasts in a class hierarchy, and can be used, albeit it is not necessary, for upcasts (generally, upcasts are implicit casts). Albeit, static_cast and dynamic_cast are close in meaning and use, they are different when dealing with polymorphic base classes (i.e. classes that have virtual functions). If base class is polymorphic:

• dynamic_cast should be used for downcast while use of static_cast is not recommended (as not safe).
• dynamic_cast makes run-time check (static_cast does not). Notice that to enable run-time check /GR compiler option should be set (instead of /GR- default option).
• dynamic_cast can be used only if base class is polymorphic (otherwise compiler generates an error). static_cast can be used both with polymorfic and non-polymorfic classes.

The length is 10 (9+1). The count includes also NULL-terminating string ('\0'), which accounts for one additional character regardless of _UNICODE is defined or not.

If _UNICODE is defined the size is 20 bytes because _UNICODE character takes 2 bytes. If _UNICODE is not defined the declaration is equivalent to:

char szString[] = "Armadillo";

In this case, the size of szString is 10 bytes because ANSI character takes 1 byte.

These reasons are general, and C-strings function prototypes can demonstrate them. For example, the function to copy C-strings, strcpy, has a prototype:

char* strcpy(char* pszDestination, const char* pszSource);

By declaring the second parameter as const, two results are achived:

• The function cannot change corresponding parameter in the caller function when called function returns. This provides a level of safery for the caller function when it is necessary to have a guarantee that its parameters would not be changed. Recall that in C/C++ function can return values not only with explicit return statement, but also through the parameters in parameter list.
• In a case when you, as a programmer, lack information about what parameter(s) is(are) input parameter(s) in a function, the const keyword brings indication that parameter in question is an input parameter.

Here is the sample to initialize two pointers to character 
strings:

class A
{
public:
        A(LPCTSTR lpszName, LPCTSTR lpszDesc = NULL) : 
                m_lpszName(lpszName), m_pszDesc(pszDesc){}
        ~A();
private:
        LPCTSTR m_lpszName;
        LPCTSTR m_lpszDesc;
};

The second pointer takes default value NULL if one value only is 
passed to the constructor. Notice that constructor is suffixed
by curly brackets without semicolon (function with a body is not
required to be terminated by semicolon).

or when constructor defined separately:

class A
{
public:
        A(LPCTSTR pszName, LPCTSTR pszDesc = NULL);
        ~A();
private:
        LPCTSTR m_lpszName;
        LPCTSTR m_lpszDesc;
};

A::A(LPCTSTR pszName, LPCTSTR pszDesc = NULL) : 
        m_lpszName(lpszName), m_lpszDesc(lpszDesc)
{

}

Notice that it is not necessary to initiliaze data members inside 
constructor body explicitly (e.g. m_pszName = pszName; 
m_pszDesc = pszDesc).

_TCHAR (TCHAR) types, and _T(_TEXT), L macros are used for UNICODE builds only. Don't use these macros for non-UNICODE builds. If you are using UNICODE builds take notice of the following:

• There is no difference between _TCHAR and TCHAR. They are both declare 2-byte character strings (wchar_t) for UNICODE builds and 1-byte character strings (char) for non-UNICODE builds. _TCHAR notation, however, is more frequently used in the MSDN (2003) documentation.
• There is no difference between _T (_T is just the short form of _TEXT) and L macros for UNICODE builds. In fact, _T defined as L macro for these builds. They are both transform 1-byte character string to 2-byte character string. In non-UNICODE builds _T macro is removed, i.e. has no effect, during build process. Don't use L macro in non-UNICODE builds since an error will occur.
• UNICODE builds are default builds in Visual Studio NET (2003) in opposite to non-UNICODE default builds in Visual C++ 6.0.

The following sample is the answer:

TCHAR szValue[80];
lstrcpy(szValue, "\"C:\\Program Files\\Synaptex\\SSS\\SSLauncher.exe\" /startup");

Notice that when path containing spaces should be passed to command line interpreter, it should be decorated with trailing double quotes.

You might have not expected it, but there are no separate classes for Check Box and Radio Button in MFC. In fact, these controls are of CButton type! Notice that Group Box is also managed by CButton class.

Icons are like bitmaps, but they are usually having more then one bitmap image inside with each of images used by different devices. Think about an application icon: the icon should point to the application in both views of Windows Explorer Small Icons/Large Icons, which use 16x16 and 32x32-icons respectively. If you'd place application shortcut on the desktop, 32x32 application icon will be used. 16x16 icon is used in the Start menu. As you can see, usually you need to provide for your application the same picture, but with different sizes. ICO-format lets have in one file these different images so that you delegate to Windows system to decide what image to use depending on the context.

When you create new Win32 project with "Win32 Application" wizard, you'd have standard 16x16 Win32 icon at the left of the title bar. If you'd place application shortcut on the desktop 32x32 icon will be used. Both icons are provided by Win32 system by default: a Win32 application can be as simple as to have only empty WinMain function. In the wizard-generated project there is no resouce file (RC), and naturally Resouce View is empty for a project. To add your own icon use the following steps:

• Go to File/New and choose Resource Script. Usually you would choose <projectname> as the name for the resouce script. At this point non-empty <projectname>.rc and resource.h will be added to the project folder.
• Compile project.
• If you open Resource View you would not see resource folders, as you might expect from your MFC experience. Instead you would see <projectname>.rc folder in the right pane. To browse resources in the Resource View close VC IDE, launch it again and open Win32 project. You would see in the Resouce View <projectname> folder now. Since it is empty it expands to "No Resources".
• Add new icon resource. Set ID for the resource, it is IDR_MAINFRAME usually. This ID Win32 is using by default for an application icon.
• At first Image Editor has 32x32 icon. Draw it as you wish. Add 16x16 device and draw it too.
• Compile.

C++ provides that one function can be declared with different parameter list within the same program. C++ calls this mechanism function overloading. To distinguish these declarations internally, C++ compilers decorate function names (generally different compilers decorate the same function names differently). Notice that name decoration (name mangling is another term) is a C++ feature, not C feature. If your program does not use function overloading you can tell compiler not to produce name decorations for functions by specifying extern "C" before the name of every exported function.

Hooks.

Set normal styles - WS_* and LVS_* - in dwStyle (in any relative order), and extended styles - WS_EX_*, LVS_EX_* - in dwExStyle (in any relative order).

You need to do two changes. First, open project definition file (<projectname>.def) and change LIBRARY "<projectname>.OCX" to LIBRARY "<projectname>.DLL". Second, go to Project/Settings, choose Link tab and change Release/<projectname>.ocx to Release/<projectname>.dll. If you are working in debug mode make the same changes.

In practical terms, preemptive (having power to preempt) means that the system can force an application to share processor with other applications according to own system rules. Webster links "preempt" to "acquire", "seize", "replace", "prevent" e.g. "replace with something considered to be of greater value or priority".

Preemptive multitasking received a full support in Windows NT (and was inherited by Windows 2K/XP/Vista), and was introduced to replace collaborative multitasking in Window 3.x. Formerly preemptive multitasking was known as an important new feature of Window 95 and 98. The earlier versions of Windows had some traces of preemptive multitasking, but were not truly systems with preemptive multitasking.

The problem with collaborative multitasking was that the program author could assign as much processor resources as he wanted to own program (albeit it was rather hypothetical opportunity not recommended by Microsoft). In the result, some authors assigned too much resources to own application so that other applications could not run at all or run very slowly, or even the whole system stalled.

In contrast, the preemptive multitasking system manages assignment of processor times assigned to applications by its own.

Short answer: 5

ATL proxy generator generates CProxy_I<sourceinterfacename> class (Connection Point Object) that calls IDispatch:Invoke with DISPID passed explicitly. Thus, default implementation of connection points in ATL means early binding.

For in-proc server (DLL):

HKCR/CLSID/{clsid}/InprocServer32

For local server (EXE):

HKCR/CLSID/{clsid}/LocalServer32

These entries must show a full path to local DLL or EXE.

Automation is a mechanism that provides communication between programs (components) written in different programming languages. From a technical standpoint, automation implies implementing dispatch interface (IDispatch) both on a server and on a client, and reliance on server's type library.

As mush as polimorphism in C++ relates to use of virtual keyword, automation in COM relates to IDispatch interface and type library.

In MFC, CCmdTarget implements IUnknown interface that must base interface for any automation interface.

Apart from C++, virtual means "non-existent". In C++, virtual functions might be non-existent, i.e. they can be declared, but no implementation is provided (as with abstract virtual functions). Such functions, in a sense "do not not exist" until they are overridden in a derived class, albeit they are declared. On the other hand, non-abstract virtual functions, which are the regular case, are provided with default implementation in a base class. In this case, the term "virtual" refers to the concept that exact implementaion of the virtual function will be selected at the run-time - exact reference to implementation of virtual function "do not exists" until run-time - based on implementations of the function in derived classes and the default implmementation in the base class.

Virtual keyword lets avoid creating more then one instance of a base class in a scheme with multiple inheritance. If class D inherits from classes B and C, and both classes B and C inherit from A, then two instances of base class A created when D class is created. To avoid this, B and C classes must inherit virtually from A:

class B: virtual public A {...};
class C: virtual public A {...};

In practical terms, the static keyword used in the following situations:

1) An application needs a several instances of a class, and some variables must have values shared among all instances, i.e. a counter variable that holds the number of class instances must be declared static.

2) A program implements Win32 function that is using callback function, which in turn should call members of a class. Win32 function callback functions are static (declared globally) and therefore cannot access other class members. One way to let callback function to do that is to use static preudo-this pointer.

For example, an application implements Win32 timer function that calls custom UpdateData callback function every m_nUpdateInterval milliseconds:

SetTimer( NULL, NULL, m_nUpdateInterval, (TIMERPROC)UpdateData );

Callback function UpdateData with pre-defined prototype should be declared static in order to access static pseudo-this pointer declared in a class:

static UINT CALLBACK UpdateData( HWND hWnd, UINT uMsg, UINT idEvent, DWORD dwTime );

When using the static keyword have in mind the following:

• The static keyword is a C++ feature, absent in pure C.
• If a class member function declared static, it can not use this pointer to access other class members. It can only access static members. One of the workarounds is to use custom preudo this pointer that holds this pointer in a static variable.
• Though static variable can be a class member it should be treated quite separately. Even if a class was not instantiated with any variable, you can access a static variable declared in a class: <classname>::<varname> anywhere in a program (see sample Static Data Members).
• Static variable declared in a class must be defined outside of a class (on file level).
• Static variables are automatically initialized to zero.
• Static keyword applied to class member data and functions, but not to classes.

MFC regular DLL:

• Can be shipped both for C/C++ (non-MFC) and MFC applications.
• MFC used internally only.
• The program structure design reminds you about regular application (EXE) design: DLL's class derived from CWinApp, you can override virtual InitInstance() and ExitInstance() functions to initialize/free resources in DLL.
• Includes both _USRDLL and _AFXDLL preprocessor directives

Command messages are designed to handle menu, toolbar, accelerator events - so-called "user interface events". Also command messages generated when something interesting occurs with base windows controls - edit, list box, static, button, check box, radio button etc - simple windows controls inherited from Windows 3.x. These controls are different from windows common controls such as List, Tree, Tab, Month Calendar, Date Time Picker and the others that were added when Windows NT came into the scene. Common controls generate notification message to their parent window. WM_COMMAND and WM_NOTIFY, as we see, serve the same purpose for base and common controls, but must be handled differently. Both messages pass valuable information in wParam/lParam, but content of these parameters is different. For WM_COMMAND messages double-word wParam pass base control ID in its low-word part of wParam. On another hand, ID of a common control take whole space of wParam. This is one the reasons why an older Win16 program designed for Windows 3.x might crash on Windows NT/2000.

Paste a line:

cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing;

after ParseCommandLine(cmdInfo) in InitInstance() function of your application class.

See sample and comments here.

These are four functions: default constructor, default destructor, copy constructor, overloaded assignment operator.

Private data members are most secured class data members compared to data members with public and protected access specifiers. Normally only access functions of a class can get their values. Protected data members bear no difference to private data members except they can be accessed in derived class.

Both private and protected data members can be accessed by member access functions of a friend class. Note that both can not be accessed directly using reference to a class. Only access functions can reach them.

C++ static variable can be a class member and hence shares class access rules: it can be declared public, private or protected. Though standard global variables are defined on file scope, as static variables, they can not be declared private (or public, protected).

Question might sound simplistic, but you can not rename a VC++ project in a way you would rename a file or a folder. VC++ <projectname> string have multiple instances inside .dsp file and therefore multiple lines should be renamed. VC++ IDE does not provide an option to rename a project. You can do it manuallly however. Open DSP file in a text editor and rename old entries <oldprojectname> to <newprojectname> down to the lines that discribe project source file.

This is to avoid accidental inclusion of a file into the project more then once. IDE generates a GUID-like name for a file which prefixed with AFX_filename_H__, has unique GUID (with signature 8-4-4-4-12) in the middle and suffixed by __INCLUDED_. Once IDE-generated the name is guaranted unique and therefore this iclusion quaranties from making accidental redundunt inclusions.

By default, member access in struct is public, but in class is private. Or, another words, default access to class members is limited, while default access to struct members is not.

SendMessage does not return immediately, it waits until a thread would process a message. Only when message is processed SendMessage returns, and calling thread resumes its work.

PostMessage, unlike SendMessage, returns immediately, it does not care if processed or not.

These methods are 3 methods of IUnknown interface:

(1) QueryInterface;
(2) AddRef;
(3) Release;

The pointers to these methods are on top of VTable. Any custom methods located beneath 3 methods of IUnknown interface.