(Fig: 1) 

An attempt to read or write to any memory address above these 33 slots (address 0×42000000) always causes an access violation to be raised. When a process initializes, Windows CE selects an open slot for the new process and populates the slot. 

So an application can use no more than 32MB of storage. But if any application requires more than 32 MB of virtual space, it can be done by some APIs.
Within “EACH” slot, offset 0×00000000 to 0x0000FFFF is a 64KB region that is always free. Any attempt to read or write within this offset always causes an access violation to be raised. The EXE file’s code and data sections load starting at address 0×00010000 (64KB). Immediately following the EXE module are regions reserved for the primary thread’s stack and the process’s default heap. Any additional thread stacks and heaps will also be allocated around this area. 

(Fig: 2) 

Windows CE loads all RAM DLLs at the same address in all process slots. For example, let’s say that process A is the first process to load the A.dll and that this DLL loads at offset 0×01800000 in process A’s slot. Now, if process B later calls LoadLibrary to also load A.dll, the system must be able to map A.dll to offset 0×01800000 in process B’s slot. If there is something else occupying this region in process B’s slot, its call to LoadLibrary fails, returning NULL.
Again, the reason why Windows CE works this way is to conserve memory. The first time A.dll is loaded, Windows CE performs all necessary fixups to the code so that references to any global and static variables inside the DLL are correct. If another process loads XYZ.DLL at a different memory address, the system must again perform fixups and this requires more memory. So instead of using the additional memory, the Windows CE architects chose to fail the call to LoadLibrary.

Slot 0, the bottommost 32MB, is special. What appears in this slot is the address space of the currently running process. For example, when a thread in Pocket Word is running (see Fig: 1), Windows CE maps the 32MB region starting at 0×08000000 to slot 0′s region starting at 0×00000000. The process’s address space is actually visible to threads in the application via two different virtual memory addresses: slot 0 and the process’s original slot (slot 4 in this example). If you were to examine the thread’s registers, you’d see that the stack pointer and base pointer registers reflect addresses that are in slot 4 and the instruction pointer register reflects an address in slot 0. When you call functions that allocate memory like HeapAlloc, malloc, or VirtualAlloc, the addresses you get back are inside slot 0, not your process’s original slot.

In WinCE all processes share a single address space, so it seems that applications could easily corrupt each other just like they could in 16-bit Windows. However, Windows CE does not allow one application to corrupt another. Windows CE protects Win32 processes by altering page protections. When a thread in a process is active, all pages belonging to all other processes are protected. An executing thread can touch addresses in slot 0 and in its process’s original slot, but an attempt to touch an address in any other slot causes an access violation to occur.

2.      Create a Hello World Application. This application will be attached to the applet. You can create any other application (Or you can attach an already developed application. Simply you will have to provide path of already in the applet source file, which will be described later).

3.      To create and build the Hello World application

a.      From the File menu, select New, and then select Subproject.

b.      In the Windows Embedded CE Subproject Wizard, select WCE Application.

c.      Type the name HelloWorld for your application in the Subproject name box. Click Next.

d.      In the Auto-generated subproject files page, choose A typical “Hello World” application and then choose Finish.

e.      Your project appears in the Platform Builder IDE, in the Solution Explorer window under the Subprojects node.

f.       In the Solution Explorer window, expand the Suborojects node, and right-click the HelloWorld project name and choose Build.

4.      Your target application is ready. Now we have to create the applet. We will create a DLL application for our Control Panel application and then add specific Control Panel code to it. When it is complete, this Control Panel application invokes a simple application (which we have just created above) called HelloWorld.exe.

5.      To create a DLL project

a.      From the File menu, choose New, and then select Subproject.

b.      In the Windows Embedded CE Subproject Wizard, select WCE Dynamic-Link Library.

c.      Type the name HelloCPL for your Control Panel application in the Subproject name box. Click Next.

d.      Be sure to use the specific name HelloCPL. Some of the code in related steps relies on auto-generated data types that are provided by the New Project Wizard and based on this name.

e.      Note: 

f.       Do not add the .cpl file extension to your project name. You provide this later when

g.      you configure the build settings for your project.

h.      In the Auto-generated subproject files page, select A DLL that exports some symbols and then click Finish.

6.      At this point, the DLL project is simply an empty shell with the correct infrastructure and settings to compile your project into a DLL. The next step is to add the actual code for your Control Panel application.

7.      To add Control Panel code to your project

a.      Open the source file of your DLL project (HelloCPL.cpp)

b.      Replace the existing code with the following code:

//

// HelloCPL.cpp : Defines the entry point for the DLL

//

#include “stdafx.h”    // Auto-generated by wizard.

#include “HelloCPL.h”  // Auto-generated by wizard.

#include “resource.h”  // Auto-generated at compile time

#include <tchar.h>     // General text functions.

#include “cpl.h”       // Control Panel support.

// Returns the number of characters in an expression.

#define lengthof(exp) ((sizeof((exp)))/sizeof((*(exp))))

HMODULE g_hModule = NULL;   // Handle to the DLL.

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

// Main entry point for the Control Panel DLL.

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

