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