Prof-UIS is an easy-to-use MFC extension library that enables you to deliver
Windows applications with a professional and user-friendly interface. Prof-UIS
is specially designed to help Visual C++ developers implement advanced UI
facilities in the most effective and easy way: In most cases, to replace the
proper MFC class name with that of Prof-UIS in your code is enough to take full
advantage of Prof-UIS functionality, i.e. CComboBox ->
CExtComboBox. That, combined with an impressive list of key
features, makes Prof-UIS an invaluable tool for GUI development.

Prof-UIS is designed to help Visual C++ programmers save hundreds of hours in
implementing today's most demanded GUI facilities in their applications. This
makes Prof-UIS an invaluable tool for GUI development.

Visual
Studio .NET-like resizable control bar, which optionally shows its contents
while dragging/resizing. Such bars can be placed in all sorts of combinations
relatively to each other both in the main frame window and in the smart floating
containers

Menu bar with automatic support for lists of MRU files and MDI windows, the
system menu for the MDI/SDI main frame and MDI child frame, and the context menu
for application's toolbars and resizable control bars

Powerful "persistent affixment algorithm" which makes Prof-UIS control bars
extremely user-friendly — they can restore their exact positions and sizes after
redocking the bars or resizing the frame

Generalized template window classes for various common tasks like injecting
non-client area borders into any window, providing flicker-free repainting and
anchoring child windows to the borders of their parent window

Multi profile UI persistence and archive-based serialization of UI state,
which supports the command usage statistics. These features are based on the
Command Manager serializable component

Alpha icons for disabled menu and toolbar items used when both the Microsoft
Office 2003 style and high/true color monitor modes are on

The CExtPopupMenuWnd class implements a popup menu. To use it is
no more difficult than the standard CMenu class.

1. Create the CExtPopupMenuWnd object dynamically:

CExtPopupMenuWnd *pPopupWnd = new CExtPopupMenuWnd;

2. Initialize menu items by either loading the menu resource

VERIFY(
pPopupWnd->LoadMenu(
hWnd,
IDR_TEST_POPUP_MENU
)
);

or performing a set of calls to
CExtPopupMenuWnd::ItemInsert()

3. Let us now look at how a new popup submenu can be inserted.

First, create and initialize it by going through Step 1 and Step 2. Then,
call ItemInsertSpecPopup() for inserting a new popup at the
specified position in the existing CExtPopupMenuWnd object. The code below
inserts a color picker menu to the existing menu:

The frequently used or basic commands are those that do not depend on usage
statistics or a number of clicks. All application commands are registered in the
command manager (CExtCmdManager), whose members and methods can be
accessed via the global smart pointer variable g_CmdManager with
operator ->. The SetBasicCommands() method allows
you to replenish the basic commands list. The system commands (from the window's
system menu), OLE commands and the commands relating to MRU files and to MDI
windows are automatically considered to be basic.

In the DRAWCLI sample expandable menus are used. When you open any drop down
menu from the menu bar, the items corresponding to basic commands are only
visible at first. Other items appear only when you click on the Expand button at
the bottom of the menu or when you press CTLT+DOWN_ARROW.

This part of the article describes how Prof-UIS implements the mechanism
responsible for docking its control bars. It also explains the most important
operations on the dockable control bar including how its position is set in a
frame window.

Frame window

A popup frame window that contains a set of control bars in its either docked
or floating state.

Floating container (floating palette, floating frame, mini frame)

A special kind of the frame window that encloses only one child docking bar
window with the AFX_IDW_DOCKBAR_FLOAT dialog control identifier.
The docking bar window encloses one or more control bars. Floating containers
are created and destroyed automatically with the control bar’s drag-and-drop
algorithm.

Control bar

The generalized MFC implementation of the window that can be either fixed to
any of the borders of its parent frame window or floated in the floating
container.

Fixed-size control bar

A fixed-size control bar (e.g. toolbars or menu bars). The size of the fixed
bar in its docked state could not be changed by dragging its borders.

Resizable control bar *

A control bar that can be resized by dragging its borders and docked in the
dynamic control bar containers.

Docking bar

