Image Taken From Microsoft.com

• To show all the folders on your computer in the navigation pane, including your personal folder, select the Show all folders check box, and then click OK.
• To automatically expand the navigation pane to the folder that’s selected in the folder window, select the Automatically expand to current folder check box, and then click OK.

Mind that this may reduce your system performance if you’re working with network drives or clear-case views.

Somehow I managed to get the Windows 7 boot USB to repair my startup for Windows. Again it had happened. The Master Boot Record wasn’t promptly recognized by Windows. It says no problems at all with your Windows Installation. What’s next. I have tried several options to like Fixing the MBR with command line and exporting and importing the boot record and importing it again to corrupt the MBR and tried the repair again. No ways!

Finally how I had to recreate the MBR. How do we do that? (BTW, do this at your own risk. Don’t blame me later)

1. Insert your bootable DVD/USB or Startup repair disc to your computer.
2. Choose Recovery options.
3. Click on Startup Repair and check if it works.

If doesn’t work

4. Open the command window and enter the following commands

bootrec.exe /fixmbr
bootsect.exe /nt60 all /force
bootrec.exe /rebuildbcd

Now you’re done. Reboot your PC and see if it works. Under Windows Vista, you will have to change to X:\boot\ folder to access bootrec and bootsect executable.

Please check the following links to explore more.
How to integrate a simple ribbon with your MFC Application?
How to handle Ribbon Control Events?
Ribbon designer (MSDN)

Old APIs were using CSIDL for representing the known location identifier. This has been replaced by KNOWFOLDERID. However Windows Vista and 7 still supports CSIDL and associated APIs for compatibility reasons. The new applications has to use the new APIs or COM Interface. When using both COM/New Shell API, you’ve to ensure that CoTaskMemFree function is called to release the output resources. Otherwise memory leak may occur. Also don’t call any other memory release function like free or delete operator. It may cause undefined behavior

How to Enumerate All Known Folders?

void EnumerateAllKnownFolders(CStringArray& strArray)
{
	CStringArray strPathRet;
	IKnownFolderManager* pkfm = NULL;
	HRESULT hr = CoCreateInstance(CLSID_KnownFolderManager, NULL,
		CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pkfm));

	if( SUCCEEDED(hr))
	{
		KNOWNFOLDERID* rfid;
		UINT uCount = 0;

		if( FAILED( pkfm->GetFolderIds( &rfid, &uCount )))
			return;

		for (UINT uIdx = 0; uIdx < uCount; ++uIdx )
		{
			IKnownFolder* pFolder;
			pkfm->GetFolder( rfid[uIdx], &pFolder );
			LPWSTR szPath;
			pFolder->GetPath(0, &szPath );
			strArray.Add( szPath );
			CoTaskMemFree( szPath );
			pFolder->Release();
		}

		CoTaskMemFree( rfid );
		pkfm->Release();
	}
}

How to get the path of a specific known folder using new COM Interface?

CString GetKnownFolderIDCOM( KNOWNFOLDERID rfid )
{
	CString strPathRet;
	LPWSTR szPath;
	IKnownFolderManager* pkfm = NULL;
	HRESULT hr = CoCreateInstance(CLSID_KnownFolderManager, NULL,
		CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pkfm));

	if( SUCCEEDED(hr))
	{
		IKnownFolder* pFolder;
		pkfm->GetFolder( rfid, &pFolder );

		pFolder->GetPath(0, &szPath );
		strPathRet = szPath;
		CoTaskMemFree( szPath );
		pFolder->Release();
	}
	pkfm->Release();
	return strPathRet;
}

How to get path of a specific known folder Shell API?

CString GetKnownPathShell( KNOWNFOLDERID rfid )
{
	CString strPath;
	LPWSTR szPath;
	SHGetKnownFolderPath( rfid, 0, 0, &szPath );
	strPath = szPath;
	CoTaskMemFree( szPath );
	return strPath;
}

Registry Virtualization emulates the HKEY_LOCAL_MACHINE\Software write operations under HKEY_USER\<User SID>_Classes\VirtualStore\Machine\Software path.

Open Registry Virtualization – If the application doesn’t have enough privilege to open a specific key, the virtualized key will be opened with maximum privilege.

Write Registry Virtualization – If the application doesn’t have enough privilege to write to the specified location, the write operation will be performed under virtual store path.

Read Registry Virtualization – System provides a merged copy of information from Virtual store and the original global store together.

Virtualization is provided for

