← Back to branch summary

~ubuntu-branches/ubuntu/precise/unity-lens-music/precise

« back to all changes in this revision

Viewing changes to src/simple-scope.vala

  • Committer: Package Import Robot
  • Author(s): Didier Roche
  • Date: 2012-02-03 11:33:57 UTC
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: package-import@ubuntu.com-20120203113357-yop2ipbkuwiizbih
Tags: upstream-5.2.0
Import upstream version 5.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/simple-scope.vala
29
29
    protected abstract int num_results_global_search { get; }
30
30
    protected abstract int num_results_lens_search { get; }
31
31
 
32
 
    protected abstract void perform_search (LensSearch? search, Dee.Model results_model, List<FilterParser> filters, int max_results = -1);
33
 
    
 
32
    protected abstract async void perform_search (LensSearch search,
 
33
                                                  SearchType search_type,
 
34
                                                  owned List<FilterParser> filters,
 
35
                                                  int max_results = -1);
 
36
 
34
37
    public SimpleScope ()
35
38
    {
36
39
    }
49
52
 
50
53
      /* Listen for changes to the lens search entry */
51
54
      scope.search_changed.connect ((search, search_type, cancellable) => {
52
 
        if (search_type == SearchType.DEFAULT)
53
 
          update_search_async.begin (search);
54
 
        else
55
 
          update_global_search_async.begin (search);
 
55
        update_search_async.begin (search, search_type);
56
56
      });
57
57
    }
58
 
 
59
 
    /* based on the filters(?) get the default results to show when the music lens is
60
 
     * just opened without filters, like when someone hits Super+M
61
 
     */
62
 
    private async void update_without_search_async (LensSearch search)
63
 
    {
64
 
      yield perform_search_async (search, num_results_without_search);
65
 
    }
66
 
    
67
 
    /**
68
 
     * results for a global search from just hitting Super. here we want to return
69
 
     * a smaller number of results with 0 filters.
70
 
     */
71
 
    private async void update_global_search_async (LensSearch search)
72
 
    {
73
 
      if (search_is_invalid (search))
74
 
      {
75
 
        search.results_model.clear ();
76
 
        search.finished ();
77
 
        return;
78
 
      }
79
 
 
80
 
      yield perform_search_async (search, num_results_global_search);
81
 
    }
82
 
    
83
 
    private async void update_search_async (LensSearch search)
84
 
    {
85
 
      // just pretend like there's no search
86
 
      if (search_is_invalid (search))
87
 
        {
88
 
          yield update_without_search_async (search);
89
 
          return;
90
 
        }
91
 
      
92
 
      yield perform_search_async (search, num_results_lens_search);
93
 
    }
94
 
 
95
 
    private async void perform_search_async (LensSearch search, int max_results)
 
58
    
 
59
    private async void update_search_async (LensSearch search,
 
60
                                            SearchType search_type)
 
61
    {
 
62
      int max_results;
 
63
      /*
 
64
       * results for a global search from just hitting Super.
 
65
       * Here we want to return a smaller number of results with 0 filters.
 
66
       */
 
67
      if (search_type == SearchType.GLOBAL)
 
68
        max_results = num_results_global_search;
 
69
      else if (is_search_empty (search))
 
70
        max_results = num_results_without_search;
 
71
      else
 
72
        max_results = num_results_lens_search;
 
73
 
 
74
      yield prepare_search (search, search_type, max_results);
 
75
    }
 
76
 
 
77
    private async void prepare_search (LensSearch search,
 
78
                                       SearchType search_type,
 
79
                                       int max_results)
96
80
    {
97
81
      var results_model = search.results_model;
98
82
 
99
83
      List<FilterParser> filters = new List<FilterParser> ();
100
 
      Filter filter = scope.get_filter ("genre");
101
 
      if (filter.filtering)
102
 
        filters.append (new GenreFilterParser (filter as CheckOptionFilter));
103
 
 
104
 
      filter = scope.get_filter ("decade");
105
 
      if (filter.filtering)
106
 
        filters.append (new DecadeFilterParser (filter as MultiRangeFilter));
107
 
      
 
84
      // don't apply filters to global searches
 
85
      if (search_type != SearchType.GLOBAL)
 
86
      {
 
87
        Filter filter = scope.get_filter ("genre");
 
88
        if (filter.filtering)
 
89
          filters.append (new GenreFilterParser (filter as CheckOptionFilterCompact));
 
90
 
 
91
        filter = scope.get_filter ("decade");
 
92
        if (filter.filtering)
 
93
          filters.append (new DecadeFilterParser (filter as MultiRangeFilter));
 
94
      }
 
95
 
108
96
      results_model.clear ();
109
 
      perform_search (search, results_model, filters, max_results);
110
 
      
 
97
 
 
98
      yield perform_search (search, search_type, (owned) filters, max_results);
 
99
 
 
100
      if (results_model.get_n_rows () == 0)
 
101
      {
 
102
        search.set_reply_hint ("no-results-hint",
 
103
          _("Sorry, there is no music that matches your search."));
 
104
      }
 
105
 
111
106
      search.finished ();
112
107
    }
113
108
 
114
 
    protected bool search_is_invalid (LensSearch? search)
 
109
    protected bool is_search_empty (LensSearch search)
 
110
      requires (search.search_string != null)
115
111
    {
116
 
      /* This boolean expression is unfolded as we seem to get
117
 
       * some null dereference if we join them in a big || expression */
118
 
      if (search == null)
119
 
        return true;
120
 
      else if (search.search_string == null)
121
 
        return true;
122
 
      
123
 
      return search.search_string.strip() == "";
 
112
      return search.search_string.strip () == "";
124
113
    }
125
114
  }
126
115
}