Well, presentation is over. I must confess that it was really strange feeling speaking and not seeing anybody. It is so unnatural.
It wasn’t without hitch (even incorrect code was working by accident) but hopefully it was good enough for everybody listening.
Here are source files used during presentation.
I will give link to presentation recording as soon as it goes up.
Tomorrow (2009-04-01) I am giving presentation at TechDays virtual conference. Presentation is titled “64-bit where art thou” and it will be about transition to 64-bit framework and issues that can arise. I will try to keep it low on power point and illustrate all through C#.
For “ages”, monitors had resolution of 96 dpi. Every OS and application was designed with it in mind (usually only tested on that resolution). If you buy LCD screen these days, you will see that everything looks a lot smaller. In order to have fine grained picture, pixel density has gone way up. However, your OS still draws everything like it did for years and your eyes are going mad.
Solution is to change DPI to suit your comfort level (usually 125% (120 dpi) is enough). After restart (log off is enough for Windows 7), everything grows a little bit. Applications that are dpi-aware will scale properly and everything should look fine.
Old applications that are not aware that 96 dpi is out of fashion, will not look so nice. Most common issues will be some controls that went outside of form bounds and text wrapping at weird places. It can happen that just one button you need is unreachable (notice on this picture, there is also cancel button way to the right - outside of window).
In order to solve this issue, Windows Vista will lie to those applications that everything is still in 96 dpi and then manually scale it (Aero is needed - DWM is culprit). Although this will solve problem with unaware applications, it will also make windows blurry (physics of stretching cannot be avoided). This may seem like a pretty good trade until you became aware that application that knew how to scale in Windows XP gets same blurry treatment (e.g. Visual Studio 2008). Windows Vista assumes that all old applications are DPI unaware and it requires application change to behave “just right” (as easiest solution, you can check ignore DPI on compatibility settings).
Reason behind Windows Vista recognizing all old applications as “problematic ones” is that there is new API in place to assure application is capable of scaling. Since that API hasn’t been there before Vista, applications will not call it. If they do not call it, Vista will think that they cannot scale. Solution is to get new version. Depending on application, that can pose a problem (e.g. there isn’t newer version of Visual Studio 2008 - it doesn’t scale even with service pack applied).
This behavior has changed with Windows 7. Microsoft recognized that most of applications know how to scale and even if they cannot, 25% increase (120 dpi is most common) will trim very little of content. Your application will, for all practical purposes, revert to XP high-DPI behavior.
If you decide to go higher than this (e.g. 150%), DWM will kick back in and scaling will take over. Although this will again make windows blurry (for Vista DPI non-aware applications), it will also make everything fit.
Since DPI settings higher than 120 dpi are not so common, I find this a worthy compromise.
Plenty of applications inside mobile windows make use of backspace key. Just imagine how difficult and unintuitive would be to create even simplest folder browser if you could not use that key. However, on smartphone you have just that situation.
Smartphone (or Windows Mobile Standard) is specific in sense that backspace is used as system-wide key for application switching. You can think of it as Tab in normal applications. It is not something you usually override but sometimes overriding that key can prove to be useful. In our desktop application we would just override ProcessCmdKey function or in worse scenario (older frameworks), just override WndProc. This would allow us to intercept those special keys and use them for our own evil purpose.
However, if we try to do this for Smart Device project we have a big problem. Neither of those two functions is supported. Reason is simple - compact framework is trimmed as far as they could go. In my opinion they took it too far.
Those who worked in times before .NET framework, may remember SetWindowLong function and that one of parameters enabled developer to set their own window procedure (GWL_WNDPROC). Fortunately, that is supported (as interop call).
In order to simplify development, I tried to keep it as familiar as possible. Whole idea is to create base form with required WndProc function and later just inherit from it. Whole procedure can be seen from sample, so I will only cover base steps.
Each form that needs to intercept backspace will also need to inherit from WndProcForm. Since WndProcForm inherits from Form, you can safely change that in already existing applications and they should retain their functionality (do not forget to recompile application once you do that - otherwise designer may complain until you can do so). Designer will complain that there visual inheritance is no longer supported for that form (P/Interop is reason) but you may safely ignore that if you don’t have visual components on multiple forms.
After that, simple matter of overriding WndProc and waiting first for WM_HOTKEY and then for both MOD_KEYUP (key is depressed) and VK_TBACK (same code as for escape) will do the job.
Notice that while I only give instructions on one usage, you may use this to intercept any window message going to your window. And that is lot of messages. This is also applicable to Windows Mobile Professional (Pocket PC) for those extended cases (although backspace is not used as switch key there).
Resources
There is one decision that every .NET developer needs to face - which target platform should I use?
From my experience most developers leave it on AnyCPU. This usually works just fine (at least on their machine ;)) but understanding option could make all the difference.
x86
This is our 32-bit processor. If we run it on 32-bit OS, it is 32-bit application. If we run it on 64-bit processor, it still runs as 32-bit application (WOW64 takes care of that). It’s whole world fits inside of 32 bits no matter what underlying platform is capable of. I would dare to say that this world may be your wisest choice if you need to play with old technology.
x64
This is what we call 64-bit processor these days. AMD calls it “AMD64”, Intel thinks of it as “Intel 64”, but essentially, it is same architecture. It doesn’t run on 32-bit processor or 32-bit OS. Everything needs to be 64 bits in order to fit. It will not work faster, it will consume more memory, but it is our future. This big boy doesn’t play well with his 32-bit friends.
Itanium
Someone at Intel had a thought: let’s have pure and modern 64-bit design without any compatibility worries. Let’s make it work as fast and effectively as possible. IA64 architecture was born. Unfortunately, it was born in wrong age. 32-bit applications had ruled the world back then and this processor was very slow in x86 compatibility mode. This one is lone wolf - doesn’t play well with neither x86 or x64 programs.
AnyCPU
This is chameleon of all targets. If you run it on 32-bit system, it will work as x86. If you run it on x64, you get program that looks like it was compiled for it. Itanium looks native to it also. But (there is always a but), it’s process has same limitations of platform it is pretending to be.
This is done through miracles of IL which emits instructions for whatever underlying architecture really is.
There is also a small price to pay. If you, as a programmer, work on 32-bit system, all your calls to non-.NET world (e.g. Win32 API) are done in 32-bits. However, if you run your program on 64-bit system, all your pointers get 64-bit treatment. For those not watching carefully (e.g. using integer where pointer is needed), world may end up collapsing.
This problem is more visible in VB.NET than C# because of code reuse (and they told you that is a good thing). Lot of VB.NET programmers have background in VB 6 and there is lot of API code written for it. Problem was that there were no pointers there. People used Longs instead of pointer - both of them were 32 bit numbers. Everything worked. Then VB.NET came and long became integer, and everything still worked. At least in 32-bit world. When executed as 64-bit process (either target was x64 or AnyCPU) problem occurred since there was four bytes per pointer missing. Those bugs can be sometimes very hard to catch.
Which one to use
I use AnyCPU unless I need to work with some component that has no 64-bit version. I know that 64-bit processes use more memory (all pointers are double in size) and there is no real speed benefit, but if customer opted to have 64-bit OS, he had some reason for it.
I see no point in overriding his choice and avoiding future. I view it as 16-bit to 32-bit transfer. Not all programs needed it, but it was inevitable. Just do it in 64 bits.