A kind of an MFC control bar which is used as a parent window for all the
control bars with the re-docking feature turned on
(CControlBar::EnableDocking() is used for this). Basically MFC
provides two types of docking bars, which are implemented as the internal class
(CDockBar): floating bar (with the dialog control identifier set to
AFX_IDW_DOCKBAR_FLOAT) and docking bar fixed to the sides of the
docking site (with the dialog control identifiers set to
AFX_IDW_DOCKBAR_LEFT, AFX_IDW_DOCKBAR_RIGHT,
AFX_IDW_DOCKBAR_TOP, or AFX_IDW_DOCKBAR_BOTTOM). MFC
supports only four docking bars for one docking site at the time (these bars are
marked with red in the below). In Prof-UIS these bars are called "circle 0" or
"outer docking bar circle". Both fixed and resizable bars can be docked into
"circle 0", but the drag-and-drop algorithm for resizable bars docks them only
into the Prof-UIS-specific inner docking bar "circles" with numbers starting
from 1. In the figure below, "circle 1" is marked with blue, "circle 2" - with
green. Inner circles are created and destroyed dynamically with the
drag-and-drop algorithm for the resizable bar. These inner circles "allow"
resizable bars to be docked to each other in a nested way. The fixed-size
control bars could be docked only into "circle 0" marked with red.

Docking site’s client area

The area that is free of any bars. It is marked with yellow in the figure and
used by MDI client windows in MDI applications and the view window in SDI
applications.

Dynamic control bar container *

A special kind of the resizable control bar, which is created dynamically and
used for docking other resizable bars to horizontal rows inside vertical rows
and vice versa. The dynamic control bar container like any resizable control bar
can take up part of the docking site or part of the floating container.

Status bar

The MFC implementation of the status line. The status bar cannot be re-docked
by dragging any its area. It takes up part of the docking site under the lowest
docking bar (i.e. under the red "circle 0").

To set a certain fixed docking bar location, just call your
CMainFrame::DockControlBar() method with the appropriate parameter
values. The following example arranges two toolbars into one horizontal image at
the bottom of a frame window:

Use the CExtControlBar::DockControlBar() methods (two overloaded
functions) to set the relative positions of the control bars. In the sample
below, the first method docks the m_wndResourceViewBar resizable
bar to the newly created row in the left part of "docking circle 1". The second
one is applied to the already docked m_wndResourceViewBar bar, with
its parameters specifying the position of the
m_wndServerExplorerBar bar relatively to the
m_wndResourceViewBar one.

To make both fixed-size bars and resizable bars visible/invisible, the
CFrameWnd::ShowControlBar() method should be used. The
CControlBar::ShowWindow() cannot be used here, because it does not
affect the positions of other bars in the same frame window (i.e. the method
does not perform the frame layout recalculation).

Usually all the control bars (but the status bar) in any docking site are
enabled to be re-dockable. This feature is turned on by performing the following
two steps. First, call the static
CExtControlBar::FrameEnableDocking( pDockSite ) method. Second,
invoke the CExtControlBar::EnableDocking() method of the bar.

If a bar is not re-dockable, its parent window is the docking site. In case
of a dockable bar, the parent window is always a docking bar window (even for a
floating palette).

IMPORTANT: CExtControlBar::FrameEnableDocking( pDockSite
) should be used instead of
CFrameWnd::EnableDocking().

Call the CExtControlBar::GetParentFrame() method to get the
pointer to the parent CFrameWnd-based window. If this returned
object is kind of CMiniFrameWnd, the bar is docked inside a
floating container. Otherwise the bar is docked in the docking site.

Retrieve the bar window style flags by calling the GetStyle()
method. The bar window is visible if its window style flags have the
WS_VISIBLE flag. The CControlBar::IsVisible() method
can additionally detect whether the bar is temporarily invisible.

These commands make each control bar visible/invisible. They are usually
marked with check marks, which indicates visibility of the bars. Every docking
bar has its own unique dialog control identifier and the corresponding menu
command in the docking site. In this case, the context menu with the list of all
the docking bars can be activated on every frame point. So, to set the correct
check mark for the "Show/Hide" command of the bar, you should add the following
two lines to the frame’s message map:

First, see the previous answer. The difference is in the command
handling/updating for the resizable bars. These commands have no check marks and
are only used to activate resizable control bars. They never hide bars.
Implement the new OnBarCheck() and
OnUpdateControlBarMenu() methods in the docking site:

When creating such a child window, pass a pointer to
CExtControlBar instance in the "parent window" parameter to the
child window Create() method. After that, the control bar will
automatically adjust the child window to its client area. So far, the resizable
control bar allows only one child window

The docking menu bar is implemented just as an ordinary toolbar. Any needed
initialization should be performed in your CMainFrame's
OnCreate() handler. Moreover, you need to add a frame window class
member of CExtMenuControlBar class.

