Windows CE 2.1 Technical Articles  

Understanding Modularity in Microsoft Windows CE 2.1

Important:
This is retired content. This content is outdated and is no longer being maintained. It is provided as a courtesy for individuals who are still using these technologies. This content may contain URLs that were valid when originally published, but now link to sites or pages that no longer exist.

Microsoft Corporation

August 2000

Summary:This paper describes how the modules and components of Microsoft Windows CE can be selected, combined and configured to create a customized version of the operating system. (21 printed pages)

Contents

Introduction
Windows CE Modules and Components
Customizing Windows CE
Sample Configurations
Summary

Introduction

The Windows CE operating system, first introduced in 1996, has been specifically designed for resource-constrained embedded applications. There are literally thousands of such applications, including products as diverse as handheld communications devices, commercial building automation systems, manufacturing process controllers, consumer electronic products and medical data acquisition devices.

A common requirement of these devices is the need to reduce the amount of hardware (RAM, ROM and other resources) required for implementation. Windows CE has been designed to meet the need for a smaller, more efficient, powerful and customizable 32-bit operating system.

Microsoft Windows CE is an operating system designed for a wide variety of embedded systems and products, from handheld PCs and consumer electronic devices to specialized industrial controllers and embedded communications devices. The Windows CE operating system has proven itself capable of handling the most demanding 32-bit embedded applications by bringing the full power of Microsoft 32-bit programming and operating systems technology to the embedded systems developer.

An important aspect of Windows CE for embedded systems is its high degree of modularity. As you will learn in this paper, Windows CE is actually a collection of operating system modules and components that can be selected and configured to meet the needs of a specific embedded application or product. Using Microsoft Windows CE Embedded Toolkit for Visual C++, embedded systems developers are able to create a version of Windows CE that is customized and optimized for their unique hardware platforms and applications.

