| OLD | NEW |
|---|
| (Empty) |
| 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 "chrome/browser/ui/panels/stacked_panel_collection.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include "base/auto_reset.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/strings/utf_string_conversions.h" | |
| 11 #include "chrome/browser/ui/panels/detached_panel_collection.h" | |
| 12 #include "chrome/browser/ui/panels/display_settings_provider.h" | |
| 13 #include "chrome/browser/ui/panels/native_panel_stack_window.h" | |
| 14 #include "chrome/browser/ui/panels/panel.h" | |
| 15 #include "chrome/browser/ui/panels/panel_constants.h" | |
| 16 #include "chrome/browser/ui/panels/panel_manager.h" | |
| 17 #include "extensions/common/extension.h" | |
| 18 | |
| 19 StackedPanelCollection::StackedPanelCollection(PanelManager* panel_manager) | |
| 20 : PanelCollection(PanelCollection::STACKED), | |
| 21 panel_manager_(panel_manager), | |
| 22 primary_stack_window_(NULL), | |
| 23 secondary_stack_window_(NULL), | |
| 24 minimizing_all_(false) { | |
| 25 } | |
| 26 | |
| 27 StackedPanelCollection::~StackedPanelCollection() { | |
| 28 DCHECK(panels_.empty()); | |
| 29 DCHECK(most_recently_active_panels_.empty()); | |
| 30 } | |
| 31 | |
| 32 void StackedPanelCollection::OnDisplayChanged() { | |
| 33 if (panels_.empty()) | |
| 34 return; | |
| 35 | |
| 36 gfx::Rect enclosing_bounds = GetEnclosingBounds(); | |
| 37 gfx::Rect work_area = panel_manager_->display_settings_provider()-> | |
| 38 GetWorkAreaMatching(enclosing_bounds); | |
| 39 | |
| 40 // If the height of the whole stack is bigger than the height of the new work | |
| 41 // area, try to reduce the stack height by collapsing panels. In rare case, | |
| 42 // all panels are collapsed and there is still not enough space. We simply | |
| 43 // let the stack go beyond the work area limit. | |
| 44 if (enclosing_bounds.height() > work_area.height()) { | |
| 45 int needed_space = enclosing_bounds.height() - work_area.height(); | |
| 46 MinimizePanelsForSpace(needed_space); | |
| 47 } | |
| 48 | |
| 49 gfx::Rect top_bounds = top_panel()->GetBounds(); | |
| 50 int common_width = top_bounds.width(); | |
| 51 if (common_width > work_area.width()) | |
| 52 common_width = work_area.width(); | |
| 53 | |
| 54 int common_x = top_bounds.x(); | |
| 55 if (common_x + common_width > work_area.right()) | |
| 56 common_x = work_area.right() - common_width; | |
| 57 if (common_x < work_area.x()) | |
| 58 common_x = work_area.x(); | |
| 59 | |
| 60 int total_height = bottom_panel()->GetBounds().bottom() - top_bounds.y(); | |
| 61 int start_y = top_bounds.y(); | |
| 62 if (start_y + total_height > work_area.bottom()) | |
| 63 start_y = work_area.bottom() - total_height; | |
| 64 if (start_y < work_area.y()) | |
| 65 start_y = work_area.y(); | |
| 66 | |
| 67 RefreshLayoutWithTopPanelStartingAt( | |
| 68 gfx::Point(common_x, start_y), common_width); | |
| 69 } | |
| 70 | |
| 71 void StackedPanelCollection::RefreshLayout() { | |
| 72 if (panels_.empty()) | |
| 73 return; | |
| 74 gfx::Rect top_bounds = top_panel()->GetBounds(); | |
| 75 RefreshLayoutWithTopPanelStartingAt(top_bounds.origin(), top_bounds.width()); | |
| 76 } | |
| 77 | |
| 78 void StackedPanelCollection::RefreshLayoutWithTopPanelStartingAt( | |
| 79 const gfx::Point& start_position, int common_width) { | |
| 80 if (panels_.empty()) | |
| 81 return; | |
| 82 | |
| 83 // If only one panel is left in the stack, we only need to check if it should | |
| 84 // be moved to |start_y| position. | |
| 85 if (panels_.size() == 1) { | |
| 86 Panel* panel = panels_.front(); | |
| 87 gfx::Rect bounds = panel->GetBounds(); | |
| 88 if (bounds.origin() != start_position) { | |
| 89 bounds.set_origin(start_position); | |
| 90 panel->SetPanelBounds(bounds); | |
| 91 } | |
| 92 return; | |
| 93 } | |
| 94 | |
| 95 // We do not update bounds for affected panels one by one. Instead, all | |
| 96 // changes are bundled and performed synchronously. | |
| 97 primary_stack_window_->BeginBatchUpdatePanelBounds(true); | |
| 98 if (secondary_stack_window_) | |
| 99 secondary_stack_window_->BeginBatchUpdatePanelBounds(true); | |
| 100 | |
| 101 int y = start_position.y(); | |
| 102 int common_x = start_position.x(); | |
| 103 for (Panels::const_iterator iter = panels_.begin(); | |
| 104 iter != panels_.end(); ++iter) { | |
| 105 Panel* panel = *iter; | |
| 106 | |
| 107 // The visibility of minimize button might need to be updated due to that | |
| 108 // top panel might change when a panel is being added or removed from | |
| 109 // the stack. | |
| 110 panel->UpdateMinimizeRestoreButtonVisibility(); | |
| 111 | |
| 112 // Don't update the stacked panel that is in preview mode. | |
| 113 gfx::Rect bounds = panel->GetBounds(); | |
| 114 if (panel->in_preview_mode()) { | |
| 115 y += bounds.height(); | |
| 116 continue; | |
| 117 } | |
| 118 | |
| 119 // Update the restored size. | |
| 120 gfx::Size full_size = panel->full_size(); | |
| 121 full_size.set_width(common_width); | |
| 122 panel->set_full_size(full_size); | |
| 123 | |
| 124 // Recompute the bounds. | |
| 125 bounds.SetRect( | |
| 126 common_x, | |
| 127 y, | |
| 128 common_width, | |
| 129 panel->expansion_state() == Panel::EXPANDED ? | |
| 130 panel->full_size().height() : panel->TitleOnlyHeight()); | |
| 131 | |
| 132 GetStackWindowForPanel(panel)->AddPanelBoundsForBatchUpdate(panel, bounds); | |
| 133 | |
| 134 y += bounds.height(); | |
| 135 } | |
| 136 | |
| 137 primary_stack_window_->EndBatchUpdatePanelBounds(); | |
| 138 if (secondary_stack_window_) | |
| 139 secondary_stack_window_->EndBatchUpdatePanelBounds(); | |
| 140 } | |
| 141 | |
| 142 base::string16 StackedPanelCollection::GetTitle() const { | |
| 143 if (panels_.empty()) | |
| 144 return base::string16(); | |
| 145 | |
| 146 Panel* panel = panels_.front(); | |
| 147 const extensions::Extension* extension = panel->GetExtension(); | |
| 148 return base::UTF8ToUTF16(extension && !extension->name().empty() ? | |
| 149 extension->name() : panel->app_name()); | |
| 150 } | |
| 151 | |
| 152 gfx::Image StackedPanelCollection::GetIcon() const { | |
| 153 if (panels_.empty()) | |
| 154 return gfx::Image(); | |
| 155 return panels_.front()->app_icon(); | |
| 156 } | |
| 157 | |
| 158 void StackedPanelCollection::PanelBoundsBatchUpdateCompleted() { | |
| 159 if (!secondary_stack_window_ || panels_.empty()) | |
| 160 return; | |
| 161 | |
| 162 if (top_panel()->in_preview_mode() != bottom_panel()->in_preview_mode() || | |
| 163 primary_stack_window_->IsAnimatingPanelBounds() || | |
| 164 secondary_stack_window_->IsAnimatingPanelBounds()) | |
| 165 return; | |
| 166 | |
| 167 // Move all panels from secondary stack window to primary stack window. | |
| 168 primary_stack_window_->MergeWith(secondary_stack_window_); | |
| 169 secondary_stack_window_->Close(); | |
| 170 secondary_stack_window_ = NULL; | |
| 171 } | |
| 172 | |
| 173 gfx::Rect StackedPanelCollection::GetEnclosingBounds() const { | |
| 174 gfx::Rect enclosing_bounds = top_panel()->GetBounds(); | |
| 175 enclosing_bounds.set_height( | |
| 176 bottom_panel()->GetBounds().bottom() - enclosing_bounds.y()); | |
| 177 return enclosing_bounds; | |
| 178 } | |
| 179 | |
| 180 int StackedPanelCollection::MinimizePanelsForSpace(int needed_space) { | |
| 181 int available_space = GetCurrentAvailableBottomSpace(); | |
| 182 | |
| 183 // Only the most recently active panel might be active. | |
| 184 Panel* active_panel = NULL; | |
| 185 if (!most_recently_active_panels_.empty()) { | |
| 186 Panel* most_recently_active_panel = most_recently_active_panels_.front(); | |
| 187 if (most_recently_active_panel->IsActive()) | |
| 188 active_panel = most_recently_active_panel; | |
| 189 } | |
| 190 | |
| 191 for (Panels::const_reverse_iterator iter = | |
| 192 most_recently_active_panels_.rbegin(); | |
| 193 iter != most_recently_active_panels_.rend() && | |
| 194 available_space < needed_space; | |
| 195 ++iter) { | |
| 196 Panel* current_panel = *iter; | |
| 197 if (current_panel != active_panel && !IsPanelMinimized(current_panel)) { | |
| 198 available_space += | |
| 199 current_panel->GetBounds().height() - panel::kTitlebarHeight; | |
| 200 MinimizePanel(current_panel); | |
| 201 } | |
| 202 } | |
| 203 return available_space; | |
| 204 } | |
| 205 | |
| 206 void StackedPanelCollection::AddPanel(Panel* panel, | |
| 207 PositioningMask positioning_mask) { | |
| 208 DCHECK_NE(this, panel->collection()); | |
| 209 panel->set_collection(this); | |
| 210 Panel* adjacent_panel = NULL; | |
| 211 if (positioning_mask & PanelCollection::TOP_POSITION) { | |
| 212 adjacent_panel = top_panel(); | |
| 213 panels_.push_front(panel); | |
| 214 } else { | |
| 215 // To fit the new panel within the working area, collapse unfocused panels | |
| 216 // in the least recent active order until there is enough space. | |
| 217 if (positioning_mask & PanelCollection::COLLAPSE_TO_FIT) { | |
| 218 int needed_space = panel->GetBounds().height(); | |
| 219 int available_space = MinimizePanelsForSpace(needed_space); | |
| 220 DCHECK(available_space >= needed_space); | |
| 221 } | |
| 222 | |
| 223 adjacent_panel = bottom_panel(); | |
| 224 panels_.push_back(panel); | |
| 225 } | |
| 226 | |
| 227 if (panel->IsActive()) | |
| 228 most_recently_active_panels_.push_front(panel); | |
| 229 else | |
| 230 most_recently_active_panels_.push_back(panel); | |
| 231 | |
| 232 if (adjacent_panel) | |
| 233 UpdatePanelCornerStyle(adjacent_panel); | |
| 234 | |
| 235 // The secondary stack window should be used when one of the following occurs: | |
| 236 // 1) Some panels but not all panels are being dragged. This is because | |
| 237 // those panels being dragged might not be fully aligned with other panels | |
| 238 // not being dragged. | |
| 239 // 2) The newly added panel is not fully aligned with the existing panel, in | |
| 240 // terms of both x and width. | |
| 241 NativePanelStackWindow* stack_window; | |
| 242 if (top_panel()->in_preview_mode() == bottom_panel()->in_preview_mode() && | |
| 243 top_panel()->GetBounds().x() == bottom_panel()->GetBounds().x() && | |
| 244 top_panel()->GetBounds().width() == bottom_panel()->GetBounds().width()) { | |
| 245 if (!primary_stack_window_) | |
| 246 primary_stack_window_ = NativePanelStackWindow::Create(this); | |
| 247 stack_window = primary_stack_window_; | |
| 248 } else { | |
| 249 if (!secondary_stack_window_) | |
| 250 secondary_stack_window_ = NativePanelStackWindow::Create(this); | |
| 251 stack_window = secondary_stack_window_; | |
| 252 } | |
| 253 stack_window->AddPanel(panel); | |
| 254 | |
| 255 if ((positioning_mask & NO_LAYOUT_REFRESH) == 0) | |
| 256 RefreshLayout(); | |
| 257 } | |
| 258 | |
| 259 void StackedPanelCollection::RemovePanel(Panel* panel, RemovalReason reason) { | |
| 260 bool is_top = panel == top_panel(); | |
| 261 bool is_bottom = panel == bottom_panel(); | |
| 262 | |
| 263 // If the top panel is being closed, all panels below it should move up. To | |
| 264 // do this, the top y position of top panel needs to be tracked first. | |
| 265 bool top_panel_closed = false; | |
| 266 gfx::Point top_origin; | |
| 267 int top_width = 0; | |
| 268 if (reason == PanelCollection::PANEL_CLOSED && is_top) { | |
| 269 top_panel_closed = true; | |
| 270 top_origin = panel->GetBounds().origin(); | |
| 271 top_width = panel->GetBounds().width(); | |
| 272 } | |
| 273 | |
| 274 panel->set_collection(NULL); | |
| 275 panels_.remove(panel); | |
| 276 most_recently_active_panels_.remove(panel); | |
| 277 | |
| 278 if (is_top) { | |
| 279 Panel* new_top_panel = top_panel(); | |
| 280 if (new_top_panel) | |
| 281 UpdatePanelCornerStyle(new_top_panel); | |
| 282 } else if (is_bottom) { | |
| 283 Panel* new_bottom_panel = bottom_panel(); | |
| 284 if (new_bottom_panel) | |
| 285 UpdatePanelCornerStyle(new_bottom_panel); | |
| 286 } | |
| 287 | |
| 288 // If an active panel is being closed, try to focus the next recently active | |
| 289 // panel in the stack that is not minimized. | |
| 290 if (reason == PanelCollection::PANEL_CLOSED && | |
| 291 panel->IsActive() && | |
| 292 !most_recently_active_panels_.empty()) { | |
| 293 for (Panels::const_iterator iter = most_recently_active_panels_.begin(); | |
| 294 iter != most_recently_active_panels_.end(); ++iter) { | |
| 295 Panel* other_panel = *iter; | |
| 296 if (!IsPanelMinimized(other_panel)) { | |
| 297 other_panel->Activate(); | |
| 298 break; | |
| 299 } | |
| 300 } | |
| 301 } | |
| 302 | |
| 303 // If the top panel is closed, move up all other panels to stay at the same | |
| 304 // y position as the top panel being closed. | |
| 305 if (top_panel_closed) | |
| 306 RefreshLayoutWithTopPanelStartingAt(top_origin, top_width); | |
| 307 else if (reason == PanelCollection::PANEL_CLOSED) | |
| 308 RefreshLayout(); | |
| 309 | |
| 310 // Remove the panel from the corresponding stack window. | |
| 311 GetStackWindowForPanel(panel)->RemovePanel(panel); | |
| 312 | |
| 313 // Close the secondary stack window if no panel is is shown inside it. | |
| 314 // Note that we do not need to do this for primary stack window since the | |
| 315 // whole stack will be gone when only one panel is left. | |
| 316 if (secondary_stack_window_ && secondary_stack_window_->IsEmpty()) { | |
| 317 secondary_stack_window_->Close(); | |
| 318 secondary_stack_window_ = NULL; | |
| 319 } | |
| 320 } | |
| 321 | |
| 322 void StackedPanelCollection::CloseAll() { | |
| 323 // Make a copy as closing panels can modify the iterator. | |
| 324 Panels panels_copy = panels_; | |
| 325 | |
| 326 for (Panels::const_iterator iter = panels_copy.begin(); | |
| 327 iter != panels_copy.end(); ++iter) | |
| 328 (*iter)->Close(); | |
| 329 | |
| 330 if (primary_stack_window_) { | |
| 331 primary_stack_window_->Close(); | |
| 332 primary_stack_window_ = NULL; | |
| 333 } | |
| 334 if (secondary_stack_window_) { | |
| 335 secondary_stack_window_->Close(); | |
| 336 secondary_stack_window_ = NULL; | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 void StackedPanelCollection::OnPanelAttentionStateChanged(Panel* panel) { | |
| 341 if ((panel->attention_mode() & Panel::USE_SYSTEM_ATTENTION) != 0) | |
| 342 primary_stack_window_->DrawSystemAttention(panel->IsDrawingAttention()); | |
| 343 } | |
| 344 | |
| 345 void StackedPanelCollection::OnPanelTitlebarClicked( | |
| 346 Panel* panel, panel::ClickModifier modifier) { | |
| 347 bool expanded = panel->expansion_state() == Panel::EXPANDED; | |
| 348 if (modifier == panel::APPLY_TO_ALL) { | |
| 349 if (expanded) | |
| 350 MinimizeAll(); | |
| 351 else | |
| 352 RestoreAll(panel); | |
| 353 } else { | |
| 354 if (expanded) | |
| 355 MinimizePanel(panel); | |
| 356 else | |
| 357 RestorePanel(panel); | |
| 358 } | |
| 359 } | |
| 360 | |
| 361 void StackedPanelCollection::ResizePanelWindow( | |
| 362 Panel* panel, | |
| 363 const gfx::Size& preferred_window_size) { | |
| 364 } | |
| 365 | |
| 366 void StackedPanelCollection::ActivatePanel(Panel* panel) { | |
| 367 // Make sure the panel is expanded when activated so the user input | |
| 368 // does not go into a collapsed window. | |
| 369 if (panel->IsMinimized()) | |
| 370 panel->SetExpansionState(Panel::EXPANDED); | |
| 371 } | |
| 372 | |
| 373 void StackedPanelCollection::MinimizePanel(Panel* panel) { | |
| 374 panel->SetExpansionState(Panel::TITLE_ONLY); | |
| 375 } | |
| 376 | |
| 377 void StackedPanelCollection::RestorePanel(Panel* panel) { | |
| 378 // Ensure that the panel could fit within the work area after it is expanded. | |
| 379 // First, try to collapse the unfocused panel in the least recent active | |
| 380 // order in order to get enough space. | |
| 381 int needed_space = panel->full_size().height() - panel->TitleOnlyHeight(); | |
| 382 int available_space = MinimizePanelsForSpace(needed_space); | |
| 383 | |
| 384 // If there is still not enough space, try to move up the stack. | |
| 385 int space_beyond_available = needed_space - available_space; | |
| 386 if (space_beyond_available > 0) { | |
| 387 int top_available_space = GetCurrentAvailableTopSpace(); | |
| 388 int move_delta = (space_beyond_available > top_available_space) ? | |
| 389 top_available_space : space_beyond_available; | |
| 390 for (Panels::const_iterator iter = panels_.begin(); | |
| 391 iter != panels_.end(); iter++) { | |
| 392 Panel* current_panel = *iter; | |
| 393 gfx::Rect bounds = current_panel->GetBounds(); | |
| 394 bounds.set_y(bounds.y() - move_delta); | |
| 395 current_panel->SetPanelBounds(bounds); | |
| 396 } | |
| 397 available_space += move_delta; | |
| 398 } | |
| 399 | |
| 400 // If there is still not enough space, shrink the restored height to make it | |
| 401 // fit at the last resort. Note that the restored height cannot be shrunk less | |
| 402 // than the minimum panel height. If this is the case, we will just let it | |
| 403 // expand beyond the screen boundary. | |
| 404 space_beyond_available = needed_space - available_space; | |
| 405 if (space_beyond_available > 0) { | |
| 406 gfx::Size full_size = panel->full_size(); | |
| 407 int reduced_height = full_size.height() - space_beyond_available; | |
| 408 if (reduced_height < panel::kPanelMinHeight) | |
| 409 reduced_height = panel::kPanelMinHeight; | |
| 410 full_size.set_height(reduced_height); | |
| 411 panel->set_full_size(full_size); | |
| 412 } | |
| 413 | |
| 414 panel->SetExpansionState(Panel::EXPANDED); | |
| 415 } | |
| 416 | |
| 417 void StackedPanelCollection::MinimizeAll() { | |
| 418 // Set minimizing_all_ to prevent deactivation of each panel when it | |
| 419 // is minimized. See comments in OnPanelExpansionStateChanged. | |
| 420 base::AutoReset<bool> pin(&minimizing_all_, true); | |
| 421 Panel* minimized_active_panel = NULL; | |
| 422 for (Panels::const_iterator iter = panels_.begin(); | |
| 423 iter != panels_.end(); ++iter) { | |
| 424 if ((*iter)->IsActive()) | |
| 425 minimized_active_panel = *iter; | |
| 426 MinimizePanel(*iter); | |
| 427 } | |
| 428 | |
| 429 // When a single panel is minimized, it is deactivated to ensure that | |
| 430 // a minimized panel does not have focus. However, when minimizing all, | |
| 431 // the deactivation is only done once after all panels are minimized, | |
| 432 // rather than per minimized panel, both for efficiency and to avoid | |
| 433 // temporary activations of random not-yet-minimized panels. | |
| 434 if (minimized_active_panel) { | |
| 435 minimized_active_panel->Deactivate(); | |
| 436 // Layout will be refreshed in response to (de)activation notification. | |
| 437 } | |
| 438 } | |
| 439 | |
| 440 void StackedPanelCollection::RestoreAll(Panel* panel_clicked) { | |
| 441 // Expand the panel being clicked first. This is to make sure at least one | |
| 442 // panel that is clicked by the user will be expanded. | |
| 443 RestorePanel(panel_clicked); | |
| 444 | |
| 445 // Try to expand all other panels starting from the most recently active | |
| 446 // panel. | |
| 447 for (Panels::const_iterator iter = most_recently_active_panels_.begin(); | |
| 448 iter != most_recently_active_panels_.end(); ++iter) { | |
| 449 // If the stack already extends to both top and bottom of the work area, | |
| 450 // stop now since we cannot fit any more expanded panels. | |
| 451 if (GetCurrentAvailableTopSpace() == 0 && | |
| 452 GetCurrentAvailableBottomSpace() == 0) { | |
| 453 break; | |
| 454 } | |
| 455 | |
| 456 Panel* panel = *iter; | |
| 457 if (panel != panel_clicked) | |
| 458 RestorePanel(panel); | |
| 459 } | |
| 460 } | |
| 461 | |
| 462 void StackedPanelCollection::OnMinimizeButtonClicked( | |
| 463 Panel* panel, panel::ClickModifier modifier) { | |
| 464 // The minimize button is only present in the top panel. | |
| 465 DCHECK_EQ(top_panel(), panel); | |
| 466 | |
| 467 primary_stack_window_->Minimize(); | |
| 468 } | |
| 469 | |
| 470 void StackedPanelCollection::OnRestoreButtonClicked( | |
| 471 Panel* panel, panel::ClickModifier modifier) { | |
| 472 NOTREACHED(); | |
| 473 } | |
| 474 | |
| 475 bool StackedPanelCollection::CanShowMinimizeButton(const Panel* panel) const { | |
| 476 // Only the top panel in the stack shows the minimize button. | |
| 477 return PanelManager::CanUseSystemMinimize() && panel == top_panel(); | |
| 478 } | |
| 479 | |
| 480 bool StackedPanelCollection::CanShowRestoreButton(const Panel* panel) const { | |
| 481 return false; | |
| 482 } | |
| 483 | |
| 484 bool StackedPanelCollection::IsPanelMinimized(const Panel* panel) const { | |
| 485 return panel->expansion_state() != Panel::EXPANDED; | |
| 486 } | |
| 487 | |
| 488 bool StackedPanelCollection::UsesAlwaysOnTopPanels() const { | |
| 489 return false; | |
| 490 } | |
| 491 | |
| 492 void StackedPanelCollection::SavePanelPlacement(Panel* panel) { | |
| 493 DCHECK(!saved_panel_placement_.panel); | |
| 494 saved_panel_placement_.panel = panel; | |
| 495 | |
| 496 if (top_panel() != panel) | |
| 497 saved_panel_placement_.top_panel = top_panel(); | |
| 498 else | |
| 499 saved_panel_placement_.position = panel->GetBounds().origin(); | |
| 500 | |
| 501 saved_panel_placement_.top_panel = top_panel() != panel ? top_panel() : NULL; | |
| 502 } | |
| 503 | |
| 504 void StackedPanelCollection::RestorePanelToSavedPlacement() { | |
| 505 DCHECK(saved_panel_placement_.panel); | |
| 506 | |
| 507 if (saved_panel_placement_.top_panel) { | |
| 508 // Restore the top panel if it has been moved out of the stack. This could | |
| 509 // happen when there're 2 panels in the stack and the bottom panel is being | |
| 510 // dragged out of the stack and thus cause both panels become detached. | |
| 511 if (saved_panel_placement_.top_panel->stack() != this) { | |
| 512 DCHECK_EQ(PanelCollection::DETACHED, | |
| 513 saved_panel_placement_.top_panel->collection()->type()); | |
| 514 panel_manager_->MovePanelToCollection( | |
| 515 saved_panel_placement_.top_panel, | |
| 516 this, | |
| 517 static_cast<PanelCollection::PositioningMask>( | |
| 518 PanelCollection::TOP_POSITION | | |
| 519 PanelCollection::NO_LAYOUT_REFRESH)); | |
| 520 } | |
| 521 RefreshLayout(); | |
| 522 } else { | |
| 523 // Restore the position when the top panel is being dragged. | |
| 524 DCHECK_EQ(top_panel(), saved_panel_placement_.panel); | |
| 525 RefreshLayoutWithTopPanelStartingAt(saved_panel_placement_.position, | |
| 526 top_panel()->GetBounds().width()); | |
| 527 } | |
| 528 | |
| 529 DiscardSavedPanelPlacement(); | |
| 530 } | |
| 531 | |
| 532 void StackedPanelCollection::DiscardSavedPanelPlacement() { | |
| 533 DCHECK(saved_panel_placement_.panel); | |
| 534 saved_panel_placement_.panel = NULL; | |
| 535 saved_panel_placement_.top_panel = NULL; | |
| 536 } | |
| 537 | |
| 538 panel::Resizability StackedPanelCollection::GetPanelResizability( | |
| 539 const Panel* panel) const { | |
| 540 // The panel in the stack can be resized by the following rules: | |
| 541 // * If collapsed, it can only be resized by its left or right edge. | |
| 542 // * Otherwise, it can be resized by its left or right edge plus: | |
| 543 // % top edge and corners, if it is at the top; | |
| 544 // % bottom edge, if it is not at the bottom. | |
| 545 // % bottom edge and corners, if it is at the bottom. | |
| 546 panel::Resizability resizability = static_cast<panel::Resizability>( | |
| 547 panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT); | |
| 548 if (panel->IsMinimized()) | |
| 549 return resizability; | |
| 550 if (panel == top_panel()) { | |
| 551 resizability = static_cast<panel::Resizability>(resizability | | |
| 552 panel::RESIZABLE_TOP | panel::RESIZABLE_TOP_LEFT | | |
| 553 panel::RESIZABLE_TOP_RIGHT); | |
| 554 } | |
| 555 if (panel == bottom_panel()) { | |
| 556 resizability = static_cast<panel::Resizability>(resizability | | |
| 557 panel::RESIZABLE_BOTTOM | panel::RESIZABLE_BOTTOM_LEFT | | |
| 558 panel::RESIZABLE_BOTTOM_RIGHT); | |
| 559 } else { | |
| 560 resizability = static_cast<panel::Resizability>(resizability | | |
| 561 panel::RESIZABLE_BOTTOM); | |
| 562 } | |
| 563 return resizability; | |
| 564 } | |
| 565 | |
| 566 void StackedPanelCollection::OnPanelResizedByMouse( | |
| 567 Panel* resized_panel, const gfx::Rect& new_bounds) { | |
| 568 resized_panel->set_full_size(new_bounds.size()); | |
| 569 | |
| 570 DCHECK(!secondary_stack_window_); | |
| 571 primary_stack_window_->BeginBatchUpdatePanelBounds(false); | |
| 572 | |
| 573 // The delta x and width can be computed from the difference between | |
| 574 // the panel being resized and any other panel. | |
| 575 Panel* other_panel = resized_panel == top_panel() ? bottom_panel() | |
| 576 : top_panel(); | |
| 577 gfx::Rect other_bounds = other_panel->GetBounds(); | |
| 578 int delta_x = new_bounds.x() - other_bounds.x(); | |
| 579 int delta_width = new_bounds.width() - other_bounds.width(); | |
| 580 | |
| 581 gfx::Rect previous_bounds; | |
| 582 bool resized_panel_found = false; | |
| 583 bool panel_below_resized_panel_updated = false; | |
| 584 for (Panels::const_iterator iter = panels_.begin(); | |
| 585 iter != panels_.end(); iter++) { | |
| 586 Panel* panel = *iter; | |
| 587 if (panel == resized_panel) { | |
| 588 // |new_bounds| should be used since the panel bounds have not been | |
| 589 // updated yet. | |
| 590 previous_bounds = new_bounds; | |
| 591 resized_panel_found = true; | |
| 592 primary_stack_window_->AddPanelBoundsForBatchUpdate(panel, new_bounds); | |
| 593 continue; | |
| 594 } | |
| 595 | |
| 596 gfx::Rect bounds = panel->GetBounds(); | |
| 597 bounds.set_x(bounds.x() + delta_x); | |
| 598 bounds.set_width(bounds.width() + delta_width); | |
| 599 | |
| 600 // If the panel below the panel being resized is expanded, update its | |
| 601 // height to offset the height change of the panel being resized. | |
| 602 // For example, the stack has P1 and P2 (from top to bottom). P1's height | |
| 603 // is 100 and P2's height is 120. If P1's bottom increases by 10, P2's | |
| 604 // height needs to shrink by 10. | |
| 605 if (resized_panel_found) { | |
| 606 if (!panel_below_resized_panel_updated && !panel->IsMinimized()) { | |
| 607 int old_bottom = bounds.bottom(); | |
| 608 bounds.set_y(previous_bounds.bottom()); | |
| 609 bounds.set_height(old_bottom - bounds.y()); | |
| 610 } else { | |
| 611 bounds.set_y(previous_bounds.bottom()); | |
| 612 } | |
| 613 panel_below_resized_panel_updated = true; | |
| 614 } | |
| 615 | |
| 616 if (!panel->IsMinimized()) | |
| 617 panel->set_full_size(bounds.size()); | |
| 618 | |
| 619 primary_stack_window_->AddPanelBoundsForBatchUpdate(panel, bounds); | |
| 620 previous_bounds = bounds; | |
| 621 } | |
| 622 | |
| 623 primary_stack_window_->EndBatchUpdatePanelBounds(); | |
| 624 } | |
| 625 | |
| 626 bool StackedPanelCollection::HasPanel(Panel* panel) const { | |
| 627 return std::find(panels_.begin(), panels_.end(), panel) != panels_.end(); | |
| 628 } | |
| 629 | |
| 630 void StackedPanelCollection::UpdatePanelOnCollectionChange(Panel* panel) { | |
| 631 panel->set_attention_mode( | |
| 632 static_cast<Panel::AttentionMode>(Panel::USE_PANEL_ATTENTION | | |
| 633 Panel::USE_SYSTEM_ATTENTION)); | |
| 634 panel->ShowShadow(false); | |
| 635 panel->UpdateMinimizeRestoreButtonVisibility(); | |
| 636 UpdatePanelCornerStyle(panel); | |
| 637 } | |
| 638 | |
| 639 void StackedPanelCollection::OnPanelExpansionStateChanged(Panel* panel) { | |
| 640 DCHECK_NE(Panel::MINIMIZED, panel->expansion_state()); | |
| 641 | |
| 642 // Ensure minimized panel does not get the focus. If minimizing all, | |
| 643 // the active panel will be deactivated once when all panels are minimized | |
| 644 // rather than per minimized panel. | |
| 645 if (panel->expansion_state() != Panel::EXPANDED && !minimizing_all_ && | |
| 646 panel->IsActive()) { | |
| 647 panel->Deactivate(); | |
| 648 } | |
| 649 | |
| 650 // The bounds change per expansion state will be done in RefreshLayout. | |
| 651 RefreshLayout(); | |
| 652 } | |
| 653 | |
| 654 void StackedPanelCollection::OnPanelActiveStateChanged(Panel* panel) { | |
| 655 if (!panel->IsActive()) | |
| 656 return; | |
| 657 | |
| 658 // Move the panel to the front if not yet. | |
| 659 Panels::iterator iter = std::find(most_recently_active_panels_.begin(), | |
| 660 most_recently_active_panels_.end(), panel); | |
| 661 DCHECK(iter != most_recently_active_panels_.end()); | |
| 662 if (iter != most_recently_active_panels_.begin()) { | |
| 663 most_recently_active_panels_.erase(iter); | |
| 664 most_recently_active_panels_.push_front(panel); | |
| 665 } | |
| 666 | |
| 667 GetStackWindowForPanel(panel)->OnPanelActivated(panel); | |
| 668 } | |
| 669 | |
| 670 gfx::Rect StackedPanelCollection::GetInitialPanelBounds( | |
| 671 const gfx::Rect& requested_bounds) const { | |
| 672 DCHECK(!panels_.empty()); | |
| 673 gfx::Rect bottom_panel_bounds = bottom_panel()->GetBounds(); | |
| 674 return gfx::Rect(bottom_panel_bounds.x(), | |
| 675 bottom_panel_bounds.bottom(), | |
| 676 bottom_panel_bounds.width(), | |
| 677 requested_bounds.height()); | |
| 678 } | |
| 679 | |
| 680 Panel* StackedPanelCollection::GetPanelAbove(Panel* panel) const { | |
| 681 DCHECK(panel); | |
| 682 | |
| 683 if (panels_.size() < 2) | |
| 684 return NULL; | |
| 685 Panels::const_iterator iter = panels_.begin(); | |
| 686 Panel* above_panel = *iter; | |
| 687 for (; iter != panels_.end(); ++iter) { | |
| 688 if (*iter == panel) | |
| 689 return above_panel; | |
| 690 above_panel = *iter; | |
| 691 } | |
| 692 return NULL; | |
| 693 } | |
| 694 | |
| 695 Panel* StackedPanelCollection::GetPanelBelow(Panel* panel) const { | |
| 696 DCHECK(panel); | |
| 697 | |
| 698 if (panels_.size() < 2) | |
| 699 return NULL; | |
| 700 Panels::const_iterator iter = | |
| 701 std::find(panels_.begin(), panels_.end(), panel); | |
| 702 if (iter == panels_.end()) | |
| 703 return NULL; | |
| 704 ++iter; | |
| 705 return iter == panels_.end() ? NULL : *iter; | |
| 706 } | |
| 707 | |
| 708 void StackedPanelCollection::MoveAllDraggingPanelsInstantly( | |
| 709 const gfx::Vector2d& delta_origin) { | |
| 710 for (Panels::const_iterator iter = panels_.begin(); | |
| 711 iter != panels_.end(); iter++) { | |
| 712 Panel* panel = *iter; | |
| 713 if (panel->in_preview_mode()) { | |
| 714 GetStackWindowForPanel(panel)->MovePanelsBy(delta_origin); | |
| 715 return; | |
| 716 } | |
| 717 } | |
| 718 } | |
| 719 | |
| 720 bool StackedPanelCollection::IsMinimized() const { | |
| 721 return primary_stack_window_->IsMinimized(); | |
| 722 } | |
| 723 | |
| 724 bool StackedPanelCollection::IsAnimatingPanelBounds(Panel* panel) const { | |
| 725 return GetStackWindowForPanel(panel)->IsAnimatingPanelBounds(); | |
| 726 } | |
| 727 | |
| 728 void StackedPanelCollection::UpdatePanelCornerStyle(Panel* panel) { | |
| 729 panel::CornerStyle corner_style; | |
| 730 bool at_top = panel == top_panel(); | |
| 731 bool at_bottom = panel == bottom_panel(); | |
| 732 if (at_top && at_bottom) | |
| 733 corner_style = panel::ALL_ROUNDED; | |
| 734 else if (at_top) | |
| 735 corner_style = panel::TOP_ROUNDED; | |
| 736 else if (at_bottom) | |
| 737 corner_style = panel::BOTTOM_ROUNDED; | |
| 738 else | |
| 739 corner_style = panel::NOT_ROUNDED; | |
| 740 panel->SetWindowCornerStyle(corner_style); | |
| 741 } | |
| 742 | |
| 743 gfx::Rect StackedPanelCollection::GetWorkArea() const { | |
| 744 if (panels_.empty()) | |
| 745 return panel_manager_->display_settings_provider()->GetPrimaryWorkArea(); | |
| 746 return panel_manager_->display_settings_provider()->GetWorkAreaMatching( | |
| 747 GetEnclosingBounds()); | |
| 748 } | |
| 749 | |
| 750 int StackedPanelCollection::GetCurrentAvailableTopSpace() const { | |
| 751 gfx::Rect work_area = GetWorkArea(); | |
| 752 if (panels_.empty()) | |
| 753 return work_area.height(); | |
| 754 | |
| 755 int available_space = top_panel()->GetBounds().y() - work_area.y(); | |
| 756 if (available_space < 0) | |
| 757 available_space = 0; | |
| 758 return available_space; | |
| 759 } | |
| 760 | |
| 761 int StackedPanelCollection::GetCurrentAvailableBottomSpace() const { | |
| 762 gfx::Rect work_area = GetWorkArea(); | |
| 763 if (panels_.empty()) | |
| 764 return work_area.height(); | |
| 765 | |
| 766 int available_space = work_area.bottom() - | |
| 767 bottom_panel()->GetBounds().bottom(); | |
| 768 if (available_space < 0) | |
| 769 available_space = 0; | |
| 770 return available_space; | |
| 771 } | |
| 772 | |
| 773 int StackedPanelCollection::GetMaximiumAvailableBottomSpace() const { | |
| 774 gfx::Rect work_area = GetWorkArea(); | |
| 775 if (panels_.empty()) | |
| 776 return work_area.height(); | |
| 777 | |
| 778 int bottom = top_panel()->GetBounds().y(); | |
| 779 for (Panels::const_iterator iter = panels_.begin(); | |
| 780 iter != panels_.end(); iter++) { | |
| 781 Panel* panel = *iter; | |
| 782 // Only the most recently active panel might be active. | |
| 783 if (iter == panels_.begin() && panel->IsActive()) | |
| 784 bottom += panel->GetBounds().height(); | |
| 785 else | |
| 786 bottom += panel::kTitlebarHeight; | |
| 787 } | |
| 788 int available_space = work_area.bottom() - bottom; | |
| 789 if (available_space < 0) | |
| 790 available_space = 0; | |
| 791 return available_space; | |
| 792 } | |
| 793 | |
| 794 NativePanelStackWindow* StackedPanelCollection::GetStackWindowForPanel( | |
| 795 Panel* panel) const { | |
| 796 return secondary_stack_window_ && secondary_stack_window_->HasPanel(panel) ? | |
| 797 secondary_stack_window_ : primary_stack_window_; | |
| 798 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2263863002:
Remove implementation of Panels on OSes other than ChromeOS. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master