By default, CExtMenuControlBar does not activate menu on
pressing the ALT key. To enable this, you should override the
PreTranslateMessage() virtual function in a frame window class and
add the following lines before the parent
PreTranslateMessage():

Painting of all the Prof-UIS windows is performed with the global paint
manager (the g_PaintManager variable). It is a smart container for
the CExtPaintManager-like object. You can install your own paint
manager classes derived from CExtPaintManager or
CExtPaintManagerXP/CExtPaintManagerOffice2003 to
re-paint anything you wish. So, create your own class derived from
CExtPaintManager. Then override the PaintGripper()
method. Please consult the code of CExtPaintManager::PaintGripper()
for details. If m_bSideBar is true, we are painting the gripper of the resizable
bar, which is a caption. If m_bFloating is true, we are painting the caption of
any floating mini-frame window.

You should use your own class derived from CExtControlBar (or
CExtToolControlBar, or CExtMenuControlBar) and
override the OnNcAreaButtonsReinitialize() virtual method. This is
the source code of CExtControlBar::OnNcAreaButtonsReinitialize():

If you remove this line NcButtons_Add( new
CExtBarNcAreaButtonClose(this) ); the "X" button will disappear.
When the control bar window is in the floating state, it is inside a miniframe
window which is created and destroyed automatically by Prof-UIS. The "X" on this
frame just hides the window. All the non-client area buttons are instances of
the classes which are derived from CExtBarNcAreaButton. You can
write your own buttons and initialize them in
OnNcAreaButtonsReinitialize().

All the Prof-UIS LIB and DLL files can be found in
...\Prof-UIS\Bin6 or ...\Prof-UIS\Bin7 folder (for
VC++ 6 or 7). You should add the ...\Prof-UIS\Include folder into
the "Include folders list" in your VC++ environment settings. Also, you should
add the ...\Prof-UIS\Bin6 or ...\Prof-UIS\Bin7 folder
into the "Library folders list". In your projects precompiled header file
(usually named StdAfx.h) you should add this line:

#include<Prof-UIS.h>

Now your program will be linked together with appropriate Prof-UIS library
(depending on your project settings). To allow your program run, you may need
copy required Prof-UIS DLL (if any required) into the same folder with your
program EXE file.

You should get the command specifier from the command manager and, then, set
the text attributes m_sToolbarText and m_sMenuText. If
you have to set/change the text after the frame window has been created, call
the RecalcLayout() method of the frame.

Create a control with Dialog Control ID value equal to the ID of an existing
button on the toolbar. Then, set then control to the button by calling
CExtToolControlBar::SetButtonCtrl() method.

If there is no command with such ID in the application menu, then it is
recommended to set a menu text for this command. That allows the button/control
to be displayed correctly in case there is no space in the toolbar for it.

Prof-UIS provides an advanced color selection dialog with a set of color
navigation modes. Just declare the CExtColorDlg object and call
DoModal(). Use m_strCaption member to set a custom
dialog caption. To set initial colors, use m_clrInit and
m_clrNew members. Some modes are demonstrated below:

User interface Manager is an instance of CExtPaintManager or the
one derived from it and is stored in a global smart pointer variable
g_PaintManager. CExtPaintManager methods are used for
drawing all supported interface components as provided by the Office 98/2K/2003
appearance. Prof-UIS also includes CExtPaintManagerXP and
CExtPaintManagerOffice2003 classes used for drawing in the Office
XP and Office 2003 styles. The following lines describe how to set the Office
98/2K/2003 interface style.

DRAWCLI

This sample application based on the Microsoft's sample with OLE
Server-Container technology support illustrates the use of OLE-verb menus, OLE
Client-Server compatible control bars, color picker menus both in menu bar and
in toolbar, toolbar buttons with dynamically generated icons, owner-draw menu,
and more.

GLViews

Demonstrates how to output rendered images (OpenGL animation) both to the
main view and to the dockable views resided in resizable control bars. This
multithreaded application allows you to select an active camera in each view,
set up its parameters and perform 6 DOF simulation of camera maneuvers. GLViews
also illustrates playing an AVI file on a 3D surface, OpenGL stencil
buffer-based reflection, and frame image rendering during animation.

Avi Frames

Shows how to work with the slider button built into the Prof-UIS toolbar. The
slider features optional scroll arrow buttons like those in the standard scroll
bar. The Zoom and Seek slider buttons represented in the sample demonstrate how
to control the playing of AVI files.