• 32 bit interactive process
• Keys in HKEY_LOCAL_MACHINE\Software
• Keys that an administrator write to (if the application doesn’t have privilege)

Virtualization is disabled for

• 64 bit processes
• Processes which doesn’t have GUI (e.g Services)
• Process that impersonate a user
• Kernel mode processes such as drivers
• Process that has specified requestedExecutionLevel in their manifest
• Keys and subkeys of HKEY_LOCAL_MACHINE\Software\Classes, HKEY_LOCAL_MACHINE\Software\Microsoft\Windows, and HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT.

The applications which required to run under Windows Vista and 7 must follow the UAC guidelines and should not use registry to store the applications information. Microsoft may stop supporting this feature in the upcoming versions of Windows. So keep your applications compatible with the latest platform.

See more

• Registry Virtualization
• UAC Developer Guide

Twitter user timeline can be accessed from

http://api.twitter.com/version/statuses/user_timeline.format

The format suffix supports following formats – XML, JSON, RSS and ATOM.

Optional parameters can also be specified in the URL like screen_name, user_id, count (must be less than 200) etc.

For e.g to access my twitter timeline, the URL can be formed as below

http://api.twitter.com/1/statuses/user_timeline.xml?screen_name=sarat

You can find more information about this in the twitter API documentation.

Similarly you can access public timeline as follows. The supported formats are same. Check Twitter Documentation

http://api.twitter.com/version/statuses/public_timeline.format

Now how we access the client, there are several methods to access and parse an XML stream in the .NET environment. Let’s go for LINQ to XML, which is the easiest and flexible way.

A basic twitter stream is having the following structure. You can easily generate this using xsd tool available in the .NET framework tools. Just give the XML path generate the schema definition file. Note that the several information associated with the tweet is hidden under the scrollbars.

Note that we’re going to access using public data querying, there’s no twitter API is ursed. The reason why we’re going for LINQ to XML is, syndication classes are not supported in all environments even it’s safe to use and forcefully add. For e.g. in Windows Phone 7 environment, Syndication classes are not supported. We can forcefully add assembly and use it, but by default it’s filtered out.

WebClient is the easiest way to query a request in several forms.

Declare the Tweets class with required information. You can contain any information which is available in a tweet/user. Ultimately it you who ultimately decide what you want to show. Here for this example, taking only minimum set of information. User name, profile image and tweet.

public class Tweet
    {
        public string UserName { get; set; }
        public string Message { get; set; }
        public string ImageSrc { get; set; }
    }

Make the request,

WebClient twitterAccess = new WebClient();
            twitterAccess.DownloadStringCompleted +=new DownloadStringCompletedEventHandler(twitterAccess_DownloadStringCompleted);
            twitterAccess.DownloadStringAsync( new Uri( "http://api.twitter.com/1/statuses/user_timeline.xml?screen_name=" + twitterUser.Text ));

Note that the request is asychronous and the thread will not be blocked until we receive the result.

XElement is the fundamental class helps us to process the downloaded string and query the required information. The data will be dynamically queried and made into class. This is done for each result of query within the entire string downloaded.

void twitterAccess_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs args )
        {
            try
            {
                XElement xmlTweets = XElement.Parse(args.Result);
                listboxTweets.ItemsSource = from tweet in xmlTweets.Descendants("status")
                                            select new Tweet
                                            {
                                                ImageSrc = tweet.Element("user").Element("profile_image_url").Value,
                                                Message = tweet.Element("text").Value,
                                                UserName = tweet.Element("user").Element("screen_name").Value
                                            };

            }
            catch
            {
                MessageBox.Show("Error downloading tweets");
            }

        }

The query is simple and straight forward.The query is made for the descendants of under “status” which is depicted in the above figure. the result will be put on “tweet” from which we can query the further subnodes of an XML. Note that the result of query generates an array Tweet instances which can be used as the item source for data for visuallization. You can use it in your own way. In this example, this set for the data source of an listbox.

ImageSrc, Message and UserName are the properties of the Tweet class and this can be used in the ItemTemplate of ListBox to Visualize them. The resultant XAML may appear as below

