// This is my own flag to determine app & NESL installation status
      if (this._appState == AppState.OutOfBrowserNeslInstalled)
      {
        this._manipProcessor = new ManipulationProcessor();

        this._manipProcessor.RaiseGestures =
          Gesture.Flick | Gesture.TwoFingerTap;

        Touch.FrameReported += (s, e) =>
          {
            this._manipProcessor.ProcessTouchPoints(
              e.GetTouchPoints(Application.Current.RootVisual),
              e.Timestamp);
          };

        this._manipProcessor.Flick += OnFlick;
        this._manipProcessor.TwoFingerTap += OnTap;
      }

  class FlickrSearch
  {
    public FlickrSearch(string searchText,
      TimeSpan interval)
    {
      this.state = new FlickSearchState(searchText);
      this.interval = interval;

      this.photoResults = new Lazy<IObservable<Stream>>(
        MakePhotoResults);
    }
    public IObservable<Stream> PhotoResults
    {
      get
      {
        return (this.photoResults.Value);
      }
    }
    IObservable<Stream> MakePhotoResults()
    {
      var webRequests =
        this.state.GetObservableSearchUris().SelectMany(
          uri =>
          {
            HttpWebRequest wr = WebRequest.Create(uri) as HttpWebRequest;

            return (Observable.Defer(Observable.FromAsyncPattern<WebResponse>(
              wr.BeginGetResponse, wr.EndGetResponse)));
          });

      var xmlResponses =
        webRequests.Select(
          wr =>
          {
            XElement xml = null;
            FlickrPhotoPageResult result = null;

            using (Stream stream = wr.GetResponseStream())
            {
              xml = XElement.Load(stream);
              result = new FlickrPhotoPageResult(xml);
            };
            return (result);
          });

      var photoResponses =
        xmlResponses.SelectMany(
          pageResponse =>
          {
            return (pageResponse.GetPhotos());
          });

      var slowedDownResponses =
        photoResponses.Zip(
          Observable.Interval(this.interval),
          (photo, count) =>
          {
            return (photo);
          });

      var slowedDownLoadsNextPage =
        slowedDownResponses.Do(p =>
        {
          // TODO: not sure about this having a side-effect which
          // can advance/end the observable at the "tail of the
          // chain" here.
          if (p.IsLastImage)
          {
            this.state.Advance(end: true);
          }
          else if (p.IsLastImageOnCurrentPage)
          {
            this.state.Advance(end: false);
          }
        });

      var streams =
        slowedDownLoadsNextPage.SelectMany(
          photo =>
          {
            HttpWebRequest request = WebRequest.Create(photo.ImageUri) as HttpWebRequest;

            return(Observable.Defer(
              Observable.FromAsyncPattern<WebResponse>(request.BeginGetResponse,
                request.EndGetResponse)));
          });

      var byteArrays =
        streams.Select(
          resp =>
          {
            HttpWebResponse webResponse = (HttpWebResponse)resp;

            MemoryStream ms = new MemoryStream();

            using (Stream s = resp.GetResponseStream())
            {
              s.CopyTo(ms);
            }
            ms.Seek(0, SeekOrigin.Begin);
            return (ms);
          });

      return (byteArrays);
    }
    Lazy<IObservable<Stream>> photoResults;
    FlickSearchState state;
    TimeSpan interval;
  }

  class FlickrSearch<T>
  {
    public FlickrSearch(string searchText,
      IObservable<T> throttlingObservable)
    {
      this.state = new FlickSearchState(searchText);
      this.throttlingObservable = throttlingObservable;

      this.photoResults = new Lazy<IObservable<MemoryStream>>(
        MakePhotoResults);
    }
    public IObservable<MemoryStream> PhotoResults
    {
      get
      {
        return (this.photoResults.Value);
      }
    }
    IObservable<MemoryStream> MakePhotoResults()
    {
      // As new URIs are produced, we turn them into HttpWebResponses
      var webRequests =
        this.state.GetObservableSearchUris().SelectMany(
          uri =>
          {
            HttpWebRequest wr = WebRequest.Create(uri) as HttpWebRequest;

            return (Observable.Defer(Observable.FromAsyncPattern<WebResponse>(
              wr.BeginGetResponse, wr.EndGetResponse)));
          });

      // We take each of those responses and we load the XML back from it
      // as a page of data.
      var xmlResponses =
        webRequests.Select(
          wr =>
          {
            XElement xml = null;
            FlickrPhotoPageResult result = null;

            using (Stream stream = wr.GetResponseStream())
            {
              xml = XElement.Load(stream);
              result = new FlickrPhotoPageResult(xml);
            };
            return (result);
          });

      // We take that page of data and turn it into photograph instances.
      var photoResponses =
        xmlResponses.SelectMany(
          pageResponse =>
          {
            return (pageResponse.GetPhotos());
          });

      // We're happy to make the web requests in order to get the streams
      // containing the photo bits.
      var photoResponseStreams =
        photoResponses.SelectMany(
          photo =>
          {
            HttpWebRequest request = WebRequest.Create(photo.ImageUri) as HttpWebRequest;

            var response = Observable.FromAsyncPattern<WebResponse>(
              request.BeginGetResponse, request.EndGetResponse);

            return (Observable.Defer(response).Select(
              resp => Tuple.Create(photo, resp)));
          });

      // And produce a stream from it.
      var photoAndStreams =
        photoResponseStreams.Select(
          photoResp =>
          {
            HttpWebResponse webResponse = (HttpWebResponse)photoResp.Item2;

            MemoryStream ms = new MemoryStream();

            using (Stream s = webResponse.GetResponseStream())
            {
              s.CopyTo(ms);
            }
            ms.Seek(0, SeekOrigin.Begin);

            return (Tuple.Create(photoResp.Item1, ms));
          });

      // We always want the first one because the user has searched and
      // expects a result.
      var first =
        photoAndStreams.Take(1);

      // We also want the rest but we want to defer them until a later 
      // time.
      var rest =
        photoAndStreams.Skip(1);

      // We produce the first result followed by the remaining results
      // only when the "throttlingObservable" produces a value so the
      // remaining results won't come through until some timer tick
      // or event fires or whatever.
      var slowedDownResponses =
        first.Concat(
          rest.Zip(
            this.throttlingObservable,
            (photoResp, throttle) =>
            {
              return (photoResp);
            }));

      // We need to make sure that we request the next page if necessary
      // by updating the URI or that we signal the result-set is complete.
      var slowedDownLoadsNextPage =
        slowedDownResponses.Do(photoAndStream =>
        {
          // TODO: not sure about this having a side-effect which
          // can advance/end the observable at the "tail of the
          // chain" here.
          if (photoAndStream.Item1.IsLastImage)
          {
            this.state.Advance(end: true);
          }
          else if (photoAndStream.Item1.IsLastImageOnCurrentPage)
          {
            this.state.Advance(end: false);
          }
        });

      return (slowedDownLoadsNextPage.Select(
        photoAndStream => photoAndStream.Item2));
    }
    Lazy<IObservable<MemoryStream>> photoResults;
    FlickSearchState state;
    IObservable<T> throttlingObservable;
  }

      this._flickEvents =
        Observable
          .FromEvent<FlickEventArgs>(this._manipProcessor, "Flick");

FlickrSearch<IEvent<FlickEventArgs>> search =
          new FlickrSearch<IEvent<FlickEventArgs>>(
            this.SearchText, this._flickEvents);

        this._searchSubscription =
          search
            .PhotoResults
            .ObserveOnDispatcher()
            .Subscribe(
            ms =>
            {
              BitmapImage image = new BitmapImage();
              image.SetSource(ms);
              this.CurrentImage = image;
            });

      this._manipProcessor.TwoFingerTap += OnTap;
    }
    void OnTap(object sender, TapEventArgs e)
    {
      this.ShowSearch = Visibility.Visible;
    }