Status Bar Panes

Demonstrates the features of the Prof-UIS status bar. This control, which is
an enhanced version of the standard MFC status bar, enables you to easily add or
remove panes on-the-fly. Its panes may contain almost any control you need:
buttons, edits, animations, progress bars, and etc.

Funny Bars

Shows how to use icons of different sizes and different color depths in
toolbars. It also demonstrates how, for the toolbar buttons, to change the font,
font size and font style of the caption as well as the button image on-the-fly.

Bug fixes

Fixed a bug with an incorrect initial position of the system menu when
clicking the right mouse button on the dialog’s caption

Fixed an XP style bug with too dark shadow under the system menu’s items

Version 2.21

Released on July 8, 2003.

New features

Fixed-size control bars (an enhanced toolbar and a completely new panel bar)
with a new powerful "persistent affixment algorithm" which makes them extremely
user-friendly. The control bars can restore their exact positions and sizes
after redocking the bars or resizing the frame.

Built-in toolbar buttons with divided drop-down areas.

CExtButton button control can now support divided drop-down areas.

All the context menus over different frame areas (including control bars,
docking bars, and floating palettes) and the toolbar’s contents button menu can
be constructed on-the-fly.

Menu item with a submenu can combine its area with the area of the currently
opened submenu.

Bug fixes

Fixed a bug dealing with the locked loop when resizing the floating toolbars
with icons of size greater than 16x16.

Version 2.20

Released on September 15, 2002.

New features

Completely new docking mechanism for resizable control bars

Visual Studio .NET like resizable control bar, which optionally shows its
content while dragging/resizing as the Task Area bar does in Office 2000 and
Office XP

Resizable dialog and resizable property sheet with styled push buttons,
which both have the new system menu, and resizable property page (these windows
also support the MFC automatic tooltip feature for their child toolbar windows)

Generalized template window classes for various common tasks like injecting
non-client area borders into any window, providing flicker-free repainting,
anchoring child windows to the borders of their parent window

Bug fixes

Fixed incorrect vertical text painting under Windows NT 4

Fixed a bug with crashing the program after clicking the mouse on the
"Show/Hide bars" menu item in the expanded button of the toolbar/menu bar

Version 2.15

Released on July 8, 2002.

New features

Completely new dragging algorithm for toolbars and resizable control bars

Streamlined resizing algorithm for floating control bars

Owner-drawn popup menu with the left image area

Smoother menu animation effects

Support for standard Windows sounds in menu

Updated Hue/Saturation/Luminance roller mode in CExtColorCtrl

Enhanced 256 color painting

Source Code compiled at warning level 4

ANSI/MBCS/Unicode support

Fully compatible with Visual Studio .NET

Bug fixes

Unwanted frame repainting when dragging control bars

Bug dealing with painting the owner-drawn CExtComboBox in
toolbars

Bug arising when auto-completing the user input in the
CExtComboBox editor popup menu

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

About the Author

Comments and Discussions

Hi,
I have problem regarding customization dialog.I hope u will help me in solving this problem.I want a toolbar name not to disply in customization dialog toolbar list.How can i do it?
Waiting for your early reply.

Hi,
I want to show bitmap in my combobox.I have done it with customization functions.CExtCustomizeSite::OnPopupListBoxDrawItem(),CExtCustomizeSite::OnPopupListBoxMeasureItem() function.It works fine.But if i select an item with bitmap and set in combobox then only text will appear in combobox.I want to set text and bitmap both in combobox.
Waiting for your early reply

hi,
If i hover mouse over enabled toolbar button.It works fine.But if it hovers over disbled toolbar buttonthen it doesn't.boz button does not recognize any event in disabled mode.so I want to show tooltips on disabled toolbar butoon.How is it possible?
Waiting for ur early reply