<ListBox x:Name="listboxTweets" Margin="12,74,13,17" ItemsSource="{Binding ''}">
        		<ListBox.ItemTemplate>
               		<DataTemplate>
               			<StackPanel Orientation="Horizontal" Height="150" Margin="0,0,7,0" Width="480">
               				<Image Source="{Binding ImageSrc}" Height="73" Width="73" VerticalAlignment="Top" Margin="0,10,8,0"/>
               				<StackPanel Orientation="Vertical" Width="376" HorizontalAlignment="Right">
								<TextBlock Text="{Binding UserName}" Foreground="IndianRed" FontSize="28" Margin="5, 0, 0, 0"/>
		               			<TextBlock Text="{Binding Message}" TextWrapping="Wrap" Margin="5,0,0,0"/>
							</StackPanel>
						</StackPanel>
			   		</DataTemplate>
			   </ListBox.ItemTemplate>
			</ListBox>

The data binding is simple. We’re defining how an item should be rendered inside the list box using the ItemTemplate speification. You can find more information on data template in MSDN. PS: When you define the class, please make sure Data Binding class is declared as public otherwise no data will be displayed in the listbox. Also make sure that you’re declaring properties (with get;set;) instead of fields (member variables) It’s simple isn’t it? Check MSDN to know more about data binding of Silverlight/WPF applications. Here’s the Windows Phone 7 Application which displays the tweets from my time line. 

I’m not posting the entire project because it’s just in the development stage. Only intended to explain the core part of the code. Have a nice time with querying tweets.

All programs for Windows Phone 7 can be written in .NET managed code. Currently C# is the only programming language supported. The tools for Windows Phone 7 can be freely downloaded from Windows Phone 7 website. It includes

• Visual Studio 2010 Express Edition
• XNA Game Studio 4.0
• On Screen Phone Emulator

Windows Phone 7 can be programmed mainly using XNA FrameWorks and the popular Silverlight platform. XNA is used for high performance games (usually 3D games) and Silverlight is usually used for the 2D graphical applications.

Windows Phone 7 contains the stripped down version of Silverlight 3. Microsoft has avoided the silverlight features which are not really compatible with the Windows Phone 7 platform. The animations for the programs can be down using the Microsoft Expression Blend

Ultimately it comes to programmer’s responsibility to choose which platform should be used for programming Windows Phone 7 application.

Windows Phone 7 contains the Azure services to access the cloud service. One of the examples are XBox Live (runs on cloud). Programs are location aware and can access data through bing, social networking websites etc.

Windows Phone 7 features Multi-Touch screen with 3 navigation buttons. Back (like the back button in the browser. This will terminate the application),  Start button (to navigate to home screen), Search. Currently the native resolution of a Windows Phone hardware is 400×800. Also 320×480 resolution screen is expected. The hardware component features

• Wi-Fi
• Camera
• Accelerometer – to detect the movement of the phone
• GPS based Location
• Vibration (programmable)
• FM Radio
• Push notifications

Once after downloading the tools, you can either start programming in the Visual Studio Express Edition or Visual Studio 2010 (if it’s already installed).

Here I’m demonstrating a basic Windows Phone 7 application in Silverlight. The code is only tested in Simulator not on any real hardware.

Create the new project using the Wizard

The basic layouts will automatically be created using the XAML and corresponding C# source will also be created. Notice that the standard controls available in the Windows phone 7 is not similar to the controls available in Windows. They’re transparent and designed for the phone. The entire theme is based on black. You can simply start debugging/execute the code using the emulator available. It’s better not to close the emulator Windows frequently as it may take time to start it up. The program will automatically deployed and starts in the emulator.

The user actions like home screen, back button, search etc will end up the application by default. The application must manage itself to restore the previous state if necessary on quit.On startup Windows phone 7 emulator will ask for the basic setup. It’s very easy to set it up and this is a one time process. The emulator can be used for changing the orientation between portrait and landscape. The buttons are available on the right top corner of the emulator window on hovering the mouse.

The demo application loads the posts from this blog and display it, whlie tap on the post titles listed, the article will be loaded on webBrower.

The layout and controls are as follows

Loading the feed items

The silverlight application had put lot of restrictions in accessing the APIs and resources of other websites. Loading news feed (RSS/Atom) is not really painful using the C# code. Silverlight supports asynchronous read operations for web requests. SyndicationFeed class is not supported supported bu default. Basically it’s safe to add this assembly to the project (System.ServiceModel.Syndication,dll) You can browse to Windows SDK folder, locate and add the same assembly in the “Client” folder

private void buttonRefresh_Click(object sender, RoutedEventArgs e)
{
    // Load the feed items
    LoadFeedItems();
}

