Today it happened to look at http://www.microsoft.com/surface. It is a innovative next generation user interface for day to day. Microsoft says about this in their press release:
The launch of Microsoft Surface marks the beginning of a new technology category and a user-interface revolution. Surface, Microsoft’s first surface computer, provides effortless interaction with digital content through natural hand gestures, touch and physical objects. Surface computing breaks down traditional barriers between people and technology, changing the way people interact with all kinds of everyday information — from photos to maps to menus.
If you don’t get any clue from the above press release, just visit http://www.microsoft.com/surface.
This HowTo covers how to copy and paste the files/text/graphics (Clipboard) content between remote desktop session and local computer in Windows XP.
Follow the following instruction in both local and remote computers.
Go to Start->Control Panel->Administrative Tools->Services. Enable and start the following services in the order shown below:
1. Network DDE DSDM 2. Network DDE 3. ClipBook
If you want to see the clipboard action in live:
You can go to Start->Run and type clipbrd and click OK to run clip board viewer. You will be shown current clipboard objects in this viewer.
Now you can use standard copy/paste menu options of the applications in both the computers to exchange the data.
The Microsoft has released Windows CE 6.0 version yesterday. The most exciting feature for me is the share kernel source (Since I don’t do any active platform building nowadays, I don’t bother much about other features in this shiny new version. You may refer this link for more info on that.
Why I consider open kernel source as important feature in Windows CE? Reason is obvious. Windows CE is not a Server or Desktop oriented OS, but it is closely bound with hardware of the system. In my ex-profession, our team had to live with Windows CE. We intended to tune the OS to our ever changing requirements, the effort continues still. Since we have struggled a lot with debugging device driver code and not knowing the limitation of Windows CE API (which is a small sub set of Win32 API), this is definitely a big boost to my friends who work in that project still. The following are expected impact due to shared kernel source on any Windows CE based project:
1. Hard core developer of Platform builder, who takes care of configuring the system according to the hardware configuration will get more help from the kernel source which sits very much in his own IDE. Debugging the kernel mode drivers will no more be a nightmare.
2. Windows CE kernel can be customized for smaller foot print and better performance. This is absolutely necessary in the embedded world.
3. This will pause the people who intend to move to Embedded Linux for technical compulsion, and have them to re look at Window CE. The chances for support to Windows CE from both technologist and management are very well there.
4. The Shared Source License has been simplified which may affect the production cost of the end product. Any body who knows, can post a comment on this. Here is a link on license details.
5. Getting a shared source kernel for paying big $$$$ for microsoft is reasonable now… happy to see this 🙂 🙂
Happy kernel hacking, my dear Windows CE friends!
If you are bored with Windows XP Luna theme (Blue/Silver/Olive), here is a nice looking theme available for download. Actually it is meant for Windows Media Center edition. But it looks awesome in Windows XP.
Install the downloaded theme. Then go to Desktop and right click for properties. In Themes tab, select “Royale” in Themes drop down box. Apply and Enjoy!
Here is the screenshot of my Royale theme.
The threads share several variables or a data structure. Often, these multiple variables or the fields of the structure must be consistent among themselves. The operating system could interrupt a thread in the middle of updating these variables. The thread that uses these variables would then be dealing with inconsistent data. The result is a collision, and it’s not difficult to imagine how an error like this could crash the program. What we need are the programming equivalents of traffic lights to help coordinate and synchronize the thread traffic. That’s the critical section. Basically, a critical section is a block of code that should not be interrupted.
Declaring: CRITICAL_SECTION cs ;
Initializing: InitializeCriticalSection (&cs) ;
Entering: EnterCriticalSection (&cs) ;
Leaving: LeaveCriticalSection (&cs) ;
Deleting: DeleteCriticalSection (&cs) ;
The most common use of multiple threads of execution is for programs that find they must carry out some lengthy processing. We can call this a “big job,” which is anything a program has to do that might violate the 1/10-second rule. Obvious big jobs include a spelling check in a word processing program, a file sort or indexing in a database program, a spreadsheet recalculation, printing, and even complex drawing. Of course, as we know by now, the best solution to following the 1/10-second rule is to farm out big jobs to secondary threads of execution. These secondary threads do not create windows, and hence they are not bound by the 1/10-second rule.
Create: hEvent = CreateEvent (&sa, fManual, fInitial, pszName) ;
Set the Event state as signalled: SetEvent (hEvent) ;
Set the Event state as unsignalled: ResetEvent (hEvent) ;
Waiting for the signalled state: WaitForSingleObject (hEvent, dwTimeOut) ;
Waiting for the multiple signalled state: WaitForMultipleObject (…) ;