We are sorry but Prof-UIS Freeware, available from this website, does not support it. The Freeware version lacks some features available in the full version (you can learn about the differences at http://www.prof-uis.com/overview.aspx). In other words, some classes are just excluded, including CExtTabWnd.

The global instance of the CExtResourceManager class (the g_ResourceManager smart pointer) is used by all the Prof-UIS components for loading Win32 resources. It allows you to search for and load language-dependent resources from the executable modules and dynamically linked libraries. This makes possible to change languages supported in your application dynamically at runtime. The most remarkable feature of the resource manager is that this dynamic language switching is possible without the necessity to have a bunch of resource DLLs.

What you are asking is more than a question about changing the background color of the application's main frame. The full version of your question is: how to paint a custom background that is consistent between controls anywhere? This feature is supported by all the Prof-UIS paint managers but is turned off by default. This feature is demonstrated in the TabbedBars sample application where you can see both a custom hurricane-like background in the main frame window.

First of all, you should enable the custom background in the currently installed paint manager:

g_PaintManager->m_bCustomBackgroundInheritanceEnabled = true;

Please note this code should be invoked both at startup and after installing a new paint manager. When the custom background painting is set on, any window starts receiving the CExtPaintManager::g_nMsgPaintInheritedBackground registered Windows message which allows to paint any background you need. The CChildView class in the TabbedBars sample is kind of the CExtTabPageContainerOneNoteWnd page container window. The CChildView class handles the CExtPaintManager::g_nMsgPaintInheritedBackground registered Windows message in the CChildView::OnMsgPaintInheritedBackground() handler method which you can use as an example.

I have a resizable dialog that is defined with WS_POPUP and WS_THICKFRAME with NO title bar (WS_CAPTION). Using the standard UI themes it displays fine. But, when I try to use the skin manager, a blank title bar is displayed. Is there anyway to use skins with a dialog that does not have the WS_CAPTION style?

Just build the library first with Visual Studio. The ProfUIS223nd.lib file corresponds the ANSI Debug configuration of the Prof-UIS. So open the ProfUISDLL project and compile the "Win32 ANSI Debug" configuration.

You should also have a valid path to the Prof-UIS library specified in the Visual Studio IDE options.

Please also note the Prof-UIS v.2.23, which can be found at this website, is very old version. Now a Prof-UIS Freeware 2.62 is available. You can download it from our website. Since 2.23 there are many useful features added and bugs fixed.

It is not clear what the item you cannot find.
As I said your project needs the "Win32 ANSI Debug" configuration of the ProfUISDLL project compiled. Did you done this? Check the ../Prof-UIS/Bin_600 folder for the ProfUIS223nd.lib file. If there is no such file, it means that you did not compile Prof-UIS.
Open the ProfUISDLL workspace, go to Build->Set Active Configuration, select "ProfUISDLL - Win32 ANSI Debug" and then click OK. Then
go to Build->Rebuild All. The ProfUIS223nd.dll file will be created in the Bin_600 folder.

Thank you for your advise
The project has worked well!!!
I do not select "ProfUISDLL-Win32 ANSI Debug" because in my project I can not find the item, I use the "ProfUISDLL-win32 debug" ,and then the ProfUI223na.dll was created int the Bin_600 folder.

Unfortunately you did not provide details such as the container application where you have faced the keyboard processing problem with your ActiveX object.

The ActiveX/DLL projects are different than the EXE projects. The EXE projects are controlling the main application's message loop while the ActiveX/DLL projects does not enabled to filtered user input in the most of cases.

We have faced the similar problem while coding ATL based ActiveX control. The problem was saved with implementing the IOleInPlaceActiveObjectImpl::TranslateAccelerator() interface method as following:

1, I use resizable dlg bars. It works fine, if the dialog template in the .rc file, has definition DIALOG and not DIALOGEX. In the later case, the dlg bar is filled with ui color, but no controls are displayed. VS2005 adds a DIALOGEX resource by default, so I had to manually change them.
Q: anyone seen this problem?

2, with the debug build, I get an ASSERT when dragging a toolbar around the UI (this means it's docked/undocked a lot of times on the frame, on resizable dlg bars, etc, in a short time)

3, When my app (SDI) starts, the status bar remains grey (as it looks in any MFC app by default), and I have to move the cursor over a menu or toolbar, then the status bar is updated properly, so it displays the tooltip text.
Am I mistaken it should initially display some idle message, like "press f1 for help" or something?
Q: what can I do to fix it?

4, back to resizable dlg bars.
Q: Is there a way for the bar to display scroll bars if the contained dialog is larger than the bar? I tried to specify scroll bar flags for the dlg template but didnt help.

5, I followed the manual in docking a toolbar in the same row as another (already docked) toolbar. It didnt work, it docked the bar in the next row.
Q: Is it supposed to work from CMainFrame::OnCreate, because this is where I wanted to use it?

1) The DIALOGEX resources are supported as well as DIALOG ones. Please make sure your dialog resource(s) are having WS_CLIPCHILDREN and WS_CLIPSIBLINGS standard window styles set on.

2) The problem is related to the incorrect initialization of control bars.
Please compare your source code with the source code of theCMainFrame::OnCreate() method in the SDI/MDI/SDIDOCVIEW/MDIDOCVIEW sample applications. To dock resizable control bars please use theCExtControlBar::DockControlBarInnerOuter() andCExtControlBar::DockControlBarLTRB() methods which are modern replacement for the old CExtControlBar::DockControlBar() method.

