app_list_model.cc revision c5cede9ae108bb15f6b7a8aea21c7e1fefa2834c 
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 "ui/app_list/app_list_model.h"
6
7#include <string>
8
9#include "ui/app_list/app_list_folder_item.h"
10#include "ui/app_list/app_list_item.h"
11#include "ui/app_list/app_list_model_observer.h"
12#include "ui/app_list/search_box_model.h"
13#include "ui/app_list/search_result.h"
14
15namespace app_list {
16
17AppListModel::AppListModel()
18    : top_level_item_list_(new AppListItemList),
19      search_box_(new SearchBoxModel),
20      results_(new SearchResults),
21      status_(STATUS_NORMAL) {
22  top_level_item_list_->AddObserver(this);
23}
24
25AppListModel::~AppListModel() { top_level_item_list_->RemoveObserver(this); }
26
27void AppListModel::AddObserver(AppListModelObserver* observer) {
28  observers_.AddObserver(observer);
29}
30
31void AppListModel::RemoveObserver(AppListModelObserver* observer) {
32  observers_.RemoveObserver(observer);
33}
34
35void AppListModel::SetStatus(Status status) {
36  if (status_ == status)
37    return;
38
39  status_ = status;
40  FOR_EACH_OBSERVER(AppListModelObserver,
41                    observers_,
42                    OnAppListModelStatusChanged());
43}
44
45AppListItem* AppListModel::FindItem(const std::string& id) {
46  AppListItem* item = top_level_item_list_->FindItem(id);
47  if (item)
48    return item;
49  for (size_t i = 0; i < top_level_item_list_->item_count(); ++i) {
50    AppListItem* child_item =
51        top_level_item_list_->item_at(i)->FindChildItem(id);
52    if (child_item)
53      return child_item;
54  }
55  return NULL;
56}
57
58AppListFolderItem* AppListModel::FindFolderItem(const std::string& id) {
59  AppListItem* item = top_level_item_list_->FindItem(id);
60  if (item && item->GetItemType() == AppListFolderItem::kItemType)
61    return static_cast<AppListFolderItem*>(item);
62  DCHECK(!item);
63  return NULL;
64}
65
66AppListItem* AppListModel::AddItem(scoped_ptr<AppListItem> item) {
67  DCHECK(!item->IsInFolder());
68  DCHECK(!top_level_item_list()->FindItem(item->id()));
69  return AddItemToItemListAndNotify(item.Pass());
70}
71
72AppListItem* AppListModel::AddItemToFolder(scoped_ptr<AppListItem> item,
73                                           const std::string& folder_id) {
74  if (folder_id.empty())
75    return AddItem(item.Pass());
76  DVLOG(2) << "AddItemToFolder: " << item->id() << ": " << folder_id;
77  DCHECK(!item->IsInFolder() || item->folder_id() == folder_id);
78  DCHECK(item->GetItemType() != AppListFolderItem::kItemType);
79  AppListFolderItem* dest_folder = FindOrCreateFolderItem(folder_id);
80  DCHECK(!dest_folder->item_list()->FindItem(item->id()))
81      << "Already in folder: " << dest_folder->id();
82  return AddItemToFolderItemAndNotify(dest_folder, item.Pass());
83}
84
85const std::string AppListModel::MergeItems(const std::string& target_item_id,
86                                           const std::string& source_item_id) {
87  DVLOG(2) << "MergeItems: " << source_item_id << " -> " << target_item_id;
88  // Find the target item.
89  AppListItem* target_item = FindItem(target_item_id);
90  if (!target_item) {
91    LOG(ERROR) << "MergeItems: Target no longer exists.";
92    return "";
93  }
94  CHECK(target_item->folder_id().empty());
95
96  AppListItem* source_item = FindItem(source_item_id);
97  if (!source_item) {
98    LOG(ERROR) << "MergeItems: Source no longer exists.";
99    return "";
100  }
101
102  // If the target item is a folder, just add the source item to it.
103  if (target_item->GetItemType() == AppListFolderItem::kItemType) {
104    AppListFolderItem* target_folder =
105        static_cast<AppListFolderItem*>(target_item);
106    if (target_folder->folder_type() == AppListFolderItem::FOLDER_TYPE_OEM) {
107      LOG(WARNING) << "MergeItems called with OEM folder as target";
108      return "";
109    }
110    scoped_ptr<AppListItem> source_item_ptr = RemoveItem(source_item);
111    source_item_ptr->set_position(
112        target_folder->item_list()->CreatePositionBefore(
113            syncer::StringOrdinal()));
114    AddItemToFolderItemAndNotify(target_folder, source_item_ptr.Pass());
115    return target_folder->id();
116  }
117
118  // Otherwise remove the source item and target item from their current
119  // location, they will become owned by the new folder.
120  scoped_ptr<AppListItem> source_item_ptr = RemoveItem(source_item);
121  CHECK(source_item_ptr);
122  scoped_ptr<AppListItem> target_item_ptr =
123      top_level_item_list_->RemoveItem(target_item_id);
124  CHECK(target_item_ptr);
125
126  // Create a new folder in the same location as the target item.
127  std::string new_folder_id = AppListFolderItem::GenerateId();
128  DVLOG(2) << "Creating folder for merge: " << new_folder_id;
129  scoped_ptr<AppListItem> new_folder_ptr(new AppListFolderItem(
130      new_folder_id, AppListFolderItem::FOLDER_TYPE_NORMAL));
131  new_folder_ptr->set_position(target_item_ptr->position());
132  AppListFolderItem* new_folder = static_cast<AppListFolderItem*>(
133      AddItemToItemListAndNotify(new_folder_ptr.Pass()));
134
135  // Add the items to the new folder.
136  target_item_ptr->set_position(
137      new_folder->item_list()->CreatePositionBefore(
138          syncer::StringOrdinal()));
139  AddItemToFolderItemAndNotify(new_folder, target_item_ptr.Pass());
140  source_item_ptr->set_position(
141      new_folder->item_list()->CreatePositionBefore(
142          syncer::StringOrdinal()));
143  AddItemToFolderItemAndNotify(new_folder, source_item_ptr.Pass());
144
145  return new_folder->id();
146}
147
148void AppListModel::MoveItemToFolder(AppListItem* item,
149                                    const std::string& folder_id) {
150  DVLOG(2) << "MoveItemToFolder: " << folder_id
151           << " <- " << item->ToDebugString();
152  if (item->folder_id() == folder_id)
153    return;
154  AppListFolderItem* dest_folder = FindOrCreateFolderItem(folder_id);
155  scoped_ptr<AppListItem> item_ptr = RemoveItem(item);
156  if (dest_folder)
157    AddItemToFolderItemAndNotify(dest_folder, item_ptr.Pass());
158  else
159    AddItemToItemListAndNotifyUpdate(item_ptr.Pass());
160}
161
162bool AppListModel::MoveItemToFolderAt(AppListItem* item,
163                                      const std::string& folder_id,
164                                      syncer::StringOrdinal position) {
165  DVLOG(2) << "MoveItemToFolderAt: " << folder_id
166           << "[" << position.ToDebugString() << "]"
167           << " <- " << item->ToDebugString();
168  if (item->folder_id() == folder_id)
169    return false;
170  AppListFolderItem* src_folder = FindOrCreateFolderItem(item->folder_id());
171  if (src_folder &&
172      src_folder->folder_type() == AppListFolderItem::FOLDER_TYPE_OEM) {
173    LOG(WARNING) << "MoveItemToFolderAt called with OEM folder as source";
174    return false;
175  }
176  AppListFolderItem* dest_folder = FindOrCreateFolderItem(folder_id);
177  scoped_ptr<AppListItem> item_ptr = RemoveItem(item);
178  if (dest_folder) {
179    item_ptr->set_position(
180        dest_folder->item_list()->CreatePositionBefore(position));
181    AddItemToFolderItemAndNotify(dest_folder, item_ptr.Pass());
182  } else {
183    item_ptr->set_position(
184        top_level_item_list_->CreatePositionBefore(position));
185    AddItemToItemListAndNotifyUpdate(item_ptr.Pass());
186  }
187  return true;
188}
189
190void AppListModel::SetItemPosition(AppListItem* item,
191                                   const syncer::StringOrdinal& new_position) {
192  if (!item->IsInFolder()) {
193    top_level_item_list_->SetItemPosition(item, new_position);
194    // Note: this will trigger OnListItemMoved which will signal observers.
195    // (This is done this way because some View code still moves items within
196    // the item list directly).
197    return;
198  }
199  AppListFolderItem* folder = FindFolderItem(item->folder_id());
200  DCHECK(folder);
201  folder->item_list()->SetItemPosition(item, new_position);
202  FOR_EACH_OBSERVER(AppListModelObserver,
203                    observers_,
204                    OnAppListItemUpdated(item));
205}
206
207void AppListModel::SetItemName(AppListItem* item, const std::string& name) {
208  item->SetName(name);
209  DVLOG(2) << "AppListModel::SetItemName: " << item->ToDebugString();
210  FOR_EACH_OBSERVER(AppListModelObserver,
211                    observers_,
212                    OnAppListItemUpdated(item));
213}
214
215void AppListModel::SetItemNameAndShortName(AppListItem* item,
216                                           const std::string& name,
217                                           const std::string& short_name) {
218  item->SetNameAndShortName(name, short_name);
219  DVLOG(2) << "AppListModel::SetItemNameAndShortName: "
220           << item->ToDebugString();
221  FOR_EACH_OBSERVER(AppListModelObserver,
222                    observers_,
223                    OnAppListItemUpdated(item));
224}
225
226void AppListModel::DeleteItem(const std::string& id) {
227  AppListItem* item = FindItem(id);
228  if (!item)
229    return;
230  if (!item->IsInFolder()) {
231    DCHECK_EQ(0u, item->ChildItemCount())
232        << "Invalid call to DeleteItem for item with children: " << id;
233    FOR_EACH_OBSERVER(AppListModelObserver,
234                      observers_,
235                      OnAppListItemWillBeDeleted(item));
236    top_level_item_list_->DeleteItem(id);
237    return;
238  }
239  AppListFolderItem* folder = FindFolderItem(item->folder_id());
240  DCHECK(folder) << "Folder not found for item: " << item->ToDebugString();
241  scoped_ptr<AppListItem> child_item = RemoveItemFromFolder(folder, item);
242  DCHECK_EQ(item, child_item.get());
243  FOR_EACH_OBSERVER(AppListModelObserver,
244                    observers_,
245                    OnAppListItemWillBeDeleted(item));
246  child_item.reset();  // Deletes item.
247}
248
249void AppListModel::NotifyExtensionPreferenceChanged() {
250  for (size_t i = 0; i < top_level_item_list_->item_count(); ++i)
251    top_level_item_list_->item_at(i)->OnExtensionPreferenceChanged();
252}
253
254// Private methods
255
256void AppListModel::OnListItemMoved(size_t from_index,
257                                   size_t to_index,
258                                   AppListItem* item) {
259  FOR_EACH_OBSERVER(AppListModelObserver,
260                    observers_,
261                    OnAppListItemUpdated(item));
262}
263
264AppListFolderItem* AppListModel::FindOrCreateFolderItem(
265    const std::string& folder_id) {
266  if (folder_id.empty())
267    return NULL;
268
269  AppListFolderItem* dest_folder = FindFolderItem(folder_id);
270  if (dest_folder)
271    return dest_folder;
272
273  DVLOG(2) << "Creating new folder: " << folder_id;
274  scoped_ptr<AppListFolderItem> new_folder(
275      new AppListFolderItem(folder_id, AppListFolderItem::FOLDER_TYPE_NORMAL));
276  new_folder->set_position(
277      top_level_item_list_->CreatePositionBefore(syncer::StringOrdinal()));
278  AppListItem* new_folder_item =
279      AddItemToItemListAndNotify(new_folder.PassAs<AppListItem>());
280  return static_cast<AppListFolderItem*>(new_folder_item);
281}
282
283AppListItem* AppListModel::AddItemToItemListAndNotify(
284    scoped_ptr<AppListItem> item_ptr) {
285  DCHECK(!item_ptr->IsInFolder());
286  AppListItem* item = top_level_item_list_->AddItem(item_ptr.Pass());
287  FOR_EACH_OBSERVER(AppListModelObserver,
288                    observers_,
289                    OnAppListItemAdded(item));
290  return item;
291}
292
293AppListItem* AppListModel::AddItemToItemListAndNotifyUpdate(
294    scoped_ptr<AppListItem> item_ptr) {
295  DCHECK(!item_ptr->IsInFolder());
296  AppListItem* item = top_level_item_list_->AddItem(item_ptr.Pass());
297  FOR_EACH_OBSERVER(AppListModelObserver,
298                    observers_,
299                    OnAppListItemUpdated(item));
300  return item;
301}
302
303AppListItem* AppListModel::AddItemToFolderItemAndNotify(
304    AppListFolderItem* folder,
305    scoped_ptr<AppListItem> item_ptr) {
306  AppListItem* item = folder->item_list()->AddItem(item_ptr.Pass());
307  item->set_folder_id(folder->id());
308  FOR_EACH_OBSERVER(AppListModelObserver,
309                    observers_,
310                    OnAppListItemUpdated(item));
311  return item;
312}
313
314scoped_ptr<AppListItem> AppListModel::RemoveItem(AppListItem* item) {
315  if (!item->IsInFolder())
316    return top_level_item_list_->RemoveItem(item->id());
317
318  AppListFolderItem* folder = FindFolderItem(item->folder_id());
319  return RemoveItemFromFolder(folder, item);
320}
321
322scoped_ptr<AppListItem> AppListModel::RemoveItemFromFolder(
323    AppListFolderItem* folder,
324    AppListItem* item) {
325  std::string folder_id = folder->id();
326  DCHECK_EQ(item->folder_id(), folder_id);
327  scoped_ptr<AppListItem> result = folder->item_list()->RemoveItem(item->id());
328  result->set_folder_id("");
329  if (folder->item_list()->item_count() == 0) {
330    DVLOG(2) << "Deleting empty folder: " << folder->ToDebugString();
331    DeleteItem(folder_id);
332  }
333  return result.Pass();
334}
335
336}  // namespace app_list
337