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 |