ash/shell/app_list.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "ash/session_state_delegate.h"
   8 #include "ash/shell.h"
   9 #include "ash/shell/example_factory.h"
  10 #include "ash/shell/toplevel_window.h"
  11 #include "ash/shell_delegate.h"
  12 #include "base/basictypes.h"
  13 #include "base/callback.h"
  14 #include "base/files/file_path.h"
  15 #include "base/i18n/case_conversion.h"
  16 #include "base/i18n/string_search.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "ui/app_list/app_list_item.h"
  21 #include "ui/app_list/app_list_item_list.h"
  22 #include "ui/app_list/app_list_model.h"
  23 #include "ui/app_list/app_list_view_delegate.h"
  24 #include "ui/app_list/search_box_model.h"
  25 #include "ui/app_list/search_result.h"
  26 #include "ui/app_list/speech_ui_model.h"
  27 #include "ui/gfx/canvas.h"
  28 #include "ui/gfx/font.h"
  29 #include "ui/gfx/image/image_skia.h"
  30 #include "ui/gfx/rect.h"
  31 #include "ui/views/examples/examples_window_with_content.h"
  32
  33 namespace ash {
  34 namespace shell {
  35
  36 namespace {
  37
  38 // WindowTypeLauncherItem is an app item of app list. It carries a window
  39 // launch type and launches corresponding example window when activated.
  40 class WindowTypeLauncherItem : public app_list::AppListItem {
  41  public:
  42   enum Type {
  43     TOPLEVEL_WINDOW = 0,
  44     NON_RESIZABLE_WINDOW,
  45     LOCK_SCREEN,
  46     WIDGETS_WINDOW,
  47     EXAMPLES_WINDOW,
  48     LAST_TYPE,
  49   };
  50
  51   explicit WindowTypeLauncherItem(const std::string& id, Type type)
  52       : app_list::AppListItem(id),
  53         type_(type) {
  54     std::string title(GetTitle(type));
  55     SetIcon(GetIcon(type), false);
  56     SetTitleAndFullName(title, title);
  57   }
  58
  59   static gfx::ImageSkia GetIcon(Type type) {
  60     static const SkColor kColors[] = {
  61         SK_ColorRED,
  62         SK_ColorGREEN,
  63         SK_ColorBLUE,
  64         SK_ColorYELLOW,
  65         SK_ColorCYAN,
  66     };
  67
  68     const int kIconSize = 128;
  69     SkBitmap icon;
  70     icon.setConfig(SkBitmap::kARGB_8888_Config, kIconSize, kIconSize);
  71     icon.allocPixels();
  72     icon.eraseColor(kColors[static_cast<int>(type) % arraysize(kColors)]);
  73     return gfx::ImageSkia::CreateFrom1xBitmap(icon);
  74   }
  75
  76   // The text below is not localized as this is an example code.
  77   static std::string GetTitle(Type type) {
  78     switch (type) {
  79       case TOPLEVEL_WINDOW:
  80         return "Create Window";
  81       case NON_RESIZABLE_WINDOW:
  82         return "Create Non-Resizable Window";
  83       case LOCK_SCREEN:
  84         return "Lock Screen";
  85       case WIDGETS_WINDOW:
  86         return "Show Example Widgets";
  87       case EXAMPLES_WINDOW:
  88         return "Open Views Examples Window";
  89       default:
  90         return "Unknown window type.";
  91     }
  92   }
  93
  94   // The text below is not localized as this is an example code.
  95   static std::string GetDetails(Type type) {
  96     // Assigns details only to some types so that we see both one-line
  97     // and two-line results.
  98     switch (type) {
  99       case WIDGETS_WINDOW:
 100         return "Creates a window to show example widgets";
 101       case EXAMPLES_WINDOW:
 102         return "Creates a window to show views example.";
 103       default:
 104         return std::string();
 105     }
 106   }
 107
 108   static void ActivateItem(Type type, int event_flags) {
 109      switch (type) {
 110       case TOPLEVEL_WINDOW: {
 111         ToplevelWindow::CreateParams params;
 112         params.can_resize = true;
 113         ToplevelWindow::CreateToplevelWindow(params);
 114         break;
 115       }
 116       case NON_RESIZABLE_WINDOW: {
 117         ToplevelWindow::CreateToplevelWindow(ToplevelWindow::CreateParams());
 118         break;
 119       }
 120       case LOCK_SCREEN: {
 121         Shell::GetInstance()->session_state_delegate()->LockScreen();
 122         break;
 123       }
 124       case WIDGETS_WINDOW: {
 125         CreateWidgetsWindow();
 126         break;
 127       }
 128       case EXAMPLES_WINDOW: {
 129         views::examples::ShowExamplesWindowWithContent(
 130             views::examples::DO_NOTHING_ON_CLOSE,
 131             Shell::GetInstance()->delegate()->GetActiveBrowserContext(),
 132             NULL);
 133         break;
 134       }
 135       default:
 136         break;
 137     }
 138   }
 139
 140   // AppListItem
 141   virtual void Activate(int event_flags) OVERRIDE {
 142     ActivateItem(type_, event_flags);
 143   }
 144
 145  private:
 146   Type type_;
 147
 148   DISALLOW_COPY_AND_ASSIGN(WindowTypeLauncherItem);
 149 };
 150
 151 // ExampleSearchResult is an app list search result. It provides what icon to
 152 // show, what should title and details text look like. It also carries the
 153 // matching window launch type so that AppListViewDelegate knows how to open
 154 // it.
 155 class ExampleSearchResult : public app_list::SearchResult {
 156  public:
 157   ExampleSearchResult(WindowTypeLauncherItem::Type type,
 158                       const base::string16& query)
 159       : type_(type) {
 160     SetIcon(WindowTypeLauncherItem::GetIcon(type_));
 161
 162     base::string16 title =
 163         base::UTF8ToUTF16(WindowTypeLauncherItem::GetTitle(type_));
 164     set_title(title);
 165
 166     Tags title_tags;
 167     const size_t match_len = query.length();
 168
 169     // Highlight matching parts in title with bold.
 170     // Note the following is not a proper way to handle i18n string.
 171     title = base::i18n::ToLower(title);
 172     size_t match_start = title.find(query);
 173     while (match_start != base::string16::npos) {
 174       title_tags.push_back(Tag(Tag::MATCH,
 175                                match_start,
 176                                match_start + match_len));
 177       match_start = title.find(query, match_start + match_len);
 178     }
 179     set_title_tags(title_tags);
 180
 181     base::string16 details =
 182         base::UTF8ToUTF16(WindowTypeLauncherItem::GetDetails(type_));
 183     set_details(details);
 184     Tags details_tags;
 185     details_tags.push_back(Tag(Tag::DIM, 0, details.length()));
 186     set_details_tags(details_tags);
 187   }
 188
 189   WindowTypeLauncherItem::Type type() const { return type_; }
 190
 191  private:
 192   WindowTypeLauncherItem::Type type_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(ExampleSearchResult);
 195 };
 196
 197 class ExampleAppListViewDelegate : public app_list::AppListViewDelegate {
 198  public:
 199   ExampleAppListViewDelegate()
 200       : model_(new app_list::AppListModel) {
 201     PopulateApps(model_->item_list());
 202     DecorateSearchBox(model_->search_box());
 203   }
 204
 205  private:
 206   void PopulateApps(app_list::AppListItemList* item_list) {
 207     for (int i = 0;
 208          i < static_cast<int>(WindowTypeLauncherItem::LAST_TYPE);
 209          ++i) {
 210       WindowTypeLauncherItem::Type type =
 211           static_cast<WindowTypeLauncherItem::Type>(i);
 212       std::string id = base::StringPrintf("%d", i);
 213       item_list->AddItem(new WindowTypeLauncherItem(id, type));
 214     }
 215   }
 216
 217   gfx::ImageSkia CreateSearchBoxIcon() {
 218     const base::string16 icon_text = base::ASCIIToUTF16("ash");
 219     const gfx::Size icon_size(32, 32);
 220
 221     gfx::Canvas canvas(icon_size, 1.0f, false /* is_opaque */);
 222     canvas.DrawStringInt(icon_text,
 223                          gfx::Font(),
 224                          SK_ColorBLACK,
 225                          0, 0, icon_size.width(), icon_size.height(),
 226                          gfx::Canvas::TEXT_ALIGN_CENTER |
 227                              gfx::Canvas::NO_SUBPIXEL_RENDERING);
 228
 229     return gfx::ImageSkia(canvas.ExtractImageRep());
 230   }
 231
 232   void DecorateSearchBox(app_list::SearchBoxModel* search_box_model) {
 233     search_box_model->SetIcon(CreateSearchBoxIcon());
 234     search_box_model->SetHintText(base::ASCIIToUTF16("Type to search..."));
 235   }
 236
 237   // Overridden from app_list::AppListViewDelegate:
 238   virtual bool ForceNativeDesktop() const OVERRIDE {
 239     return false;
 240   }
 241
 242   virtual void SetProfileByPath(const base::FilePath& profile_path) OVERRIDE {
 243     // Nothing needs to be done.
 244   }
 245
 246   virtual const Users& GetUsers() const OVERRIDE {
 247     return users_;
 248   }
 249
 250   virtual app_list::AppListModel* GetModel() OVERRIDE { return model_.get(); }
 251
 252   virtual app_list::SigninDelegate* GetSigninDelegate() OVERRIDE {
 253     return NULL;
 254   }
 255
 256   virtual app_list::SpeechUIModel* GetSpeechUI() OVERRIDE {
 257     return &speech_ui_;
 258   }
 259
 260   virtual void GetShortcutPathForApp(
 261       const std::string& app_id,
 262       const base::Callback<void(const base::FilePath&)>& callback) OVERRIDE {
 263     callback.Run(base::FilePath());
 264   }
 265
 266   virtual void OpenSearchResult(app_list::SearchResult* result,
 267                                 int event_flags) OVERRIDE {
 268     const ExampleSearchResult* example_result =
 269         static_cast<const ExampleSearchResult*>(result);
 270     WindowTypeLauncherItem::ActivateItem(example_result->type(), event_flags);
 271   }
 272
 273   virtual void InvokeSearchResultAction(app_list::SearchResult* result,
 274                                         int action_index,
 275                                         int event_flags) OVERRIDE {
 276     NOTIMPLEMENTED();
 277   }
 278
 279   virtual base::TimeDelta GetAutoLaunchTimeout() OVERRIDE {
 280     return base::TimeDelta();
 281   }
 282
 283   virtual void AutoLaunchCanceled() OVERRIDE {
 284   }
 285
 286   virtual void StartSearch() OVERRIDE {
 287     base::string16 query;
 288     TrimWhitespace(model_->search_box()->text(), TRIM_ALL, &query);
 289     query = base::i18n::ToLower(query);
 290
 291     model_->results()->DeleteAll();
 292     if (query.empty())
 293       return;
 294
 295     for (int i = 0;
 296          i < static_cast<int>(WindowTypeLauncherItem::LAST_TYPE);
 297          ++i) {
 298       WindowTypeLauncherItem::Type type =
 299           static_cast<WindowTypeLauncherItem::Type>(i);
 300
 301       base::string16 title =
 302           base::UTF8ToUTF16(WindowTypeLauncherItem::GetTitle(type));
 303       if (base::i18n::StringSearchIgnoringCaseAndAccents(
 304               query, title, NULL, NULL)) {
 305         model_->results()->Add(new ExampleSearchResult(type, query));
 306       }
 307     }
 308   }
 309
 310   virtual void StopSearch() OVERRIDE {
 311     // Nothing needs to be done.
 312   }
 313
 314   virtual void ViewInitialized() OVERRIDE {
 315     // Nothing needs to be done.
 316   }
 317
 318   virtual void Dismiss() OVERRIDE {
 319     DCHECK(ash::Shell::HasInstance());
 320     if (Shell::GetInstance()->GetAppListTargetVisibility())
 321       Shell::GetInstance()->ToggleAppList(NULL);
 322   }
 323
 324   virtual void ViewClosing() OVERRIDE {
 325     // Nothing needs to be done.
 326   }
 327
 328   virtual gfx::ImageSkia GetWindowIcon() OVERRIDE {
 329     return gfx::ImageSkia();
 330   }
 331
 332   virtual void OpenSettings() OVERRIDE {
 333     // Nothing needs to be done.
 334   }
 335
 336   virtual void OpenHelp() OVERRIDE {
 337     // Nothing needs to be done.
 338   }
 339
 340   virtual void OpenFeedback() OVERRIDE {
 341     // Nothing needs to be done.
 342   }
 343
 344   virtual void ToggleSpeechRecognition() OVERRIDE {
 345     NOTIMPLEMENTED();
 346   }
 347
 348   virtual void ShowForProfileByPath(
 349       const base::FilePath& profile_path) OVERRIDE {
 350     // Nothing needs to be done.
 351   }
 352
 353   virtual content::WebContents* GetStartPageContents() OVERRIDE {
 354     return NULL;
 355   }
 356
 357   virtual content::WebContents* GetSpeechRecognitionContents() OVERRIDE {
 358     return NULL;
 359   }
 360
 361   scoped_ptr<app_list::AppListModel> model_;
 362   app_list::SpeechUIModel speech_ui_;
 363   Users users_;
 364
 365   DISALLOW_COPY_AND_ASSIGN(ExampleAppListViewDelegate);
 366 };
 367
 368 }  // namespace
 369
 370 app_list::AppListViewDelegate* CreateAppListViewDelegate() {
 371   return new ExampleAppListViewDelegate;
 372 }
 373
 374 }  // namespace shell
 375 }  // namespace ash