using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;

using System.IO;
using System.ServiceModel.Syndication;
using System.Xml;
using Microsoft.Phone.Tasks;

namespace FeedReader4WIRED
{
    public partial class MainPage : PhoneApplicationPage
    {

        private int i = 0;
        

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            // Set the data context of the listbox control to the sample data
            DataContext = App.ViewModel;
            this.Loaded += new RoutedEventHandler(MainPage_Loaded);
        }

        // Load data for the ViewModel Items
        private void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            if (!App.ViewModel.IsDataLoaded)
            {
                App.ViewModel.LoadData();
            }
        }

        private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
        {
            ApplicationBar.IsVisible = false;
            

            // WebClient is used instead of HttpWebRequest in this code sample because 
            // the implementation is simpler and easier to use, and we do not need to use 
            // advanced functionality that HttpWebRequest provides, such as the ability to send headers.
            WebClient webClientNews = new WebClient();
            WebClient webClientMedia = new WebClient();
            WebClient webClientAutopia = new WebClient();
            WebClient webClientBusiness = new WebClient();
            WebClient webClientGadgetLab = new WebClient();
            WebClient webClientPlayBook = new WebClient();
            WebClient webClientRawFile = new WebClient();
            WebClient webClientTutorial = new WebClient();
            WebClient webClientDesign = new WebClient();
            WebClient webClientEnterprise = new WebClient();
            WebClient webClientScience = new WebClient();


            // Subscribe to the DownloadStringCompleted event prior to downloading the RSS feed.
            webClientNews.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientNews_DownloadStringCompleted);
            webClientMedia.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientMedia_DownloadStringCompleted);
            webClientAutopia.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientAutopia_DownloadStringCompleted);
            webClientBusiness.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientBusiness_DownloadStringCompleted);
            webClientGadgetLab.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientGadgetLab_DownloadStringCompleted);
            webClientPlayBook.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientPlayBook_DownloadStringCompleted);
            webClientRawFile.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientRawFile_DownloadStringCompleted);
            webClientTutorial.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientTutorial_DownloadStringCompleted);
            webClientDesign.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientDesign_DownloadStringCompleted);
            webClientEnterprise.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientEnterprise_DownloadStringCompleted);
            webClientScience.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClientScience_DownloadStringCompleted);


            // Download the RSS feed. DownloadStringAsync was used instead of OpenStreamAsync because we do not need 
            // to leave a stream open, and we will not need to worry about closing the channel. 
            webClientNews.DownloadStringAsync(new System.Uri("http://www.wired.com/gamelife/feed/"));
            webClientMedia.DownloadStringAsync(new System.Uri("http://www.wired.com/dangerroom/feed/"));
            webClientAutopia.DownloadStringAsync(new System.Uri("http://www.wired.com/autopia/feed/"));
            webClientBusiness.DownloadStringAsync(new System.Uri("http://www.wired.com/business/feed/"));
            webClientGadgetLab.DownloadStringAsync(new System.Uri("http://www.wired.com/gadgetlab/feed/"));
            webClientPlayBook.DownloadStringAsync(new System.Uri("http://www.wired.com/playbook/feed/"));
            webClientRawFile.DownloadStringAsync(new System.Uri("http://www.wired.com/rawfile/feed/"));
            webClientTutorial.DownloadStringAsync(new System.Uri("http://www.webmonkey.com/feed/"));
            webClientDesign.DownloadStringAsync(new System.Uri("http://www.wired.com/design/feed/"));
            webClientEnterprise.DownloadStringAsync(new System.Uri("http://www.wired.com/wiredenterprise/feed/"));
            webClientScience.DownloadStringAsync(new System.Uri("http://www.wired.com/wiredscience/feed/"));


        }

        // Event handler which runs after the feed is fully downloaded.
        private void webClientNews_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListNews(e.Result);
            }
        }

        private void webClientMedia_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListMedia(e.Result);
            }
        }

        private void webClientAutopia_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListAutopia(e.Result);
            }
        }

        private void webClientBusiness_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListBusiness(e.Result);
            }
        }

        private void webClientGadgetLab_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListGadgetLab(e.Result);
            }
        }

        private void webClientPlayBook_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListPlayBook(e.Result);
            }
        }

        private void webClientRawFile_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListRawFile(e.Result);
            }
        }

        private void webClientTutorial_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListTutorial(e.Result);
            }
        }

        private void webClientDesign_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListDesign(e.Result);
            }
        }

        private void webClientEnterprise_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListEnterprise(e.Result);
            }
        }

        private void webClientScience_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedListScience(e.Result);
            }
        }

        // This method determines whether the user has navigated to the application after the application was tombstoned.
        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            // First, check whether the feed is already saved in the page state.
            if (this.State.ContainsKey("feed"))
            {
                // Get the feed again only if the application was tombstoned, which means the ListBox will be empty.
                // This is because the OnNavigatedTo method is also called when navigating between pages in your application.
                // You would want to rebind only if your application was tombstoned and page state has been lost. 
                if (feedListBoxNews1.Items.Count == 0)
                {
                    UpdateFeedListNews(State["feed"] as string);
                }
                if (feedListBoxNews2.Items.Count == 0)
                {
                    UpdateFeedListMedia(State["feed"] as string);
                }
                if (feedListBoxNews3.Items.Count == 0)
                {
                    UpdateFeedListAutopia(State["feed"] as string);
                }
                if (feedListBoxNews4.Items.Count == 0)
                {
                    UpdateFeedListBusiness(State["feed"] as string);
                }
                if (feedListBoxNews5.Items.Count == 0)
                {
                    UpdateFeedListGadgetLab(State["feed"] as string);
                }
                if (feedListBoxNews6.Items.Count == 0)
                {
                    UpdateFeedListPlayBook(State["feed"] as string);
                }
                if (feedListBoxNews7.Items.Count == 0)
                {
                    UpdateFeedListRawFile(State["feed"] as string);
                }
                if (feedListBoxNews8.Items.Count == 0)
                {
                    UpdateFeedListTutorial(State["feed"] as string);
                }
                if (feedListBoxNews9.Items.Count == 0)
                {
                    UpdateFeedListDesign(State["feed"] as string);
                }
                if (feedListBoxNews10.Items.Count == 0)
                {
                    UpdateFeedListEnterprise(State["feed"] as string);
                }
                if (feedListBoxNews11.Items.Count == 0)
                {
                    UpdateFeedListScience(State["feed"] as string);
                }


            }
        }



        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListNews(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews1.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListMedia(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews2.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListAutopia(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews3.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListBusiness(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews4.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListGadgetLab(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews5.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListPlayBook(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews6.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListRawFile(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews7.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListTutorial(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews8.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListDesign(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews9.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListEnterprise(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews10.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedListScience(string feedXML)
        {
            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews11.ItemsSource = feed.Items;
                //feedListBoxMedia.ItemsSource = feed.Items;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // The SelectionChanged handler for the feed items 
        private void feedListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ListBox listBox = sender as ListBox;

            if (listBox != null && listBox.SelectedItem != null)
            {
                // Get the SyndicationItem that was tapped.
                SyndicationItem sItem = (SyndicationItem)listBox.SelectedItem;

                // Set up the page navigation only if a link actually exists in the feed item.
                if (sItem.Links.Count > 0)
                {
                    // Get the associated URI of the feed item.
                    Uri uri = sItem.Links.FirstOrDefault().Uri;
                    String struri = uri.ToString();

                    // Create a new WebBrowserTask Launcher to navigate to the feed item. 
                    // An alternative solution would be to use a WebBrowser control, but WebBrowserTask is simpler to use. 
                    //WebBrowserTask webBrowserTask = new WebBrowserTask();
                    //webBrowserTask.Uri = uri;
                    //webBrowserTask.Show();
                    webBrowser1.Visibility = System.Windows.Visibility.Visible;
                    ApplicationBar.IsVisible = true;
                    webBrowser1.Navigate(new Uri(struri, UriKind.Absolute));
                   // NavigationService.Navigate(new Uri("/XapNote;component/webBrowser.xaml", UriKind.Relative));

                    
                    
                }
            }
        }

        private void AppBar_Back_Click(object sender, EventArgs e)
        {
            webBrowser1.Visibility = System.Windows.Visibility.Collapsed;
            ApplicationBar.IsVisible = false;
        }

        private void Panorama_LayoutUpdated(object sender, EventArgs e)
        {       
            
        }

        private void Panorama_Loaded(object sender, RoutedEventArgs e)
        {
            //loading.Visibility = System.Windows.Visibility.Visible;
            //i++;

            //if (i >= 5)
            //{
            //    loading.Visibility = System.Windows.Visibility.Visible;
            //}   
        }

        private void LayoutRoot_LayoutUpdated(object sender, EventArgs e)
        {
               
        }

        private void PhoneApplicationPage_LayoutUpdated(object sender, EventArgs e)
        {
            i++;
            if (i >= 5)
            {
                loading.Visibility = System.Windows.Visibility.Collapsed;
            }
        }
    }
}