private void LoadFeedItems()
{
    // Asynchronously load the feed content.
    WebClient client = new WebClient();
    Uri address = new Uri("http://feeds.feedburner.com/sharingmythoughts");
    client.OpenReadCompleted += client_openReadComplete;
    // Add the callback on completion
    client.OpenReadAsync(address);
    webBrowser.Visibility = Visibility.Collapsed;
    buttonBack.Visibility = Visibility.Collapsed;

}
private void client_openReadComplete(object sender, OpenReadCompletedEventArgs args)
{
    try
    {
        listBoxPosts.Items.Clear();
        // try to load the result in the XML reader.
        // Exception may occur if the request is failed
        XmlReader reader = XmlReader.Create(args.Result);

        // Syndication Feed is not supported by default.
        // It's safe to add this assembly.
        SyndicationFeed feed = SyndicationFeed.Load(reader);
        Items = feed.Items.ToArray();
        foreach (SyndicationItem e in Items)
            listBoxPosts.Items.Add(e.Title.Text);
    }
    catch
    {
        MessageBox.Show("Error downloading feed");
    }

}

Navigate to the base URL on tapping

private void OnTapItem(object sender, MouseButtonEventArgs e)
{
    if (listBoxPosts.SelectedIndex >= 0)
    {
        buttonRefresh.Visibility = Visibility.Collapsed;
        buttonBack.Visibility = Visibility.Visible;
        webBrowser.Visibility = Visibility.Visible;
        Uri address = new Uri(Items[listBoxPosts.SelectedIndex].Id);
        webBrowser.Navigate(address);
    }
}

The mobile theme I’ve enabled for this blog is not really working well. The WPTouch theme I installed seems not really identifying Windows Phone 7 user agent string. (Amazingly it works well when I load using Intenet Explorer App in the Phone 7).

Adding support for Orientation

By default, the wizard creates application with Portrait Orientation. The page content will not be arranged according to the current orientation if we don’t add support for it. Change the orientation to Portrait/Landscape/PortraitOrLandscape in the XAML file

SupportedOrientations="PortraitOrLandscape" Orientation="Portrait"

Handling Orientation Events

It’s possible to override OnOrientationChanged function do if we need to manage something else other than the default orientation change support implemented in the base class. For the simple applications using controls, we can use the standard alignment surppot provided by the grids and panels. The controls will be perfectly aligned according the vertical and horizontal settings of the controls.

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
    <ListBox Margin="0" x:Name="listBoxPosts" MouseLeftButtonUp="OnTapItem" />
    <phone:WebBrowser Margin="0" x:Name="webBrowser" />
</Grid>
<Button Content="Refresh" Height="71" HorizontalAlignment="Right" Margin="320,145,0,0" x:Name="buttonRefresh" VerticalAlignment="Top" Width="160" Click="buttonRefresh_Click" />
<Button Content="Back" Height="71" HorizontalAlignment="Left" Margin="0,145,0,0" x:Name="buttonBack" VerticalAlignment="Top" Width="160" Click="buttonBack_Click" />

Override the OnOrientationChanged if more flexibility is necessary

protected override void OnOrientationChanged(OrientationChangedEventArgs args)
{
    // do your code. If base is not called, then the orientation will not be changed
    base.OnOrientationChanged(args);
}

Portrait Orientation

Landscape Orientation

Putting it all together

Download the source from GIT Hub

Closing note

I feel Windows Phone 7 is a solid platform. It uses the modern programming languages and technologies. C# is one of the most popular language and it’s expressive. The Apple’s iOS platform is truly a solid and great foundation but the object C has a slight learning curve. It’s obvious because it’s my father’s programming language, not mine. But Apple made the platform truly solid and cash cow for the developers. So nobody really care it’s his father’s or his.

Microsoft has chosen right technologies for Windows Phone 7 is proven and popular. XNA, Silverlight with C# will surely give edge for Microsoft to get a pace on their platform. Also the developer tools are easy to work and available for free.

Charles Petzold is working for a free version of book for Programming Windows Phone 7 which is expected to out soon. Apple has a definite documentation, video tutorials and lot more stuffs to help the developers. The MSDN documentation is slightly noisy with too many languages technologies. Even if we check the documentation for silverlight, some of the functionalities may not work under Windows Phone 7. Hopefully we can see lot of good stuffs in MSDN and Channel 9 for Windows Phone 7( Channel 9 offer Windows Phone 7 Training Kit now). Now I’m exploring more about deploying the phone applications. See you son.