extern “C” BOOL APIENTRY DllMain( HANDLE hModule,

                       DWORD  ul_reason_for_call,

                       LPVOID lpReserved )

{

  switch (ul_reason_for_call)

  {

    case DLL_PROCESS_ATTACH:

    {

      g_hModule = (HMODULE) hModule;

    }

    case DLL_THREAD_ATTACH:

    case DLL_THREAD_DETACH:

    case DLL_PROCESS_DETACH:

       break;

    }

    return TRUE;

}

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

// The entry point to the Control Panel application.

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

extern “C” HelloCPL_API LONG CALLBACK CPlApplet(HWND hwndCPL,

                  UINT message, LPARAM lParam1, LPARAM lParam2)

{

  switch (message)

  {

    case CPL_INIT:

      // Perform global initializations, especially memory

      // allocations, here.

      // Return 1 for success or 0 for failure.

      // Control Panel does not load if failure is returned.

      return 1;

    case CPL_GETCOUNT:

      // The number of actions supported by this Control

      // Panel application.

      return 1;

    case CPL_NEWINQUIRE:

      // This message is sent once for each dialog box, as

      // determined by the value returned from CPL_GETCOUNT.

      // lParam1 is the 0-based index of the dialog box.

      // lParam2 is a pointer to the NEWCPLINFO structure.

    {

      ASSERT(0 == lParam1);

      ASSERT(lParam2);

      NEWCPLINFO* lpNewCplInfo = (NEWCPLINFO *) lParam2;

      if (lpNewCplInfo)

      {

         lpNewCplInfo->dwSize = sizeof(NEWCPLINFO);

         lpNewCplInfo->dwFlags = 0;

         lpNewCplInfo->dwHelpContext = 0;

         lpNewCplInfo->lData = IDI_HELLOWORLD;

         // The large icon for this application. Do not free this

         // HICON; it is freed by the Control Panel infrastructure.

         lpNewCplInfo->hIcon = LoadIcon(g_hModule,

                                  MAKEINTRESOURCE(IDI_HELLOWORLD));

          LoadString(g_hModule, IDS_APP_TITLE, lpNewCplInfo->szName,

                     lengthof(lpNewCplInfo->szName));

          LoadString(g_hModule, IDS_HELLO, lpNewCplInfo->szInfo,

                     lengthof(lpNewCplInfo->szInfo));

        LoadString(g_hModule, IDC_HelloWorld, lpNewCplInfo->szInfo,

                     lengthof(lpNewCplInfo->szInfo));

          _tcscpy(lpNewCplInfo->szHelpFile, _T(“”));

          return 0;

      }

      return 1;  // Nonzero value means CPlApplet failed.

    }

    case CPL_DBLCLK:

    {

      // The user has double-clicked the icon for the

      // dialog box in lParam1 (zero-based).

      PROCESS_INFORMATION pi = {0};

      if (CreateProcess(_T(“\\Windows\\HelloWorld.exe”), NULL, NULL,

                             NULL, FALSE, 0, NULL, NULL, NULL, &pi))

      {

        CloseHandle(pi.hThread);

        CloseHandle(pi.hProcess);

        return 0;

      }

      return 1;     // CPlApplet failed.

    }

    case CPL_STOP:

      // Called once for each dialog box. Used for cleanup.

    case CPL_EXIT:

      // Called only once for the application. Used for cleanup.

    default:

      return 0;

  }

  return 1;  // CPlApplet failed.

  }  // CPlApplet

NOTE: It will be good if you understand the purpose of each switch case mentioned in above code.

c.      This code uses an icon resource named IDI_HELLOWORLD and three string resources named IDS_APP_TITLE, IDS_HELLO and IDC_HelloWorld. Before you can compile your application, we must add these resources to the DLL project.

d.      Three string resources, IDS_APP_TITLE, IDS_HELLO and IDC_HelloWorld.

e.      An icon resource, IDI_HELLOWORLD.

f.       To add a resource file to your HelloCPL project:

                        i.        Select your HelloCPL project.

                       ii.        Right-click the node, choose Add, and then choose Add item.

                     iii.        The Add New Item dialog box appears.

                    iv.        Choose the Resource, and then choose Resource File (.rc).

                      v.        In the Name box, type the name HelloCPL for your project’s new resource file. Choose Add. Now close the tab.

g.      To add a string table to your resource file:

                        i.        In Resource View, the Solution Explorer window, expand Subprojects, expand the node for your HelloCPL project, and navigate to HelloCPL.rc.

                       ii.        Double-click HelloCPL.rc.

                     iii.        In Resource View, right-click HelloCTL.rc, and choose Add Resource.

                    iv.        In the Add Resource dialog box, choose String Table and choose New.

                      v.        Double-click a blank line in the String Table window.

                    vi.        Add the IDS_APP_TITLE resource identifier.

                   vii.        In the Caption box, type the string “Hello Control Panel” and to save the value.

                 viii.        Same way add the other resource identifiers IDS_HELLO and IDC_HelloWorld and assign to it the value “A sample Control Panel application”.

