Windows CE Interface
- 1 Introduction
- 2 Other Interfaces
- 3 Setting Up the Windows CE interface
- 3.1 Using the stable add-on installer
- 3.2 Using the snapshot add-on installer
- 3.3 Setting up the Windows CE interface manually
- 3.4 Compiling Windows CE project files with Lazarus IDE
- 3.5 Debugging Windows CE software on the Lazarus IDE
- 3.6 Installing and Using the Pocket PC Emulator
- 4 How to add a new control
- 5 Gallery
- 6 See Also
The Windows CE Interface was started by Felipe Monteiro de Carvalho and latter extended by Roozbeh and other contributors. The interface was started on 2006 with a still under development Windows CE FPC compiler. A stable compiler was released on 2007, which made it possible to release a WinCE add-on installer together with the 0.9.24 Lazarus release.
Because of the bad experience with code sharing between similar interfaces in the past with the gtk/gtk2 interface, it was decided to start a clean code for WinCE. Because the APIs are very similar, a lot of the code on the WinCE interface is copyed from the Win32/64 Interface.
- Lazarus known issues (things that will never be fixed) - A list of interface compatibility issues
- Win32/64 Interface - The Windows API (formerly Win32 API) interface for Windows 95/98/Me/2000/XP/Vista/10, but not CE
- Windows CE Interface - For Pocket PC and Smartphones
- Carbon Interface - The Carbon 32 bit interface for macOS (deprecated; removed from macOS 10.15)
- Cocoa Interface - The Cocoa 64 bit interface for macOS
- Qt Interface - The Qt4 interface for Unixes, macOS, Windows, and Linux-based PDAs
- Qt5 Interface - The Qt5 interface for Unixes, macOS, Windows, and Linux-based PDAs
- GTK1 Interface - The gtk1 interface for Unixes, macOS (X11), Windows
- GTK2 Interface - The gtk2 interface for Unixes, macOS (X11), Windows
- GTK3 Interface - The gtk3 interface for Unixes, macOS (X11), Windows
- fpGUI Interface - Based on the fpGUI library, which is a cross-platform toolkit completely written in Object Pascal
- Custom Drawn Interface - A cross-platform LCL backend written completely in Object Pascal inside Lazarus. The Lazarus interface to Android.
Platform specific Tips
- Android Programming - For Android smartphones and tablets
- iPhone/iPod development - About using Objective Pascal to develop iOS applications
- FreeBSD Programming Tips - FreeBSD programming tips
- Linux Programming Tips - How to execute particular programming tasks in Linux
- macOS Programming Tips - Lazarus tips, useful tools, Unix commands, and more...
- WinCE Programming Tips - Using the telephone API, sending SMSes, and more...
- Windows Programming Tips - Desktop Windows programming tips
Interface Development Articles
- Carbon interface internals - If you want to help improving the Carbon interface
- Windows CE Development Notes - For Pocket PC and Smartphones
- Adding a new interface - How to add a new widget set interface
- LCL Defines - Choosing the right options to recompile LCL
- LCL Internals - Some info about the inner workings of the LCL
- Cocoa Internals - Some info about the inner workings of the Cocoa widgetset
Setting Up the Windows CE interface
To set up the Windows CE interface you will need to either use the add-on installer or set up the interface manually. Both options are detailed below. Using the add-on installer is, of course, much easier.
Using the stable add-on installer
With the first stable release of Free Pascal for Windows CE the installation of a WinCE development environment was never easier. The step-by-step guide below is all you need to install and configure Lazarus to compile wince applications.
- Install the latest Lazarus on Windows normally from SourceForge: http://sourceforge.net/project/showfiles.php?group_id=89339
- Download and install the add-on installer (cross-arm-wince) for the same Lazarus version you just downloaded. It's on the same Source Forge Download page.
- You can now compile arm-wince application from within Lazarus by changing in the compiler options:
- Projects -> Compiler Options... -> Paths -> LCL Widget Type: wince
- Projects -> Compiler Options... -> Code -> Target OS: wince
- Projects -> Compiler Options... -> Code -> Target CPU Family: arm
- To reduce build filesize, in the Projects -> Compiler Options... -> Debugging section, check Strip symbols and uncheck all the rest.
Using the snapshot add-on installer
Instead of using the stable release, it's also possible to use the latest development version of the Windows CE interface through the daily snapshot. It's untested, but may be helpful if you need fixes which were added after the latest stable release and consider building everything yourself too hard or too much work.
- Install the latest Lazarus snapshot on Windows normally from here. Make sure you choose a Win32 snapshot with the exact same FPC version as the WinCE snapshot: http://www.hu.freepascal.org/lazarus/
- Download and install the add-on installer for the same Free Pascal version you just downloaded. It's on the same page.
- The rest of the steps is similar to the step-by-step guide on using the stable add-on installer
Setting up the Windows CE interface manually
While the 0.9.26 release was made with the stable Windows CE FPC Compiler version 2.2.2, the development version of Lazarus now requires FPC 2.2.4 or higher. Here are instruction to set this environment up:
Step 1 - To start with you will need to recompile the compiler on Windows to create a Windows CE - ARM Crosscompiler. There are instructions here: WinCE port.
- Use TortoiseSVN to checkout the latest 2.2.5: http://svn.freepascal.org/svn/fpc/branches/fixes_2_2/
- Then create a batch script like this one to build your compiler starting from your installed FPC 2.2.4 (either from Lazarus or from separate install):
cd compiler PATH=C:\Programas\lazarus220\fpc\2.2.4\bin\i386-win32 make cycle CPU_TARGET=arm OS_TARGET=wince cd .. pause
Step 2 - You also need to compile FCL (Free Component Library) with the newly built compile. Instructions here.
- This clever batch script makes this easier (don't forget to fix the paths to your machine). OPT="-FU... will put all compiled units on the same place, which is very convenient, (but can cause problems. It is better to use a make clean all install instead):
cd packages PATH=C:\Programas\lazarus220\fpc\2.2.5\bin\i386-win32 make clean all CPU_TARGET=arm OS_TARGET=wince PP=ppcrossarm.exe OPT="-FUC:\Programas\lazarus220\fpc\2.2.5\units\arm-wince" cd .. pause
Step 3 - Put the batch file bellow on the root of your subversion Lazarus directory and run it
PATH=C:\Programas\lazarus22\fpc\2.2.5\bin\i386-win32;c:\Programas\arm make lcl LCL_PLATFORM=wince PP=ppcrossarm.exe CPU_TARGET=arm OS_TARGET=wince pause
This should compile LCL for Windows CE.
Step 4 - Cross-compile the LazarusPackageIntf so you can use 3rd party visual components. Go to lazarus\packager\registration and do:
PATH=C:\Programas\lazarus22\fpc\2.2.5\bin\i386-win32;c:\Programas\arm make PP=ppcrossarm.exe CPU_TARGET=arm OS_TARGET=wince pause
NOTE: you need to specify $(LazarusDir)\packager\units\$(TargetCPU)-$(TargetOS)\ into your project's unit path (adding FCL as requirement should do that).
Step 5 - Now you can use Lazarus IDE to design,compile and debug your applications.
- You can also use scripts similar to this for compiling your applications:
PATH=C:\Programas\lazarus22\fpc\2.2.5\bin\i386-win32;c:\Programas\arm ppcrossarm.exe -Twince -FuC:\Programas\fpc\rtl\units\arm-wince -FDC:\Programas\arm -XParm-wince- test.pas ppcrossarm.exe -Twince -FuC:\programas\lazarus\lcl\units\arm-wince -FuC:\programas\lazarus\lcl\units\arm-wince\wince -FuC:\Programas\fpc\rtl\units\arm-wince -FDC:\Programas\arm -XParm-wince- windowtest.pas pause
Compiling Windows CE project files with Lazarus IDE
NOTE: recently a "wincemenures.or" file is reported missing on linking. You just need to copy this file from "lazarus/lcl/interfaces/wince" to "lazarus/lcl/units/arm-wince" and everything will be fine.
Everything is just as you do with other interfaces and OSes. Make sure you have selected wince as widgetset in in Compiler Options->Paths and in Code tab page select WinCE as target os and arm as Target CPU.
If you compiled your own compiler or installed it without using the Lazarus add-on installer, you also need to change compiler path in Environment options to point to your ppcrossarm.exe compiler. In other cases the compiler should already be set to the correct one, which is fpc.exe, which is a front end which chooses the correct back end compiler for the target CPU. In this case the path will be similar to C:\lazarus\fpc\2.2.2\bin\i386-win32\fpc.exe varying with the version of your installed FPC.
Now IDE is ready to compiler your files.
Debugging Windows CE software on the Lazarus IDE
You can also debug applications created within Lazarus IDE.
Step 1 - In Lazarus IDE go to the menu Environment->Debugger Options. Change the debugger path to the directory with gdb for wince.you can get it from here ftp://ftp.freepascal.org/pub/fpc/contrib/cross/gdb-6.4-win32-arm-wince.zip
And you also need to have ActiveSync installed for gdb to work. You can get ActiveSync here: http://www.microsoft.com/windowsmobile/en-us/help/synchronize/activesync45.mspx
Step 2 - If you are using Microsoft Device Emulator Preview, launch(or restore)it.Make sure you've started emulator with 128MB of RAM.Select a path for shared folders in emulator, add copy command to your .bat file used for building your application to copy the compiled exe file to your shared path.(as you can see in my .bat file).Here is a .bat file you can use to launch emulator with 128 of ram.
start deviceemulator.exe ".\ppc_2003_se\PPC_2003_SE_WWE_ARMv4.bin" /memsize 128 /skin ".\ppc_2003_se\PocketPC_2003_Skin.xml"
After that just do 'save and exit' whenever you want to quit emulator,and launch it again from shortcuts created in your start menu.(the shortcuts with '(restore)').
Step 3 - Run Device Emulator Manager and in available emulators right click on the name of emulator and do cradle.Now Microsoft ActiveSync will be launched.If not in Micrososft ActiveSync Go to the menu File->Get connected.If still ActiveSync doesn't recognize the emulator.Uncradle and Cradle the emulator again.
Step 4 - Copy that file with File Explorer program in your emulator to \gdb directory.If it is your first time running emulator you have to create a gdb directory in 'My Pocket PC' folder which is your root(\) folder.(To make things even faster for your each build,with file explorer go to your shared folder,press ctrl+c in your exe file,go to \gdb folder and each time before you try to debug your application just press ctrl+v)
Step 5 - Now you can safely debug your application.gdb for wince will be launched.it will copy arm-wince-pe-stub.exe to \gdb folder and check if your application.exe file is there and will launch the program. If you encountered an error make sure the \gdb folder is created,arm-wince-pe-stub.exe and you exe file is there.Also most of the times because of big size of exe file you can not copy that into your \gdb file.So you have to call Microsoft Device Emulator Preview with 128mg of ram instead of default 64mg ram.
1. Programs remain in memory still after exiting from them. So you can't overwrite the .exe file. You have to use tools like Process Viewer from Microsoft which remotely shows all processes and allow you to kill them. Or use process killers inside the emulator. Process Explorer is another good option. One can get it from http://madebits.com
2. Each time you are done with debugging your program don't exit from program.Do program Reset and then Debugger reset. Note that sometimes still program remain in memory,so you also have to kill the process too.
3. You can change the remote directory from /gdb to yours by add gdb parameter --eval-command="set remotedirectory ...
--eval-command="set remotedirectory \Storage Card\Program Files\My Program\bin"
4. You can reduce the size of exe file by check "Use external gdb file debug symbols file -Xg", and "Strip Symbols -Xs", the file myapp.gdb generated and stay at your computer to use it with the gdb.
Installing and Using the Pocket PC Emulator
Windows Mobile 5.0 Emulator
1 - You can download a Pocket PC Emulator from Microsoft here. First, download and install the file V1Emulator.zip.
2 - Next, be careful that there is a wrong information on the website. It will say that you need to install the Virtual Machine Network Driver, but the link provided on the website is broken. Instead, download Virtual PC 2007 here. This will install the necessary driver too.
3 - Now, go back to the first website and download and install the efp.msi file
Now you should have a fully functional PocketPC Emulator which can be utilized together with Lazarus to develop applications.
To run a Lazarus application on the emulator you can either use GDB via ActiveSync, or you can also just execute it directly.
Never Emulators and Images
Running an application on the emulator
1 - Go the the Windows Programs Menu --> "Windows Mobile Emulator Images" --> "PocketPC"
2 - If you never configured your shared folder for the emulator, do so now, by clicking on the menu File --> Configure once the emulator opens. Set it to a folder where you can access your Windows CE executable created with Lazarus.
3 - On the emulator click: Start --> Programs. Now select "File Explorer". Now select "Storage Card". Navigate until you find your executable and double click it to execute it.
How to add a new control
For example TButton.
TButton is defined in lcl/buttons.pp. This is the platform independent part of the LCL, which is used by the normal LCL programmer.
Its widgetset class is in lcl/widgetset/wsbuttons.pp. This is the platform independent base for all widgetsets (qt, carbon, gtk, win32, ...).
It's wince interface class is in lcl/interfaces/wince/wincewsbuttons.pp:
TWinCEWSButton = class(TWSButton) private protected public class function CreateHandle(const AWinControl: TWinControl; const AParams: TCreateParams): TLCLIntfHandle; override; end;
Every WS class, that actually implements something must be registered. See the initialization section at the end of the wincewsXXX.pp unit:
Also notice that DestroyHandle should be implemented to clean up memory utilized by the control.
Bellow are screenshots of applications created with Lazarus for Windows CE:
Virtual Moon Atlas - A free software for Moon observation or survay ( http://ap-i.net/avl/en/start ):
LazCalendar - A simple calendar application:
germesorders - A simple database application using sqlite and RxLib
ZzOo, pronounced /'zi:zu:/, is a free Western Zodiac sign finder.
Mini SQLite Viewer - Simple SQlite viewer/manager for WinCE and Win32
- Windows CE Interface Development notes
- Alternative Lazarus Windows CE tutorial using Win64
- Roadmap for the Windows CE interface
- Mini framework for WindowsCE applications: pkMiniGUI.pas Documentation
- WinCE port of KOL GUI library - compact applications for WinCE/Win32.
- WinCE port - About the compiler specific parts of the port