3) Prof-UIS status bar requires only the following: use CExtStatusControlBar instead of CStatusBar. All the APIs of the CExtStatusControlBar class implemented for extending features of MFC status bar are optional and users are usually do not need them. By default the idle text in the message pane inside the status bar is the "Ready" text defined as AFX_IDS_IDLE_MESSAGE string table resource. If you do not see this text, then you should check the command routing invocations in your project.

4) Neither the CDialog class in MFC nor the CExtResizableDialog class in Prof-UIS are supporting scrolling. You can use MFC's CFormView class which is the view component but based on the dialog resource and supports scrolling. But this class does not provides anchoring features like the CExtResizableDialog class. The universal solution is to use container window which will stretch the child dialog window if the container's size is larger than initial dialog size. The container window should support scrolling and scroll its child dialog window if the container's size is smaller than initial dialog size. The following sample application implements a ready to use scrollable dialog container window like we described above.

5) This question is not actually a question. You can see toolbars docked relatively to each other in the most of Prof-UIS sample applications based on the frame window as the main application window. Please compare your toolbar initialization code with the Prof-UIS samples.

Please note that you can always download the latest freeware version from the Prof-UIS website. New versions include bug fixes and new interesting features. The version which can be found on this website is quite an old version and this issue has been fixed in one of the later versions.

I need to evaluate different commercial GUI toolkits for an application. For this reason I downloaded the Freeware version (V2.61) to test it. Later i would need the commercial version should i take decide to use your lib. (Btw. I had some trouble in compiling it, you should change the hint on the download page regarding the configuration from "MBCS Debug" to "Static MBCS Debug"; but 2 Projects still fail to compile).

I have an application in development where I need to rewrite parts of the GUI since the current version does not seem to work properly. So I'm looking for a new GUI toolkit in order to no longer depend on multiple different solutions for certain aspects of the GUI.
My application has multiple dockable windows. In one of this windows i'd like to put a property grid. Currently i user several Open Source Solutions but they have issues when it comes to properly resoring dockwindow and toolbar positions. I need a GUI toolkit able to restore an application having multiple toolbars and dockwindows that can be located anywhere on the screen. The resizebale ChildSheet example is pretty close to what i need. However neither can I use the registry nor the application ini file for storing the data. Is there any chance of serializing the GUI state to anything other than registry or the application ini file? (The GUI layout is project specific in my application)

Also I'd like to know if I can add an image List to the Property grid. The example does not seem to show it but it's a pretty importand feature for me.

You need to include only one header file. This file is Prof-UIS.h and it should be included in your StdAfx.h header:

#include < Prof-UIS.h >

Please do not forget to set the required paths in VS settings before compiling your project. This is described in the article Getting Started with Prof-UIS. I would also recommend you carefully read other articles available on the Prof-UIS website.

Please note Prof-UIS v.2.23 is quite an old version. We recommend you download the latest freeware version 2.54 from the Prof-UIS website. It includes many bug fixes and interesting new features.

I have created a project by the prof-uis application wizard,but then how do I use the application wizard?
In the web of introducing the prof-uis feature,making
a interface by the application wizard only need 10 steps in one minute.Could I work easily by the application wizard as well as the introducing? By the way,I install the prof-uis2.52 trial,and visal c++ 6.0.could you solve my problem?

We did not see any warnings and errors anywhere. We guess these build errors may occur if you installed some new Platform SDK which had added its paths to the include folders list of Visual Studio 6.0. Please check the include directories in the Visual Studio settings (select Tools | Options and then the Directories tab). Any Platform SDK directory should be at the bottom of the list. Here is a typical Include files list on a computer where both Visual Studio 6.0 and .NET 2003 are installed:

You are right. I had the follow line in my directories include files section.

C:\Program Files\Microsoft SDK\Include

I wish I could tell you which SDK kit I have downloaded but I have no idea. I might have had Microsoft .Net SDK included in Microsoft Visual Studio 6.0 Builds. Well just thought I would let you know...