If the WOW64 process want to know the original platform it’s running, it must call GetNativeSystemInfo. When we’ve to use this? I’ve a realworld example. When we spawn process explorer (procexp.exe, it realize the underlying platform and create another exe procexp64.exe (64bit version) to iterate all process information in the system. Note that the GetNativeSystemInfo need to be called only if you 32bit application wants to run under 64 bit platform and need to care about the true underlying platform. In all other cases, call GetSystemInfo, which works across platforms uniquely. See the snippet below

#include "stdafx.h"
#include 

void displayPrcessorInfo( SYSTEM_INFO &stInfo )
{
        switch( stInfo.wProcessorArchitecture )
        {
        case PROCESSOR_ARCHITECTURE_INTEL:
                printf( "Processor Architecture: Intel x86\n");
                break;
        case PROCESSOR_ARCHITECTURE_IA64:
                printf( "Processor Type: Intel x64\n");
                break;
        case PROCESSOR_ARCHITECTURE_AMD64:
                printf( "Processor Type: AMD 64\n");
                break;
        default:
                printf( "Unknown processor architecture\n");
        }
}

int _tmain(int argc, _TCHAR* argv[])
{
        SYSTEM_INFO stInfo;
        GetSystemInfo( &stInfo );
        displayPrcessorInfo(stInfo);

        GetNativeSystemInfo( &stInfo );
        displayPrcessorInfo(stInfo);
        return 0;
}

To know more about the different processor architecture in abstract level, please do check one of my previous posts.

But even if this parameter isn’t given the Windows under Windows 7 draws without much flickering. Why? (If you haven’t tried the WS_EX_COMPOSITED style, just create the Window using WS_EX_COMPOSITED style or call ModifyStyleEx( hWnd, 0, WS_EX_COMPOSITED, 0 ); in the Initialization routine).

In Windows 7, the Desktop Window Manager (DWM) manages all the Windows running in the system. DWM uses GPU available in the system. When Windows Aero is enabled, the entire desktop area is a Direct3D surface. All drawing operations made by Windows are sent directly to the offline buffer for rendering. DWM will swap this buffer to screen whenever required. Thus by default all Window operations are done through double buffering. This architecture is quite different in prior versions of Windows, where all the operations are redirected to the main screen(buffer).

To explain a bit more detailed, the Window itself being mapped as texture on the screen, the way this texture appeared is controlled through shader programs. Like Window transition effects are implemented through shaders. The shaders are small programs which can control the coordinates and pixels being displayed.

Since the desktop itself a 3D surface, DWM has access to all the Windows displayed on the screen. This it can effortlessly implement the new features like, aero peak, flip 3D etc. The double buffering is also provided by DWM during Window movement, repainting etc. for flicker free drawing.

The DWM double buffering methods are sometimes not compatible with real-time graphics applications and games. In this case, DWM will not do window compositing so the application can gain the desired performance and no overheads of DWM implemented double buffering.

DWM also employs efficient rendering techniques called culling to avoid displaying the WIndows which are not visible in the screen (minimized, small windows hidden behind other windows etc). But we can’t flickering will never happen under Windows 7. The high refreshing rate application may still cause flickering. These kind of applications must use Windows Native Double buffering support provided. I already have covered about double buffering and double buffering helpers introducing since Windows Vista in separate blog post.

Roughly we’ve two methods to do this.

Method #1. Handle the NCHITTEST message and ignore while user click on the caption area (Titlebar). This method doesn’t work well in Windows 7/Vista if Aero is enabled. This method works with any type of Window having titlebar. The disadvantage of this method is , the user will still able to move using keyboard, if system menu is available.

LRESULT CMoveWindowSampleDlg::OnNcHitTest(CPoint point)
{
    UINT nHitTest = CDialogEx::OnNcHitTest(point);

    if( HTCAPTION == nHitTest )
        nHitTest = HTNOWHERE;

    return nHitTest;
}

Method #2 – Remove the Move command from System Menu (Works with windows having system menu stle (WS_SYSMENU) ). The the Move command in the system menu will be removed in this case. Windows will internally disable the movement of this kind of Windows.

BOOL CMoveWindowSampleDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    CMenu* pSysMenu = GetSystemMenu(FALSE);

    if (pSysMenu != NULL)
    {
        pSysMenu->RemoveMenu( SC_MOVE, MF_BYCOMMAND );
       }
...

       return TRUE;
}

PS: Using method 2, this is the same method we use to disable the close button of a Window. For disabling a menu/titlebar button. Call EnableMenu function with relevant parameters.