You will update the ready state as your code is downloaded by calling [COleControl::InternalSetReadyState](../mfc/reference/colecontrol-class.md#colecontrol__internalsetreadystate). One place you could call `InternalSetReadyState` is from the `OnProgress` override of `CDataPathProperty`-derived class.

[MFC Internet Programming Tasks](../mfc/mfc-internet-programming-tasks.md)

- [Client or Server Application](#_core_client_or_server_application)

- [COM on the Internet](#_core_com_on_the_internet)

Your application may run on a client computer or on a server computer. Your application may also be stored on a server, and then downloaded across the Internet and run on a client computer. MFC WinInet classes are used for client applications to download files. MFC and asynchronous moniker classes are used to download files and control properties. Classes for ActiveX controls and Active documents are used for client applications and for applications that are downloaded from the server to run on a client.

Microsoft offers several ways of providing content on a Web page. Web pages can use standard HTML or HTML extensions, such as the object tag, to provide dynamic content such as ActiveX controls.

Web browsers typically display HTML pages. Active documents can also display your application's data in the simple point-and-click interface of a COM-enabled browser. Your Active document server can display your document, full frame in the entire client area, with its own menus and toolbars.

ActiveX controls you write can be downloaded asynchronously from the server and displayed on a Web page. You can use a scripting language such as VBScript to perform client-side validation before sending information to the server.

You can write ActiveX controls that are embedded in an HTML page and Active document servers that are viewed in a browser. You can write HTML pages that contain a button to submit a request to run your ISAPI application on a Web server. You can write a stand-alone application that uses Internet protocols to download files and display the information to your user, without ever using a browser application.

- [Add an Automation class](../mfc/automation-servers.md)

- [Use type libraries](../mfc/automation-clients-using-type-libraries.md)

- [Access automation servers](../mfc/automation-servers.md)

- [Write automation clients in C++](../mfc/automation-clients.md)

The Microsoft Foundation Class Library provides collection classes to manage groups of objects. These classes are of two types:

- [Collection classes not created from templates](#_core_the_collection_classes_not_based_on_templates)

A map is a collection that associates a key object with a value object.

The easiest way to implement a type-safe collection that contains objects of any type is to use one of the MFC template-based classes. For examples of these classes, see the MFC sample [COLLECT](../top/visual-cpp-samples.md).

The following table lists the MFC template-based collection classes.

How expensive is this routing mechanism Compared to what your handler does in response to a command, the cost of the routing is low. Bear in mind that the framework generates commands only when the user interacts with a user-interface object.

|When an object of this type receives a command . . .|It gives itself and other command-target objects a chance to handle the command in this order:|

|----------------------------------------------------------|-----------------------------------------------------------------------------------------------------|

This article describes the steps necessary to incorporate optional advanced features into existing container applications. These features are:

- [An OLE link to an embedded object](#_core_links_to_embedded_objects)

A container/server application is an application that acts as both a container and a server. Microsoft Word for Windows is an example of this. You can embed Word for Windows documents in other applications, and you can also embed items in Word for Windows documents. The process for modifying your container application to be both a container and a full server (you cannot create a combination container/miniserver application) is similar to the process for creating a full server.

The article [Servers: Implementing a Server](../mfc/servers-implementing-a-server.md) lists a number of tasks required to implement a server application. If you convert a container application to a container/server application, then you need to perform some of those same tasks, adding code to the container. The following lists the important things to consider:

The table below briefly describes each of the Windows common controls, including the control's MFC wrapper class.

|Control|MFC class|Description|New in Windows 95|

|-------------|---------------|-----------------|------------------------|

- [A map](#_core_to_delete_all_elements_in_a_map)

1. Use `GetHeadPosition` and `GetNext` to iterate through the list.

Notice the difference between deleting an element's object and removing the element itself. Removing an element from the list merely removes the list's reference to the object. The object still exists in memory. When you delete an object, it ceases to exist and its memory is reclaimed. Thus, it is important to remove an element immediately after the element's object has been deleted so that the list won't try to access objects that no longer exist.

1. Use `GetSize` and integer index values to iterate through the array.

As with the list example above, you can call `RemoveAll` to remove all elements in an array or `RemoveAt` to remove an individual element.

1. Use `GetStartPosition` and `GetNextAssoc` to iterate through the array.

- [Dynamically resizing the toolbar](#_core_dynamically_resizing_the_toolbar)

See the MFC General sample [DOCKTOOL](../top/visual-cpp-samples.md) for examples.

You can also use [CToolBar::GetButtonStyle](../mfc/reference/ctoolbar-class.md#ctoolbar__getbuttonstyle) to return a state and style for buttons on your toolbars. A button's style determines how the button appears and how it responds to user input; the state tells whether the button is in a wrapped state.

For a toolbar with the size fixed style, designate toolbar button indexes at which the toolbar will wrap. The following code shows how to do this in your main frame window's `OnCreate` override:

[!code-cpp[NVC_MFCDocViewSDI#10](../mfc/codesnippet/cpp/docking-and-floating-toolbars_1.cpp)]