This paper describes how the modules and components of Microsoft Windows CE can be selected, combined and configured to create a customized version of the operating system. This paper:

  • Summarizes the modules and components that make up Windows CE
  • Describes how a custom version of Windows CE can be configured and built
  • Provides examples of common Windows CE configurations
  • Shows that Windows CE is a flexible, powerful, and modular platform for embedded applications

    Streamlining Embedded Systems

    The need for simplification in embedded systems is often based on cost (as in the case of consumer electronic devices), but may also be driven by other factors such as system reliability, strict power budgets or physical size limitations. Consider the following aspects of a typical embedded system:

    • An embedded system may have severe memory and other hardware resource constraints.
    • An embedded system may or may not include a graphic user interface.
    • An embedded system may have time-critical processing requirements.
    • An embedded system may be designed to run just one application.
    • An embedded system may be designed to operate on a single customized platform.
    • The distinction between an embedded operating system and the application it hosts may be unclear.

      The last point is of particular importance. The operating system chosen for an embedded system must not get in the way of the embedded application. In many cases it is not even required (or desirable) that the application user know what operating system is being used inside the embedded system or product. In this environment, an operating system that can be reduced to its core functionality and adapted to the limited resources available—without unnecessarily compromising other design goals—is of paramount importance.

      For example, consider the design of a home automation system. This product may incorporate the functions of a climate control system (heating, ventilation and air conditioning), as well as control of lights, a remote alarm system, intercom, telephone answering system, and more advanced features, such as energy usage monitoring. This is an example of an embedded application that may require a substantial (although simplified) graphical interface, but in which there is no requirement to expose to the user any elements of the underlying operating system, or to utilize such hardware features as a keyboard. This information appliance, although relatively complex, will have only a limited need for many of the features of a complete operating system.

      In support of embedded applications such as this, Windows CE is designed to be efficient, customizable and modular. The result is an operating system in which specific features (such as communications, graphical user interface, and support for specialized input devices) can be easily selected, configured or removed altogether to create a customized, application-specific operating system.

      Windows CE for Embedded Applications

      Before describing the modules and components that make up Windows CE, it is important to understand, from a higher level, what Windows CE is and what it is not. Those unfamiliar with Windows CE may have a mistaken notion that it is simply a reduced feature-set version of an existing operating system (such as the Microsoft Windows NT operating system). The truth is that Windows CE was developed from the ground up as a small-footprint, highly customizable and modular operating system for embedded applications. The Windows CE kernel borrows much of what is best from other Microsoft 32-bit operating systems, while eliminating (or replacing) those operating system features that are not needed for typical Windows CE-based applications. That result is that Windows CE is compact and customizable. In fact, it is possible to create a version of the Windows CE kernel that requires less than 200K of ROM.

      Unlike other 32-bit Windows operating systems, Windows CE operating system code resides and executes in ROM. Depending on your product requirements, you may also choose to place application code in ROM. For example, Pocket Word, Pocket Excel and other application programs included with an H/PC are provided in ROM.

      Because programs stored in ROM execute in place in Windows CE, your embedded applications can function with only a modest amount of RAM, for such purposes as stack and heap storage. Alternatively, your application may make use of RAM for program memory as well as for temporary storage.

      To further increase the performance of application software, Windows CE features on-demand paging: the operating system only needs to uncompress and load a small portion of a RAM-based program for execution. The flexibility and speed of ROM- and RAM-based programs mean that devices based on Windows CE can be constructed with a wide variety of memory configurations.

      On the development side, programmers targeting Windows CE have access to a wide variety of familiar development environments, including Microsoft Visual C++ and Visual Basic development systems. The Windows CE application programmer interface (API) is consistent with the Win32 API used in other 32-bit Windows platforms, making it easy to create new applications, or (as appropriate) to port existing desktop applications. For customizing Windows CE for a specific type of hardware, including selecting and configuring the appropriate modules and components, Microsoft provides the Windows CE Embedded Toolkit for Visual C++. This set of tools gives you everything you need to build, download to your target platform and debug a version of Windows CE that includes your application software and only those Windows CE operating system components that are required to support that component.

      Windows CE Modules And Components

      Because minimal memory requirement is a major design goal, Windows CE is built from a number of discrete modules. You can control the size ("footprint") of the operating system software by selecting only the modules that you need. Several of these modules are also further divided into components. By selecting a minimum set of modules and components, you can minimize the hardware resources (ROM and RAM, in particular) needed to support your end product.

      Windows CE modules that include one or more optional components are referred to as component modules. Examples of component modules include Coredll, Gwes, Filesys, and Ole32. Each of these modules provides full or partial support for major features of the operating system, and can be tailored to serve the needs of a given embedded application.

      Operating System Kernel Components

      The Windows CE kernel (represented by the Coredll module) provides the base operating system functionality that must be present on all platforms. The kernel is responsible for memory management, process management, and certain required file management functions. It manages virtual memory, scheduling, multitasking, multithreading, and exception handling.

      Most components of the Coredll module are required for any configuration of Windows CE. There are some optional kernel components, however, that are needed when you are including other operating system features (and corresponding modules) such as telephony, multimedia and GDI graphics.

      File System Components

      The Filesys module supports the Windows CE object store API functions. These API functions support a ROM-based file system, a RAM-based file system, a structured storage system (the Windows CE database), and a system registry. The file system also supports multiple installable file systems. An implementation of the FAT File System is provided to support files stored on external media such as PC Cards. These various file system components can be selected or omitted during the operating system build process to include only those file system features that are required. The following are a few typical combinations of file system components:

      • A ROM-only file system
      • Both ROM and RAM file systems
      • ROM, ROM, database, registry and passwords
      • RAM and ROM file systems, and a FAT file system

        Windows CE can be custom-configured to support any of these file system combinations.

        Graphic, Windowing and Event Components

        If you are experienced with programming for Windows, you are probably familiar with the Win32 User and GDI (Graphics Device Interface) subsystems of desktop Windows platforms, as exposed in the Win32 API. Windows CE combines the User and GDI subsystems into one component module called the Graphics, Windowing, and Events Subsystem (Gwes). The event manager and window manager in Gwes are analogous to the User subsystem of Win32, while the Win32 GDI sub-system is replaced with a smaller multi-platform GDI (MGDI) more suitable for Windows CE-based devices.

        The Gwes module is responsible for user interface and windowing features of Windows CE. Gwes implements the window, dialog, and control manipulation capabilities of the system. Gwes is also responsible for displaying graphics and text on graphics display devices and for performing sophisticated graphics manipulations. Application software, and Windows CE itself, use the MGDI features of Gwes extensively for the visual display of user interface items such as menus, scroll bars, and icons. The Gwes components can be organized into the following general areas:

        • Base GWES components (required)
        • Message queue components (required)
        • GDI components (optional)
        • Window management components (optional)
        • Dialogs (optional)
        • Controls (optional)
        • Font support components (optional)
        • User input components (optional)
        • Power management components (optional)

          Other Components and Modules

          In addition to the primary component modules Filesys and Gwes, other operating system modules are available, including modules and components in the following categories:

          • Communications modules (supporting TAPI, IRDA, RAS, TCP/IP and other networking features)
          • PCMCIA (PC Card) support modules
          • RSA encryption module (for communications support)
          • Device manager and installable device drivers
          • Multimedia (sound) support module
          • OLE/COM (including OLE Automation) support module
          • Windows CE desktop and services which support custom, add-on shells

            Each module or component provided in Windows CE supports a group of related API functions that are available to the application developer. All defined modules and components, and their corresponding APIs, are listed in the documentation provided with the Microsoft Windows CE Embedded Toolkit for Visual C++.

            Supporting Devices with Windows CE

            Another modular aspect of Windows CE is its device driver architecture. Windows CE supports two fundamental categories of device drivers: built-in drivers and installable drivers. As the name implies, built-in device drivers are intended for devices that are built into a given Windows CE-based hardware platform. An embedded system designer using Windows CE is responsible for providing the built-in drivers to operate any devices to be included with the system. For example, some Windows CE-based applications require a custom touch-sensitive LCD screen. The designers of such products are responsible for providing device driver software for their devices in order to allow the Windows CE operating system to use the touch screen device. In the complete system, these built-in drivers reside in ROM along with the customized Windows CE kernel.

            Installable device drivers are for any peripheral devices that can be temporarily connected to a Windows CE platform. This covers devices such as modems, printers, digital cameras, PC Cards (also known as PCMCIA cards), and other external devices. Windows CE platforms are different from desktop computers in their method of adding hardware. With a desktop PC, a computer user can open the case and plug an expansion card directly into the data bus. This generally means that device driver software for these types of expansion cards must run in kernel mode because of their need for direct access to whatever memory locations control the hardware. Windows CE platforms, on the other hand, do not offer any end-user access to the data bus, and new hardware cannot be added in that fashion. In Windows CE, all additional hardware must be connected to the Windows CE platform via external connectors such as serial ports, PC card slots, or USB ports. This puts peripheral devices for Windows CE in a similar situation to printers on normal PCs; device driver software for both runs as user-mode processes that use the services of built-in hardware in order to control their devices.

            The device driver architecture of Windows CE has been designed to streamline the process of creating drivers, while at the same time reducing system resource requirements and maintaining fast device interrupt processing. Whether your application uses built-in drivers, installable drivers, or both, it will benefit from the ways in which Windows CE minimizes device resource requirements.

            Installable device drivers for Windows CE are dynamically linked libraries (DLLs). You create them in very much the same way as you create a DLL for the Windows 95 or Windows NT operating systems.

            The primary job of an installable device driver is to expose the services of a peripheral device to applications. In much the same way as in other Windows operating systems, presenting the device as a special file in the file system does this. All installable device driver DLLs expose the same entry points. Those entry points correspond to the standard Win32 file I/O functions, such as OpenFile, ReadFile, DeviceIOControl, and others. In addition, Windows CE requires some additional entry points related to maintaining a device's state while the Windows CE platform is turned off.

            Customizing Windows CE

            Creating a version of Windows customized for your application and hardware requirements is easy, if you have the right tools. The Windows CE Embedded Toolkit for Visual C++ includes everything you need to build the Windows CE operating system and port it to your new hardware. Remote debugging tools make it possible to test and debug your embedded application, and sample drivers simplify the process of supporting new custom hardware devices.

            Windows CE Embedded Toolkit for Visual C++ is integrated into the Visual C++ for Windows CE integrated development environment (IDE) and provides additional capabilities for embedded software developers, including:

            • Cross compilers for the various processor families supported by Windows CE
            • A Windows CE emulator that allows quick and easy debugging of many types of applications for Windows CE
            • A Windows CE operating system builder
            • ROM image generation utilities
            • Download and remote debugging tools
            • Sample code and tutorial documentation
            • The Windows CE Software Development Kit (SDK)
            • The Windows CE Driver Development Kit (DDK)
            • The Win32 for Windows CE API reference
            • All modules and components of the Windows CE operating system

              Windows CE and the Embedded Toolkit support a wide variety of embedded processors, including: Hitachi SH3, Sh1; DEC SA-1100, ARM 720T; NEC VR4102, VR4111, VR4300; IBM and Motorola PPC821, PPC403GC; Philips PR31500; Toshiba TX3912; AMD ElanSC400, and the Intel 486DX and Pentium family of processors. Additional members of these CPU families may also run Windows CE but have not yet been certified in Microsoft test labs.

              Porting Windows CE To New Hardware

              If you are creating a fully customized product, including the hardware, your first step will be to determine the hardware and application requirements and build a customized version of Windows CE that meets those requirements. When developing a new hardware platform and its supporting I/O devices, you will be making decisions and tradeoffs at different levels in the design. For example, unless you are relying exclusively on common, off-the-shelf hardware, you will almost certainly need to write custom device drivers to support one or more peripheral devices. You may also need to configure Windows CE to include the necessary device handling components, and to customize the OEM abstraction layer (OAL) of Windows CE for your hardware.

              At the application level, you will need to write interface code that meets the requirements of the devices in your system. The Windows CE Driver Development Kit (included in the Embedded Toolkit) provides the information and examples you need to create Win32-capable device drivers.

              To create a customized version of Windows CE that meets the unique requirements of your hardware platform, you must:

              • Determine the number and types of device interfaces that will be required.
              • Determine the operating system modules and components that will be required for your hardware platform and application, and select (or create) a corresponding configuration.
              • Create a build environment suitable for your development project and platform. The build environment for your project is represented by a directory structure on your development host and is tailored for your project and platform.
              • Port the Windows CE boot loader to your platform.
              • Port the CE shell utility (cesh) to your platform. The CE shell utility gives you the means to download binary files to your hardware platform through the parallel, serial, or ethernet port on your development host.
              • Design, implement and port the OEM abstraction layer (OAL). The OAL is compiled and linked with the operating system kernel library supplied in the Embedded Toolkit to produce a kernel executable targeted to your platform's system architecture.
              • Port any required built-in device drivers. The Embedded Toolkit includes several pre-written device drivers that can be ported to your development platform. Using the supplied drivers is not required, but can save you considerable time.
              • Create and port any required installable device drivers.
              • Design and implement your custom shell and applications, if required.
              • Build your customized Windows CE operating system by running the supplied Build utility.
              • Copy all files needed for the ROM image by running the Buildrel utility.
              • Create a binary ROM image by running the Makeimg utility.
              • Copy the binary ROM image to your platform using the Cesh utility.
              • Test and debug the customized Windows CE on your target platform using the supplied debugging tools (Windbg.exe, Memtool.exe, etc).

                As you can see, there are many steps required to create and implement a customized version of Windows CE. Fortunately, the Embedded Toolkit provides you with a rich set of tools intended to simplify this process, allowing you to focus on implementing and debugging your embedded application. The Embedded Toolkit also includes sample operating system builds so you can better understand the steps required.

                Sample Configurations

                Selecting an appropriate set of Windows CE modules and components for a given embedded application can be a complex, time-consuming task. There are many optional modules and components from which to choose, and many interdependencies among these modules and components. To simplify the process of selecting modules and components, the Embedded Toolkit includes a number of pre-tested configurations. The following four samples illustrate a few of these formally tested configurations.

                Sample Configuration: Base Kernel

                The base kernel project, provided in the Embedded Toolkit, demonstrates how to configure Windows CE for a minimal application that includes user input (keyboard) support, does not include display capability, and has only minimal device and communications facilities. This version of Windows CE contains the minimum number of components required to build the Gwes and CoreDLL modules and includes the components needed to build the file system module, database, registry, and password components. Two additional variations of this project are provided in the Embedded Toolkit that remove optional components such as the RAM file system and database. A sample application is included with the project that accepts keyboard input and displays the appropriate keyboard (VK) codes to the debug serial port.

                This sample configuration supports the following features:

                • Core operating system (kernel)
                • Cesh debug shell and Toolhelp module provided for debugging
                • Password support
                • Keyboard input support
                • No RAM file system
                • No communications

                  To support these features, the sample project includes the following modules and components:

                   Modules/components Related sample applications
                   Coredll Operating core DLL module (required)
                   coremain Required component
                   coreloc Required component
                   fmtmsg CoreDLL component
                   lmem Required component
                   thunks Required component
                   Filesys File system module
                   fsdbase Database component
                   fsmain File system main component
                   fsysram RAM and ROM file system component
                   fsheap Heap file system component
                   fsreg Registry component
                   fspass Password component
                   pmstub Post message stub component
                   Nk Operating system kernel (required)
                   Toolhelp Toolhelp (debugger support) module
                   Shell Debugging shell

                  Sample Configuration: Adding Communications

                  This Embedded Toolkit sample project, like the one previously described, builds a partial version of Windows CE with no user interface components. This version does, however, include most of the data communications and networking components available in Windows CE, including TCP/IP, PPP, NDIS, IRComm, IRDA, Serial, WinInet, Secure sockets, NTLM authentication, TAPI, Unimodem and Redir. Variations of this project allow the inclusion of only the IRComm, IRDA, and Serial components, or the TCP and NDIS components.

                  This demonstration project includes the source code for a simple communications application called RASDEMO. This sample application creates a phone book entry on the target platform and attempts to connect with a specified RAS server. The project makes use of the following Windows CE features:

                  • Core operating system (kernel)
                  • Debugging
                  • TAPI
                  • Networking (Winsock, NDIS, etc)
                  • PC card (PCMCIA driver) services
                  • Minimal Gwes (for communications support)

                    This sample project includes the following Windows CE modules and components (depending on the build variation):

                     Module/component name Description
                     Afd AFD module
                     Arp ARP module
                     Cardserv Card services (PCMCIA driver) module
                     Coredll Operating core DLL module (required)
                     coremain Required component
                     coreloc Required component
                     lmem Required component
                     thunks Required component
                     fmtmsg CoreDLL component
                     rectapi GDI support component
                     wmgr_c Window manager component
                     serdev Serial device support component
                     tapilib TAPI telephony support component
                     cryptapi Cryptography component
                     rsa32 RSA encryption component
                     Cxport Common transport utilities component
                     Device Installable device manager module
                     Dhcp Dynamic host configuration module
                     Elnk3 Elnk3 module
                     Filesys File system module
                     fsmain File system main component
                     fsysram RAM and ROM file system component
                     fsheap Heap file system component
                     fsreg Registry component
                     Gwes Graphics, windowing and event module
                     calibrui Touch pad calibration U/I component
                     mgbase GDI base component
                     mgbitmap GDI bitmap component
                     mgblt BitBlt component
                     mgblt2 Bitmap transfer support component
                     mgdc Device context support component
                     mgdibsec CreateDIBSection API component
                     mgdraw Drawing and drawing tool component
                     mgdrwtxt Text drawing support component
                     mgpal Palette support component
                     mgprint Printing support component
                     mgrgn Drawing region support component
                     mgtt TrueType font support component
                     mgwinmgr ScrollDC support component
                     wmbase GWES base component
                     gweshare GWES component
                     gwesmain GWES main component
                     immthunk Thunking component
                     msgque Message queue component
                     loadstr String loading component
                     tchui Touch pad U/I component
                     gsetwinlong Get/SetWindowLong component
                     Ircomm IrDA communications module
                     Irdastk IrDA stack module
                     Ndis NDIS network module
                     Ne2000 NE2000 module
                     Netbios Netbios module
                     Netdetec Network detect (ping) module
                     Netui Network U/I module
                     Nk Operating system kernel (required)
                     Ntlmssp Ntlmssp module
                     Ppp Point-to-point protocol module
                     Redir Redirector module
                     Rsabase RSA encryption module
                     Secur32 Security Support Provider Interface module
                     Schannel SSL/PCT secure socket layer
                     Shell Debugging shell module
                     Tapi TAPI support module
                     Tcpstk TCP/IP stack module
                     Toolhelp Toolhelp (debugger support) module
                     Winsock Winsock services module
                     sslsock SSL Winsock support component
                     Unimodem Unimodem module
                     Wininet Internet support module
                     inetftp FTP protocol component

                    Sample Configuration: Adding Minimal Display Capabilities

                    This demonstration project builds a nearly complete version of the Windows CE file system, including Gwes and CoreDLL. The configuration includes support for touch pad input devices, audio, and other features common to handheld PCs (H/PCs) and other handheld devices, but includes only a minimally configured Gwes module with no window management support.

                    This sample project provided with the Embedded Toolkit includes an application (POLYGONS.EXE) that tests the graphic output of the target platform.

                    This sample project provides support for the following Windows CE features:

                    • Core operating system (kernel)
                    • Debugging support
                    • Cesh debug shell
                    • MGDI (graphics, windowing and events) support
                    • Touch display panel support

                      In support of these features, the project includes the following Windows CE modules and components:

                       Module/component Description
                       Coredll Operating core DLL module (required)
                       coremain Required component
                       coreloc Required component
                       fmtmsg CoreDLL component
                       lmem Required component
                       thunks Required component
                       mgdi_c GDI support component
                       rectapi GDI support component
                       wmgr_c Window manager component
                       Filesys File system module
                       fsmain File system main component
                       fsysram RAM and ROM file system component
                       fsheap Heap file system component
                       fsreg Registry component
                       fspass Password component
                       fsdbase Database component
                       Gwes GWES module
                       calibrui Touch pad calibration U/I component
                       foregnd Foreground window component
                       getpower Battery power component
                       gsetwinlong Get/SetWindowLong component
                       gweshare GWES component
                       gwesmain GWES main component
                       idle System idle component
                       immthunk Thunking component
                       kbdui Keyboard interface component
                       loadstr String loading component
                       mgbase GDI base component
                       mgbitmap GDI bitmap component
                       mgblt BitBlt component
                       mgblt2 Bitmap transfer support component
                       mgdc Device context support component
                       mgdibsec CreateDIBSection API component
                       mgdraw Drawing and drawing tool component
                       mgrgn Drawing region support component
                       mgwinmgr ScrollDC support component
                       mgtt TrueType font support component
                       mgprint Printing support component
                       mgdrwtxt Text drawing support component
                       mgpal Palette support component
                       msgbeep MessageBeep API component
                       msgque Message queue component
                       nled Notification LED component
                       tchui Touch pad U/I component
                       uibase User interface base component
                       wmbase GWES base component
                       Nk Operating system kernel (required)
                       Shell Debugging shell
                       Toolhelp Toolhelp (debugger support) module

                      Sample Configuration: Adding Window Management

                      This sample project includes nearly all modules and components available for Windows CE, including complete graphic and drawing support, TrueType fonts, OLE interfaces, communications, PC Card (PCMCIA) devices and other advanced features. This sample represents the typical feature set of a handheld PC (H/PC).

                      Two sample applications are provided in the Embedded Toolkit to assist in validating the configuration.

                      This sample project provides support for the following Windows CE features:

                      • Core operating system (kernel)
                      • Cesh debug shell and debugging support
                      • COM and Automation
                      • Communications
                      • Installable device driver support
                      • Complete GDI support

                        This sample project includes the following Windows CE modules and components:

                         Module/component Description
                         Afd AFD component
                         Atadisk ATA disk support module
                         Cegsm CEGSM module
                         Console Console component
                         Coredll Operating core DLL module (required)
                         accel_c CreateAccelerator table component
                         coreimm Input method manager component
                         coremain Required component
                         coreloc Required component
                         coresiow Wide string formatting fns component
                         corestrw Wide stdio fns component
                         lmem Required component
                         thunks Required component
                         fmtmsg CoreDLL component
                         fpemul Floating point emulation component
                         rectapi GDI support component
                         wmgr_c Window manager component
                         serdev Serial device support component
                         tapilib TAPI telephony support component
                         mgdi_c GDI support component
                         wavelib Multimedia support component
                         Cxport Common transport utilities module
                         Device Installable device manager module
                         Fatfs FAT file system module
                         Filesys File system module
                         fsmain File system main component
                         fsysram RAM and ROM file system component
                         fsheap Heap file system component
                         fsreg Registry component
                         fspass Password component
                         fsdbase Database component
                         Gwes GWES module
                         accel Accelerator component
                         audio Audio component
                         btnctl Button control component
                         calibrui Touch pad calibration U/I component
                         caret Caret component
                         cascade Cascading menu component
                         cdlctl Candidate list control component
                         clipbd Clipboard component
                         cmbctl Combo box control component
                         defwndproc Define window procedure component
                         dlgmgr Dialog manager component
                         dlgmnem Dialog mnemonics component
                         edctl Edit control component
                         foregnd Foreground window component
                         gcache GWES initialization component
                         getpower Battery power component
                         gsetwinlong Get/SetWindowLong component
                         gwectrl GWES base component
                         gweshare GWES component
                         gwesmain GWES main component
                         icon Icon component
                         iconcmn Core icon component
                         iconcurs Mouse cursor component
                         idle System idle component
                         imgctl Image control component
                         immthunk Thunking component
                         kbdui Keyboard interface component
                         lbctl Listbox component
                         loadstr String loading component
                         loadbmp Bitmap loading component
                         loadimg Image loading component
                         mcursor Cursor component
                         mcursor8 Standard window cursor component
                         menu Menu component
                         menuscrl Scrolling menu component
                         msgbeep MessageBeep API component
                         msgbox Message box component
                         msgbox2 Color message box component
                         mgbase GDI base component
                         mgbitmap GDI bitmap component
                         mgblt BitBlt component
                         mgblt2 Bitmap transfer support component
                         mgdc Device context support component
                         mgdibsec CreateDIBSection API component
                         moverlap Overlapping menu component
                         mgdraw Drawing and drawing tool component
                         mgrgn Drawing region support component
                         mgwinmgr ScrollDC support component
                         mgrast Font support component
                         mgrast2 Font support component
                         mgdrwtxt Text drawing support component
                         mgpal Palette support component
                         mgpalnat Natural Palette component
                         msgque Message queue component
                         mtapui Tap menu U/I component
                         nclient Non-client window area component
                         nled Notification LED component
                         oom Out of memory component
                         oomui Out of memory U/I component
                         scbctl Scroll bar control
                         startui Startup dialog U/I component
                         startup Startup component
                         stcctl Static control component
                         tchui Touch pad U/I component
                         timer Timer component
                         uibase User interface base component
                         winmgr Window manager component
                         wmbase GWES base component
                         Ircomm IrDA communications module
                         Irdastk IrDA communications support module
                         Ndis Network driver component
                         Netui Network U/I module
                         Nk Operating system kernel (required)
                         Ntlmssp NTLMSSP module
                         Ole32 OLE support module
                         com COM interface support component
                         olemain OLE main component
                         Oleauto32 OLE Automation module
                         Ppp Point-to-point protocol module
                         Secur32 Security Support Provider Interface module
                         Shell Debugging shell module
                         Sramdisk SRAM (PCMCIA) card device module
                         Tapi TAPI telephony module
                         Tcpstk TCP/IP stack module
                         Toolhelp Toolhelp (debugger support) module
                         Uuid UUID support module
                         Unimodem Unimodem support module
                         Waveapi Multimedia sound API module
                         Wininet Internet services support module
                         inetftp Internet file transfer component
                         Winsock Winsock support module
                         sslsock SSL Winsock component

                        Summary

                        This paper has shown how the Windows CE operating system can be custom-configured for the unique needs of an embedded application. The modular architecture of Windows CE, coupled with its compact and efficient design, makes it possible to create highly efficient embedded applications while retaining all the benefits of a widely understood and consistent programming interface.

                        For More Information

                        For information about creating your own customized shell using the shell support components, see Implementing a Custom Shell On a Microsoft Windows CE 2.1-based Device.

                        Complete documentation about the tools and process used to build the Windows CE operating system is included with the Microsoft Windows CE Embedded Toolkit for Visual C++ 5.0.