I have taken over a Windows-CE 6.0 application that I would like to port to other platforms. It is a relatively straightforward, self-contained GUI application, written in Embedded C++ Version 4.0
The very first target I am interested in would be a regular Windows desktop (i.e. XP, Vista, Windows-7).
I understand that porting a desktop application to CE is nontrivial; but what about the reverse, which is what I am interested in? Is going from Windows-CE to Windows Desktop (somewhat) upward-compatible? I sure would love to hear "buy this $1000 Microsoft XYZ C++ development environment and just compile and go!"
(FYI I have no experience with GUI applications nor with programming in the Windows environment; pretend I am but a simple linux/unix guy with decades of C/C++ experience but absolutely no Windows-Fu... ;-)
Porting up should, actually, be pretty straightforward. CE is mostly a subset of Win32, with heavy emphasis on Unicode.
You can probably make sure UNICODE is defined, build and, with a little luck, most of it will "just work". Places that are going to be hangups are:
The UI is likely to be set for a resolution that doesn't match your PC - often CE apps are targeted to a specific device and resolution and this doesn't necessarily come out very aesthetic on a PC.
Anything dynamically loaded (GetProcAddress) from coredll will have to be re-mapped to kernel32/user32/etc
If the device uses the SIP (software input panel - i.e. on-screen keyboard) then all of that has to get stripped out.
If the app uses any Notifications (icons, etc) that has to get replaced
If the app uses any power management, that has to get ripped out
If the app uses any device-specific stuff - especially direct calls to drivers, all of that has to be replaced
If the app is using point to point queues, that has to get replaced
If the app is using the device manager (e.g. to get notifications of copnnected devices) that has to get replaced
Any calls into aygshell.dll are likely to be problematic as well.
Related
I know that the new UWP app model has some limitations when comparing to "traditional" Win32 apps.
Let's take Visual Studio Code as an example of a desktop app.
What features of Visual Studio Code were missing or had to be different from user perspective, if it was an UWP app?
EDIT:
I've done exams for microsoft certification "Essentials of Developing Windows Store Apps Using C#" and Exam 70-355: Universal Windows Platform – App Data, Services, and Coding Patterns. So I know something about win rt api.
Please don't bother with answers like "uwp app runs in sandbox". They are useless, because they say nothing about the limitations from users' perspective. I intentionally took real life example, so we can go concrete.
The limitation could be, that your app cannot support 3rd party plugins like custom syntax highlighter or refactorin extension(it was limitation of windows store apps, not sure if its still valid).
Another limitation could be, that your app is not able to take screenshot, because there is no api in uwp for it (not sure it its true, actually)
The phrase "Win32 desktop app" is a ill-defined since the Win32 API programming model has been around since Windows NT 3.1. It can also cover dozens of development languages and UI frameworks over the intervening two decades.
Here's a quick overview of the key UWP differences:
API surface area. The UWP platform supports many but not all Win32 and COM APIs, and introduces new APIs. If your "Win32 desktop app" is using mostly ANSI APIs that date back to Windows 95, then you have a lot of updating to do. If you are using mostly Windows Vista era UNICODE APIs, then a lot of stuff "just works". See Win32 and COM API for Windows Runtime apps (System).
Security context. The UWP platform runs applications in an AppContainer security context. "Win32 desktop apps" on Windows Vista or later run as "Standard User" or as "Administrator". UWP apps have less access rights than "Standard User" and can never run as "Administrator". UWP apps can request additional capabilities to get a few more rights with permission from the user, but have limited access to the system and user data. For example, you cannot read most of the filesystem, only your installed location, an isolated application data folder, and an isolated temporary file folder. See File access and permissions (Windows Runtime apps). This also means UWP apps have limited access to devices. See Device and sensor overviews.
Windows Vista User Account Control that introduced Standard User was focused on protecting the system and other users data compared to the older "everything is administrator" model, but did little to protect the current user's data files since all apps could access or even modify it. AppContainer isolation is protecting both the system and the current user's data and settings. "Win32 desktop apps" were encouraged to install to C:\Program Files which was read-only at runtime and to use application data folders, but they were not required to.
Deployment via AppX. "Win32 desktop apps" use any number of ways of deployment, often something using MSI technology and running as "Administrator". UWP apps are packaged in AppX files and are always deployed by the system. There is no "Custom Install Step", and therefore UWP apps cannot install drivers or services, change ACLs, etc. The system takes care of deploying the C/C++ Runtime (which must be Visual C++ 2015 or later).
Interface model. There is a plethora of interface frameworks for "Win32 desktop apps" like WinForms, MFC, WPF, etc. The vast majority of these are not compatible with UWP because UWP does not support classic Win32 windowing, WM_ messages, or GDI/GDI+. For UWP apps, you can use XAML with C++ or C# code-behind, DirectX (Direct2D and/or Direct3D) with C++ (or C# via 3rd party assemblies like SharpDX), or HTML5 with JavaScript.
Deployment via MSIX.
Answering your question is therefore extremely difficult, if not impossible, without a complete understanding of the product's code base and dependencies.
See Get started with Windows apps
I am running LabVIEW 2013 Dev Environment on a Chinese Windows 8 platform. LabVIEW is not a Unicode-base program, and consequently on Asian Windows there are display issues for our interfaces created with US-English character sets. I can fix this problem by setting the language settings for non-unicode programs to English. This works fine, except that all my other non-unicode-based programs are totally illegible.
A quick google search turned up Microsoft's utility for running application with a user-specified code page, AppLocale. The utility is only written to be compatible up to Windows XP. There are two suggested methods I ran accross for installing it: 1. run installer using compatibility settings 2. install using command prompt with admin privileges (apparently it doesn't play well with UAC. You can find one set of instructions here for installing AppLocale on Windows with UAC.
Unfortunately, nothing I have tried has been able to get LabVIEW to use the code page I would like it to. When I run LabVIEW through AppLocale and open the user-interface I am concerned about, the characters still do not display properly.
Any ideas what I might be doing wrong? Could there be a fundamental incompatibility with LabVIEW?
Does anyone know of an alternative to AppLocale that might work for me?
One alternative to Applocale on windows 8 is Locale Emulator created by xupefei. You will have to have visual studio to build the project.
Make sure that your region settings are set to an english speaking region such as the united states of america. You can check this under
control panel >> clock, language, and region >> region settings
Additionally ensure that you have the language packs installed for the character sets used by LabVIEW. You can check which language packs you have installed under control panel >> clock, language, and region >> language
You will want to have installed support for complex languages
If none of these things work I would try upgrading to windows 10 as it has much better language support
I inherited a huge code base which was written to work on Windows XP. Now we would like to migrate to Windows 7. I do not know what is the proper way to go about this. What is the proper approach to do the above task? I did some googling on differences between XP and Windows 7 but I do not get any proper links which describe how the internals of 7 differ from XP. Any links will be appreciated.
Usually how do S/W developers migrate their code/apps written for one version of OS say Vista to Windows 7?
I sell an autoupdate solution (AutoUpdate+, minor plug) and so have lots of experience porting Windows apps to the latest releases, and yet still maintaining backwards compatibility. Porting from Windows XP to Windows 7 can be a big challenge (there should be almost no difference in a move from Windows Vista to Window 7).
Window XP doesn't care where your application exists, and hence programmers would dump both their application and support logic (log files, config files, user profiles etc.) into the same location under "C:\Program Files\". Take this application to Windows 7 and you'll start finding some unusual behaviors. For starters, you will notice that files seem to 'disappear'. Instead of a log file being modified under the common Program Files location, you may end up with multiple, and separate, copies for each user under "Compatibility / Program Files". Windows Vista/7 introduced file system virtualization, and will now create separate user instances of files to ensure to ensure that each user has their own secure copy.
Another problem you will encounter on Windows Vista, and to a lesser extent on Windows 7, is User Account Control (UAC) prompts. It's similar to the issue above, in that new security restrictions will now cause Windows Vista/7 to prompt the user for approval to proceed. The most noticeable area where this occurs is when you are tampering with executable files in sensitive directories, installing applications and drivers, and sometimes when trying to self-update an app (the abovementioned app actually works around these prompts with some smart logic).
So in short, security changes are the biggest difference between Windows XP and Windows Vista/7. Your best start is to separate application logic (binaries) from supporting logic, by putting the latter into user specific directories. Some apps may never be fixable and can be forced instead to work in Compatibility Mode or to launch always under the Admin account context --- poor workarounds, but may be suitable in your company.
Simon # http://AutoUpdatePlus.com
There are three parts to the migration. First, make it just plain work. This means fixing up hardcoded file paths (there's no more Documents and Settings), changing some of your save locations so you don't need to be elevated to work properly and don't rely on virtualization, changing some of your registry key locations for the same reason, and coping with high-DPI which might now be applied automatically based on screen size rather than as a user's choice.
Second, make it look and work like a Windows 7 application. Is your jumplist usable? Your thumbnail? You get some things for free, do you like what you get or would you like to take control? Are there obvious wins you could use like thumbnail buttons, jumplist tasks, taskbar overlays, etc. Don't surprise your users and don't disappoint your users. (Example of disappointment: VS 2008 and the crummy jumplists it offered. They had the excuse of being released before Windows 7 - you don't.)
Third, take advantage of Windows 7 to be greater than you otherwise would. Stop polling for network joins, file creation, hardware being plugged in, going on and off AC power etc and learn how to get notified when those things happen. Add touch support beyond what you get for free. Talk to a sensor or GPS for the first time, since Windows 7 makes it simpler than it ever was. That sort of thing.
1 is not optional. 2 is really not optional either, a year after Windows 7 is released. 3 will differentiate you and I recommend, once you get past 1 and 2, you look into it.
Basically Windows7 is a 4bit OS and so necessarily runs on a 64bit processor environment. XP has 32bit as well as 4 bit flavours. If your application is for the 32bit version of XP, in that case, the major migration means making the application run on 4bit OS effectively.
The basic steps can be something like this:
Make it compatible to 64bit win7. So you may just compile the code off a win7 machine (on 64bit). If the compilation works fine, you might be able to run the app successfully.
The first step just allows to move ahead. But your application might not be effective. In that case, you might have to review the code for any specific implementation coupled on 32bit os and upgrade them to take advantage of 64bit OS.
The major advantages on 64bit OS is higher address-ability (so access more RAM) and also cache etc.
I did some googling on differences between XP and Windows 7 but I do not get any proper links which describe how the internals of 7 differ from XP. Any links will be appreciated.
API diff report between XP and Vista: https://abi-laboratory.pro/compatibility/Windows_5.0_to_Windows_6.0/x86_64/abi_compat_report.html
API diff report between Vista and 7: https://abi-laboratory.pro/compatibility/Windows_6.0_to_Windows_7.0/x86_64/abi_compat_report.html
The reports are generated by the abi-compliance-checker tool.
As i just need the hard RT capabilities, can I install and run Windows Embedded CE 6.0 on a regular PC ? (dell or so ?), and UDP out some data ?
You can install Windows CE in a PC, but you would need to create your own image. See this tutorial in MSDN. Also google for CEPC.
Finally visit Mike Hall's blog. I remember reading a related article there, but I can't find it now. Anyhow, this blog is a great resource for Windows Embedded.
(From working with Windows CE 5.0, so there may be some differences, YMMV.)
You should be able to run Windows CE both in an emulator and installed on the device itself as the host operating system.
In the first case all you need is an emulator, which is provided with the development kit and in a more expensive version of Visual Studio. This will run the OS fine, albeit a bit slow depending on the architecture you choose to build the Guest OS for.
In the second case you will actually need to find or write drivers for the hardware that you want to run on and use. This will require the Platform Builder application (I believe it's a plugin to Visual Studio now) and knowledge of the hardware that you are running on. Windows CE itself does support x86 processors, although I don't remember if it supports all x86 processors (instruction sets) or just 486's.
If you want to go down the second route you also may be able to get an Intel Atom or AMD Geode board support package (BSP) which will help you develop the drivers.
Many of my users have been telling me that they'd like to run my software on their Linux machines under Wine.
But I'm a Windows Developer who has practically no experience with Linux.
Now I could spend a month or two installing Linux, learning Linux, installing Wine, learning Wine, and thoroughly ensure my application runs well under Wine. But I am still developing for Windows, so I don't want to take so much time away from development right now.
So what can I do without too much effort to get my program running as well as possible under Wine?
I did find this General help on running applications under Wine.
Download VMWare and an Ubuntu virtual machine (Ubuntu is a popular Linux distribution) from the VMWare site. This will provide you with a working Linux O/S inside your Windows environment without needing to install Linux manually.
You can then use the instructions here to install Wine, that Wiki page also provides you with some instructions on how to use it.
If you follow what Adam Rosenfield suggested and just try running your application in Wine unmodified, you will be able to determine quickly whether there are problems. My guess would be that there are some, otherwise your users would not have contacted you about it :)
There are many ways for getting help with debugging applications in Wine, consult the website for options and pick a few ways that suit you. As always, it's best not to rely on a single channel for communication.
Also, if you are more comfortable with developing in Windows, the approach of using a virtual machine will allow you to compile your code as usual in Windows and copy the binary into the virtual machine for testing (Ubuntu supports browsing/mounting Windows shares).
As long as you're not doing anything unusual such as playing around with hardware or poking around in undocumented API calls and data structures, you should be able to run your code under Wine with few or no modifications. Wine has a fairly complete implementation of the public Windows APIs, so if your program plays nice and doesn't mess around, it should just work.
Don't use too much of the windows API! Don't use anything new from Microsoft ;)
Avoid using WPF is the #1 suggestion.
But it really wouldn't kill you to test your app under Wine. It's not that hard to try; it certainly won't take months. For instance:
Use http://www.ubuntu.com/getubuntu/downloadmirrors#wubi to install
Ubuntu into a file on your Windows machine, then start ubuntu and install the latest Wine from
http://winehq.org/download/deb
Then try running your app's installer.
If it doesn't work, check the Wine FAQ, ask for help in one of the wine forums, and/or file bugs in wine's bug tracker.
Should take about three hours from a dead start to trying out your installer.
I was rather surprised when one of my Delphi5 applications just worked out of the zip.
The only real way this is going to work is to do it yourself, i.e. install vmware and a linux distro as Sean suggested. Linux isn't actually that hard, and we're all here to help.
Having done a quick test I can confirm that it largely works. There is an ACCVIO reading 0x34 during start up, the error dialog can be ignored and the application runs, I opened the Steve McCarthy GEDCOM.
Screenshot
This was using Wine 1.1.12 under MEPIS 7.9.94-rc1_32 under VMWare. Highly recommend to use VMWare for this sort of thing.
What language/platform do you develop with? Depending on which it is, it should be no trouble to get it running native. For example, if you use Java or Python, both operate very cleanly on Linux. Likewise, if you're a .NET developer, you should be able, with some pain, to get your app running in Mono.
Find Linux beta testers. It can reports a bug to WINE developers or find a bug in your application.
Wine is more sensitive to errors than Windows. For example, Wine will crash on NULL window handles, and fail to create windows if the class is invalid, whereas Windows is more robust and will just circumvent the error.
It's an opportunity to clean up your code.
I was amazed at how well Wine ran my app the first time I tried. However, I had to get rid of a third-party driver-based component.