h.      To import an icon into your resources:

                        i.        In Resource View, right-click HelloCTL.rc, and choose Add Resource.

                       ii.        In the Add Resource dialog box, choose Icon and choose Import (or you can draw your own icon by clicking New).

                     iii.        The Import dialog box appears and displays your project directory.

                    iv.        Open the directory for your Hello World application.

                      v.        Choose the icon (.ico) file for your HelloWorld.exe, and choose Open.

                    vi.        You can close the window to proceed with the default icon, or you can customize the icon with the available tools prior to closing the window.

                   vii.        Change the resource identifier for your icon to IDI_HELLOWORLD in property of icon.

Now all our projects are created. If this you build the solution it will fail because we have not added the support for CPL.

For the OS to recognize a DLL as a Control Panel application, the file must be built for the correct hardware platform and be named with a Control Panel (.cpl) file extension.

i.        To change the file extension of your output file from dll to cpl:

                        i.        In the Solution Explorer window, right-click the HelloCPL project and choose Properties.

                       ii.        Select the General tab in the dialog box that appears. In the Custom Variables field, click the … button to open the Custom Variables box.

                     iii.        Click the New button. In the Environment Variable dialog box, type CPL in the Variable name text box, and 1 in the Variable value text box.

                    iv.        This will force the HelloCPL application name to have a .cpl extension instead of the default .dll extension.

                      v.        Click the C/C++ tab in the project settings dialog box. To include the appropriate header files, in the Include Directories field, type $(_PROJECTROOT)\cesysgen\oak\inc .

                    vi.        To open the file, expand the HelloCPL\Parameter files node and double-click HelloCPL.bib. Replace the code in this file with the following code:

MODULES

HelloCPL.cpl $(_FLATRELEASEDIR)\HelloCPL.cpl           NK

j.        To verify that HelloCPL is set to export functions as a DLL:

                        i.        In the Solution Explorer window, right-click the HelloCPL project and choose Properties.

                       ii.        Select the C\C++ tab.

                     iii.        Verify that the Additional MacroDefinitions field is set to $(CDEFINES) -DHelloCPL_EXPORTS.

                    iv.        Set the DLL Entry Point field to DllMain

Now build the subprojects.

For example you want to add some folders in “My Documents” as:

\My Documents

                   ..\Project Documents

                   ..\Internal Documents

                                            MyFile.txt

Open Project.dat file and add as given below:

          Root:-Directory(“Program Files”)

          Root:-Directory(“My Documents”)

          Directory(“\Program Files”):-Directory(“ASSET”)

          Directory(“\My Documents”):-Directory(“Project Documents”)

          Directory(“\My Documents”):-Directory(“Internal Documents”)

          Directory(“\My Documents\Internal Documents”):-File(“MyFile.txt”, “\Windows\Myfile.txt”)

 root:[-Directory(“<directory name>”)] [-File(“<final_file_name>”, “<initial_file>”)]

 Where <directory_name> is the name of the directory, <final_file_name> is the final name of the file that is copied from the \Windows directory, and <initial_file> is the name of the initial file in the \Windows directory.

Now do a “Copy Files to Release Directory”. It will first clear your build folder and then will copy all the bib, reg, dat and other required files. Then do the “Make Run Time Image”. Once your image is up, you could find see you new folder tree structure.

2.      You can add the files using .bib file. You can declare the files in FILES section or MODULE section and your file will be added. Better read about FILES and MODULES section from web.

        i.            If your file is an Native executable, add it in MODULE section

       ii.            If your file is an Managed executable, add it in FILES section

     iii.            If your file is not an executable, add it in FILES section

3.      Ordering is not important here.

4.      For example I am adding an .exe file (Native code), .dll file and a .txt file.

MODULES

;  Name        Path                                 Memory Type

;  ———-  ——————————–   ———–

LogStatus.dll  $(_FLATRELEASEDIR)\LogStatus.dll        NK

LoadTest.exe $(_FLATRELEASEDIR)\LoadTest.exe        NK

FILES

;  Name        Path                                 Memory Type

;  ———-  ——————————–   ———–

MyFile.txt      $(_FLATRELEASEDIR)\MyFile.txt             NK

Name: Name of the file which you want to add in the OS image. Its not necessary that this name should be same as the original file. If you want to add file abcd.txt as XYZ.abc, here you can provide name as XYZ.txt.

Path: Path of the file, which need to be added in the path.

Memory Type: Name of the memory area where this file will be loaded.

5.      Open your project.bib file and add your file. 

After providing all these info, Do a “Copy Files to Release Directory”. It will first clear your build folder and then will copy all the bib, reg and other required files. Then do the “Make Run Time Image”. Makeimg.exe will read your bib file entry and look for the specified file at the path which you have declared in “Path” section above. Once your image is up, yoy could find oput your file in \Windows folder.

Click “Settings” button of “Download”: In “Display” tab make Screen width as 740, and height as 480 (NOTE: you can give whatever size you want).

In “Network” tab, select “Enable NE2000 PCMCIA..” check box and click OK

1. Click apply
2. Go to Build and Build the solutions.
3. 
4. Once Solution is build without any error, go to “Target” and and click “Attach Device”
5. you can see the output of an image loading in Output window.