1 // Copyright 2013 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 "ash/shelf/shelf_window_watcher.h" 6 7 #include "ash/display/display_controller.h" 8 #include "ash/shelf/shelf_constants.h" 9 #include "ash/shelf/shelf_item_delegate_manager.h" 10 #include "ash/shelf/shelf_model.h" 11 #include "ash/shelf/shelf_util.h" 12 #include "ash/shelf/shelf_window_watcher_item_delegate.h" 13 #include "ash/shell.h" 14 #include "ash/shell_window_ids.h" 15 #include "ash/wm/window_state.h" 16 #include "ash/wm/window_util.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "ui/aura/window.h" 19 #include "ui/base/resource/resource_bundle.h" 20 #include "ui/gfx/image/image_skia.h" 21 #include "ui/gfx/screen.h" 22 #include "ui/wm/public/activation_client.h" 23 24 namespace { 25 26 // Sets ShelfItem property by using the value of |details|. 27 void SetShelfItemDetailsForShelfItem(ash::ShelfItem* item, 28 const ash::ShelfItemDetails& details) { 29 item->type = details.type; 30 if (details.image_resource_id != ash::kInvalidImageResourceID) { 31 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); 32 item->image = *rb.GetImageSkiaNamed(details.image_resource_id); 33 } 34 } 35 36 // Returns true if |window| has a ShelfItem added by ShelfWindowWatcher. 37 bool HasShelfItemForWindow(aura::Window* window) { 38 if (ash::GetShelfItemDetailsForWindow(window) != NULL && 39 ash::GetShelfIDForWindow(window) != ash::kInvalidShelfID) 40 return true; 41 return false; 42 } 43 44 // Returns true if |window| is in the process of being dragged. 45 bool IsDragging(aura::Window* window) { 46 return ash::wm::GetWindowState(window)->is_dragged(); 47 } 48 49 } // namespace 50 51 namespace ash { 52 53 ShelfWindowWatcher::RootWindowObserver::RootWindowObserver( 54 ShelfWindowWatcher* window_watcher) 55 : window_watcher_(window_watcher) { 56 } 57 58 ShelfWindowWatcher::RootWindowObserver::~RootWindowObserver() { 59 } 60 61 void ShelfWindowWatcher::RootWindowObserver::OnWindowDestroying( 62 aura::Window* window) { 63 window_watcher_->OnRootWindowRemoved(window); 64 } 65 66 ShelfWindowWatcher::RemovedWindowObserver::RemovedWindowObserver( 67 ShelfWindowWatcher* window_watcher) 68 : window_watcher_(window_watcher) { 69 } 70 71 ShelfWindowWatcher::RemovedWindowObserver::~RemovedWindowObserver() { 72 } 73 74 void ShelfWindowWatcher::RemovedWindowObserver::OnWindowParentChanged( 75 aura::Window* window, 76 aura::Window* parent) { 77 // When |parent| is NULL, this |window| will be destroyed. In that case, its 78 // item will be removed at OnWindowDestroyed(). 79 if (!parent) 80 return; 81 82 // When |parent| is changed from default container to docked container 83 // during the dragging, |window|'s item should not be removed because it will 84 // be re-parented to default container again after finishing the dragging. 85 // We don't need to check |parent| is default container because this observer 86 // is already removed from |window| when |window| is re-parented to default 87 // container. 88 if (IsDragging(window) && parent->id() == kShellWindowId_DockedContainer) 89 return; 90 91 // When |window| is re-parented to other containers or |window| is re-parented 92 // not to |docked_container| during the dragging, its item should be removed 93 // and stop observing this |window|. 94 window_watcher_->FinishObservingRemovedWindow(window); 95 } 96 97 void ShelfWindowWatcher::RemovedWindowObserver::OnWindowDestroyed( 98 aura::Window* window) { 99 DCHECK(HasShelfItemForWindow(window)); 100 window_watcher_->FinishObservingRemovedWindow(window); 101 } 102 103 ShelfWindowWatcher::ShelfWindowWatcher( 104 ShelfModel* model, 105 ShelfItemDelegateManager* item_delegate_manager) 106 : model_(model), 107 item_delegate_manager_(item_delegate_manager), 108 root_window_observer_(this), 109 removed_window_observer_(this), 110 observed_windows_(this), 111 observed_root_windows_(&root_window_observer_), 112 observed_removed_windows_(&removed_window_observer_), 113 observed_activation_clients_(this) { 114 // We can't assume all RootWindows have the same ActivationClient. 115 // Add a RootWindow and its ActivationClient to the observed list. 116 aura::Window::Windows root_windows = Shell::GetAllRootWindows(); 117 for (aura::Window::Windows::const_iterator it = root_windows.begin(); 118 it != root_windows.end(); ++it) 119 OnRootWindowAdded(*it); 120 121 Shell::GetScreen()->AddObserver(this); 122 } 123 124 ShelfWindowWatcher::~ShelfWindowWatcher() { 125 Shell::GetScreen()->RemoveObserver(this); 126 } 127 128 void ShelfWindowWatcher::AddShelfItem(aura::Window* window) { 129 const ShelfItemDetails* item_details = 130 GetShelfItemDetailsForWindow(window); 131 ShelfItem item; 132 ShelfID id = model_->next_id(); 133 item.status = wm::IsActiveWindow(window) ? STATUS_ACTIVE: STATUS_RUNNING; 134 SetShelfItemDetailsForShelfItem(&item, *item_details); 135 SetShelfIDForWindow(id, window); 136 scoped_ptr<ShelfItemDelegate> item_delegate( 137 new ShelfWindowWatcherItemDelegate(window, model_)); 138 // |item_delegate| is owned by |item_delegate_manager_|. 139 item_delegate_manager_->SetShelfItemDelegate(id, item_delegate.Pass()); 140 model_->Add(item); 141 } 142 143 void ShelfWindowWatcher::RemoveShelfItem(aura::Window* window) { 144 model_->RemoveItemAt(model_->ItemIndexByID(GetShelfIDForWindow(window))); 145 SetShelfIDForWindow(kInvalidShelfID, window); 146 } 147 148 void ShelfWindowWatcher::OnRootWindowAdded(aura::Window* root_window) { 149 // |observed_activation_clients_| can have the same ActivationClient multiple 150 // times - which would be handled by the |observed_activation_clients_|. 151 observed_activation_clients_.Add( 152 aura::client::GetActivationClient(root_window)); 153 observed_root_windows_.Add(root_window); 154 155 aura::Window* default_container = Shell::GetContainer( 156 root_window, 157 kShellWindowId_DefaultContainer); 158 observed_windows_.Add(default_container); 159 for (size_t i = 0; i < default_container->children().size(); ++i) 160 observed_windows_.Add(default_container->children()[i]); 161 } 162 163 void ShelfWindowWatcher::OnRootWindowRemoved(aura::Window* root_window) { 164 observed_root_windows_.Remove(root_window); 165 observed_activation_clients_.Remove( 166 aura::client::GetActivationClient(root_window)); 167 } 168 169 void ShelfWindowWatcher::UpdateShelfItemStatus(aura::Window* window, 170 bool is_active) { 171 int index = GetShelfItemIndexForWindow(window); 172 DCHECK_GE(index, 0); 173 174 ShelfItem item = model_->items()[index]; 175 item.status = is_active ? STATUS_ACTIVE : STATUS_RUNNING; 176 model_->Set(index, item); 177 } 178 179 int ShelfWindowWatcher::GetShelfItemIndexForWindow( 180 aura::Window* window) const { 181 return model_->ItemIndexByID(GetShelfIDForWindow(window)); 182 } 183 184 void ShelfWindowWatcher::StartObservingRemovedWindow(aura::Window* window) { 185 observed_removed_windows_.Add(window); 186 } 187 188 void ShelfWindowWatcher::FinishObservingRemovedWindow(aura::Window* window) { 189 observed_removed_windows_.Remove(window); 190 RemoveShelfItem(window); 191 } 192 193 void ShelfWindowWatcher::OnWindowActivated(aura::Window* gained_active, 194 aura::Window* lost_active) { 195 if (gained_active && HasShelfItemForWindow(gained_active)) 196 UpdateShelfItemStatus(gained_active, true); 197 if (lost_active && HasShelfItemForWindow(lost_active)) 198 UpdateShelfItemStatus(lost_active, false); 199 } 200 201 void ShelfWindowWatcher::OnWindowAdded(aura::Window* window) { 202 observed_windows_.Add(window); 203 204 if (observed_removed_windows_.IsObserving(window)) { 205 // When |window| is added and it is already observed by 206 // |dragged_window_observer_|, |window| already has its item. 207 DCHECK(HasShelfItemForWindow(window)); 208 observed_removed_windows_.Remove(window); 209 return; 210 } 211 212 // Add ShelfItem if |window| already has a ShelfItemDetails when it is 213 // created. Don't make a new ShelfItem for the re-parented |window| that 214 // already has a ShelfItem. 215 if (GetShelfIDForWindow(window) == kInvalidShelfID && 216 GetShelfItemDetailsForWindow(window)) 217 AddShelfItem(window); 218 } 219 220 void ShelfWindowWatcher::OnWillRemoveWindow(aura::Window* window) { 221 // Remove a child window of default container. 222 if (observed_windows_.IsObserving(window)) 223 observed_windows_.Remove(window); 224 225 // Don't remove |window| item immediately. Instead, defer handling of removing 226 // |window|'s item to RemovedWindowObserver because |window| could be added 227 // again to default container. 228 if (HasShelfItemForWindow(window)) 229 StartObservingRemovedWindow(window); 230 } 231 232 void ShelfWindowWatcher::OnWindowDestroying(aura::Window* window) { 233 // Remove the default container. 234 if (observed_windows_.IsObserving(window)) 235 observed_windows_.Remove(window); 236 } 237 238 void ShelfWindowWatcher::OnWindowPropertyChanged(aura::Window* window, 239 const void* key, 240 intptr_t old) { 241 if (key != kShelfItemDetailsKey) 242 return; 243 244 if (GetShelfItemDetailsForWindow(window) == NULL) { 245 // Removes ShelfItem for |window| when it has a ShelfItem. 246 if (reinterpret_cast<ShelfItemDetails*>(old) != NULL) 247 RemoveShelfItem(window); 248 return; 249 } 250 251 // When ShelfItemDetails is changed, update ShelfItem. 252 if (HasShelfItemForWindow(window)) { 253 int index = GetShelfItemIndexForWindow(window); 254 DCHECK_GE(index, 0); 255 ShelfItem item = model_->items()[index]; 256 const ShelfItemDetails* details = 257 GetShelfItemDetailsForWindow(window); 258 SetShelfItemDetailsForShelfItem(&item, *details); 259 model_->Set(index, item); 260 return; 261 } 262 263 // Creates a new ShelfItem for |window|. 264 AddShelfItem(window); 265 } 266 267 void ShelfWindowWatcher::OnDisplayAdded(const gfx::Display& new_display) { 268 // Add a new RootWindow and its ActivationClient to observed list. 269 aura::Window* root_window = Shell::GetInstance()->display_controller()-> 270 GetRootWindowForDisplayId(new_display.id()); 271 272 // When the primary root window's display get removed, the existing root 273 // window is taken over by the new display and the observer is already set. 274 if (!observed_root_windows_.IsObserving(root_window)) 275 OnRootWindowAdded(root_window); 276 } 277 278 void ShelfWindowWatcher::OnDisplayRemoved(const gfx::Display& old_display) { 279 // When this is called, RootWindow of |old_display| is already removed. 280 // Instead, we remove an observer from RootWindow and ActivationClient in the 281 // OnRootWindowDestroyed(). 282 // Do nothing here. 283 } 284 285 void ShelfWindowWatcher::OnDisplayMetricsChanged(const gfx::Display&, 286 uint32_t) { 287 } 288 289 } // namespace ash 290