| // Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "window_manager/panels/panel_manager.h" |
| |
| #include <utility> |
| |
| #include "base/logging.h" |
| #include "cros/chromeos_wm_ipc_enums.h" |
| #include "window_manager/atom_cache.h" |
| #include "window_manager/event_consumer_registrar.h" |
| #include "window_manager/motion_event_coalescer.h" |
| #include "window_manager/panels/panel.h" |
| #include "window_manager/panels/panel_bar.h" |
| #include "window_manager/panels/panel_dock.h" |
| #include "window_manager/panels/panel_container.h" |
| #include "window_manager/stacking_manager.h" |
| #include "window_manager/window.h" |
| #include "window_manager/window_manager.h" |
| |
| using std::make_pair; |
| using std::map; |
| using std::pair; |
| using std::set; |
| using std::tr1::shared_ptr; |
| using std::vector; |
| using window_manager::util::FindWithDefault; |
| using window_manager::util::XidStr; |
| |
| namespace window_manager { |
| |
| // Frequency with which we should update the position of dragged panels. |
| static const int kDraggedPanelUpdateMs = 25; |
| |
| // How long should the animation when detaching panels from containers take? |
| static const int kDetachPanelAnimMs = 100; |
| |
| // Chosen because 1280 - 256 = 1024. |
| const int PanelManager::kPanelDockWidth = 256; |
| |
| PanelManager::PanelManager(WindowManager* wm) |
| : wm_(wm), |
| dragged_panel_(NULL), |
| fullscreen_panel_(NULL), |
| dragged_panel_event_coalescer_( |
| new MotionEventCoalescer( |
| wm_->event_loop(), |
| NewPermanentCallback( |
| this, &PanelManager::HandlePeriodicPanelDragMotion), |
| kDraggedPanelUpdateMs)), |
| panel_bar_(new PanelBar(this)), |
| left_panel_dock_( |
| new PanelDock(this, PanelDock::DOCK_TYPE_LEFT, kPanelDockWidth)), |
| right_panel_dock_( |
| new PanelDock(this, PanelDock::DOCK_TYPE_RIGHT, kPanelDockWidth)), |
| saw_map_request_(false), |
| event_consumer_registrar_(new EventConsumerRegistrar(wm_, this)) { |
| event_consumer_registrar_->RegisterForChromeMessages( |
| chromeos::WM_IPC_MESSAGE_WM_SET_PANEL_STATE); |
| event_consumer_registrar_->RegisterForChromeMessages( |
| chromeos::WM_IPC_MESSAGE_WM_NOTIFY_PANEL_DRAGGED); |
| event_consumer_registrar_->RegisterForChromeMessages( |
| chromeos::WM_IPC_MESSAGE_WM_NOTIFY_PANEL_DRAG_COMPLETE); |
| |
| wm_->focus_manager()->RegisterFocusChangeListener(this); |
| |
| RegisterContainer(panel_bar_.get()); |
| RegisterContainer(left_panel_dock_.get()); |
| RegisterContainer(right_panel_dock_.get()); |
| } |
| |
| PanelManager::~PanelManager() { |
| wm_->focus_manager()->UnregisterFocusChangeListener(this); |
| dragged_panel_ = NULL; |
| } |
| |
| bool PanelManager::IsInputWindow(XWindow xid) { |
| return container_input_xids_.count(xid) || panel_input_xids_.count(xid); |
| } |
| |
| void PanelManager::HandleScreenResize() { |
| for (vector<PanelContainer*>::iterator it = containers_.begin(); |
| it != containers_.end(); ++it) { |
| (*it)->HandleScreenResize(); |
| } |
| for (PanelMap::iterator it = panels_.begin(); it != panels_.end(); ++it) |
| it->second->HandleScreenResize(); |
| } |
| |
| bool PanelManager::HandleWindowMapRequest(Window* win) { |
| saw_map_request_ = true; |
| |
| if (win->type() != chromeos::WM_IPC_WINDOW_CHROME_PANEL_CONTENT && |
| win->type() != chromeos::WM_IPC_WINDOW_CHROME_PANEL_TITLEBAR && |
| (!win->transient_for_xid() || !GetPanelByXid(win->transient_for_xid()))) |
| return false; |
| |
| DoInitialSetupForWindow(win); |
| return true; |
| } |
| |
| void PanelManager::HandleWindowMap(Window* win) { |
| if (win->override_redirect()) |
| return; |
| |
| if (win->type() != chromeos::WM_IPC_WINDOW_CHROME_PANEL_CONTENT && |
| win->type() != chromeos::WM_IPC_WINDOW_CHROME_PANEL_TITLEBAR) { |
| // The only non-panel windows that we'll handle are transients |
| // belonging to panels. |
| if (!win->transient_for_xid()) |
| return; |
| |
| Panel* owner_panel = GetPanelByXid(win->transient_for_xid()); |
| if (!owner_panel) { |
| // Maybe its owner is itself a transient for a panel. |
| Window* owner_win = wm_->GetWindow(win->transient_for_xid()); |
| if (owner_win) |
| owner_panel = GetPanelOwningTransientWindow(*owner_win); |
| } |
| if (owner_panel) { |
| transient_xids_to_owners_[win->xid()] = owner_panel; |
| owner_panel->HandleTransientWindowMap(win); |
| if (!win->is_rgba()) |
| win->SetShadowType(Shadow::TYPE_RECTANGULAR); |
| } |
| return; |
| } |
| |
| // Handle initial setup for existing windows for which we never saw a map |
| // request event. |
| if (!saw_map_request_) |
| DoInitialSetupForWindow(win); |
| |
| switch (win->type()) { |
| case chromeos::WM_IPC_WINDOW_CHROME_PANEL_TITLEBAR: |
| // Don't do anything with panel titlebars when they're first |
| // mapped; we'll handle them after we see the corresponding content |
| // window. |
| break; |
| |
| case chromeos::WM_IPC_WINDOW_CHROME_PANEL_CONTENT: { |
| // Resize the titlebar to match the content window's current width. |
| // There's a small chance that we'll constrain the content size in the |
| // Panel c'tor, but this lets us get the titlebar to the right size |
| // before we make both windows visible in the common case. |
| if (!win->type_params().empty()) { |
| Window* titlebar_win = wm_->GetWindow(win->type_params().at(0)); |
| if (titlebar_win) { |
| titlebar_win->Resize( |
| Size(win->client_width(), titlebar_win->client_height()), |
| GRAVITY_NORTHWEST); |
| } |
| } |
| |
| if (win->has_initial_pixmap()) { |
| HandleContentWindowInitialPixmapFetch(win); |
| } else { |
| // If we don't have the window's pixmap yet, defer creating the Panel |
| // object and register to get notified after the pixmap is loaded. |
| event_consumer_registrar_->RegisterForWindowEvents(win->xid()); |
| content_xids_without_initial_pixmaps_.insert(win->xid()); |
| } |
| break; |
| } |
| |
| default: |
| NOTREACHED() << "Unhandled window type " << win->type(); |
| } |
| } |
| |
| void PanelManager::HandleWindowUnmap(Window* win) { |
| if (win->override_redirect()) |
| return; |
| |
| set<XWindow>::iterator content_it = |
| content_xids_without_initial_pixmaps_.find(win->xid()); |
| if (content_it != content_xids_without_initial_pixmaps_.end()) { |
| event_consumer_registrar_->UnregisterForWindowEvents(win->xid()); |
| content_xids_without_initial_pixmaps_.erase(content_it); |
| } |
| |
| Panel* owner_panel = GetPanelOwningTransientWindow(*win); |
| if (owner_panel) { |
| transient_xids_to_owners_.erase(win->xid()); |
| owner_panel->HandleTransientWindowUnmap(win); |
| return; |
| } |
| |
| Panel* panel = GetPanelByWindow(*win); |
| if (!panel) |
| return; |
| |
| PanelContainer* container = GetContainerForPanel(*panel); |
| if (container) |
| RemovePanelFromContainer(panel, container); |
| if (panel == dragged_panel_) |
| HandlePanelDragComplete(panel, true); // removed=true |
| if (panel == fullscreen_panel_) |
| fullscreen_panel_ = NULL; |
| |
| // If the panel was focused, assign the focus to another panel, or |
| // failing that, let the window manager decide what to do with it. |
| if (panel->is_focused()) { |
| XTime timestamp = wm()->GetCurrentTimeFromServer(); |
| if (!TakeFocus(timestamp)) |
| wm_->TakeFocus(timestamp); |
| } |
| |
| vector<XWindow> input_windows; |
| panel->GetInputWindows(&input_windows); |
| for (vector<XWindow>::const_iterator it = input_windows.begin(); |
| it != input_windows.end(); ++it) { |
| CHECK(panel_input_xids_.erase(*it) == 1); |
| } |
| |
| // Clean up any references to this panel in the transient window map. |
| vector<XWindow> orphaned_transient_xids; |
| for (map<XWindow, Panel*>::const_iterator it = |
| transient_xids_to_owners_.begin(); |
| it != transient_xids_to_owners_.end(); ++it) { |
| if (it->second == panel) |
| orphaned_transient_xids.push_back(it->first); |
| } |
| for (vector<XWindow>::const_iterator it = orphaned_transient_xids.begin(); |
| it != orphaned_transient_xids.end(); ++it) { |
| CHECK(transient_xids_to_owners_.erase(*it) == 1); |
| } |
| |
| CHECK(panels_by_titlebar_xid_.erase(panel->titlebar_xid()) == 1); |
| CHECK(panels_.erase(panel->content_xid()) == 1); |
| } |
| |
| void PanelManager::HandleWindowPixmapFetch(Window* win) { |
| set<XWindow>::iterator it = |
| content_xids_without_initial_pixmaps_.find(win->xid()); |
| if (it != content_xids_without_initial_pixmaps_.end()) { |
| event_consumer_registrar_->UnregisterForWindowEvents(win->xid()); |
| content_xids_without_initial_pixmaps_.erase(it); |
| HandleContentWindowInitialPixmapFetch(win); |
| } |
| } |
| |
| void PanelManager::HandleWindowConfigureRequest(Window* win, |
| const Rect& requested_bounds) { |
| if (Panel* owner_panel = GetPanelOwningTransientWindow(*win)) { |
| owner_panel->HandleTransientWindowConfigureRequest(win, requested_bounds); |
| return; |
| } |
| |
| Panel* panel = GetPanelByWindow(*win); |
| if (!panel) |
| return; |
| |
| if (win != panel->content_win()) { |
| LOG(WARNING) << "Ignoring request to configure non-content window " |
| << win->xid_str() << " for panel " << panel->xid_str(); |
| return; |
| } |
| PanelContainer* container = GetContainerForPanel(*panel); |
| if (!container) { |
| LOG(WARNING) << "Ignoring request to configure panel " << panel->xid_str() |
| << " while it's not in a container"; |
| return; |
| } |
| if (panel->is_being_resized_by_user()) { |
| LOG(WARNING) << "Ignoring request to configure panel " << panel->xid_str() |
| << " while it's being manually resized"; |
| win->SendSyntheticConfigureNotify(); |
| return; |
| } |
| |
| if (requested_bounds.size() != panel->content_size()) |
| container->HandlePanelResizeRequest(panel, requested_bounds.size()); |
| else |
| win->SendSyntheticConfigureNotify(); |
| } |
| |
| void PanelManager::HandleButtonPress(XWindow xid, |
| const Point& relative_pos, |
| const Point& absolute_pos, |
| int button, |
| XTime timestamp) { |
| // If this is a container's input window, notify the container. |
| PanelContainer* container = GetContainerOwningInputWindow(xid); |
| if (container) { |
| container->HandleInputWindowButtonPress( |
| xid, relative_pos, absolute_pos, button, timestamp); |
| return; |
| } |
| |
| // If this is a panel's input window, notify the panel. |
| Panel* panel = GetPanelOwningInputWindow(xid); |
| if (panel) { |
| panel->HandleInputWindowButtonPress(xid, relative_pos, button, timestamp); |
| return; |
| } |
| |
| Window* win = wm_->GetWindow(xid); |
| if (!win) |
| return; |
| |
| // If it's a panel's content window, notify the panel's container. |
| panel = GetPanelByWindow(*win); |
| if (panel) { |
| container = GetContainerForPanel(*panel); |
| if (container) |
| container->HandlePanelButtonPress(panel, button, timestamp); |
| return; |
| } |
| |
| panel = GetPanelOwningTransientWindow(*win); |
| if (panel) { |
| panel->HandleTransientWindowButtonPress(win, button, timestamp); |
| return; |
| } |
| } |
| |
| void PanelManager::HandleButtonRelease(XWindow xid, |
| const Point& relative_pos, |
| const Point& absolute_pos, |
| int button, |
| XTime timestamp) { |
| // We only care if button releases happened in container or panel input |
| // windows -- there's no current need to notify containers about button |
| // releases in their panels. |
| PanelContainer* container = GetContainerOwningInputWindow(xid); |
| if (container) { |
| container->HandleInputWindowButtonRelease( |
| xid, relative_pos, absolute_pos, button, timestamp); |
| return; |
| } |
| |
| Panel* panel = GetPanelOwningInputWindow(xid); |
| if (panel) { |
| panel->HandleInputWindowButtonRelease(xid, relative_pos, button, timestamp); |
| return; |
| } |
| } |
| |
| void PanelManager::HandlePointerEnter(XWindow xid, |
| const Point& relative_pos, |
| const Point& absolute_pos, |
| XTime timestamp) { |
| PanelContainer* container = GetContainerOwningInputWindow(xid); |
| if (container) { |
| container->HandleInputWindowPointerEnter( |
| xid, relative_pos, absolute_pos, timestamp); |
| return; |
| } |
| |
| // If it's a panel's titlebar window, notify the panel's container. |
| Window* win = wm_->GetWindow(xid); |
| if (win) { |
| Panel* panel = GetPanelByWindow(*win); |
| if (panel) { |
| container = GetContainerForPanel(*panel); |
| if (container && xid == panel->titlebar_xid()) |
| container->HandlePanelTitlebarPointerEnter(panel, timestamp); |
| return; |
| } |
| } |
| } |
| |
| void PanelManager::HandlePointerLeave(XWindow xid, |
| const Point& relative_pos, |
| const Point& absolute_pos, |
| XTime timestamp) { |
| PanelContainer* container = GetContainerOwningInputWindow(xid); |
| if (container) |
| container->HandleInputWindowPointerLeave( |
| xid, relative_pos, absolute_pos, timestamp); |
| } |
| |
| void PanelManager::HandlePointerMotion(XWindow xid, |
| const Point& relative_pos, |
| const Point& absolute_pos, |
| XTime timestamp) { |
| Panel* panel = GetPanelOwningInputWindow(xid); |
| if (panel) |
| panel->HandleInputWindowPointerMotion(xid, relative_pos); |
| } |
| |
| void PanelManager::HandleChromeMessage(const WmIpc::Message& msg) { |
| switch (msg.type()) { |
| case chromeos::WM_IPC_MESSAGE_WM_SET_PANEL_STATE: { |
| XWindow xid = msg.param(0); |
| Panel* panel = GetPanelByXid(xid); |
| if (!panel) { |
| LOG(WARNING) << "Ignoring WM_SET_PANEL_STATE message for non-panel " |
| << "window " << XidStr(xid); |
| return; |
| } |
| PanelContainer* container = GetContainerForPanel(*panel); |
| if (container) |
| container->HandleSetPanelStateMessage(panel, msg.param(1)); |
| break; |
| } |
| case chromeos::WM_IPC_MESSAGE_WM_NOTIFY_PANEL_DRAGGED: { |
| XWindow xid = msg.param(0); |
| Panel* panel = GetPanelByXid(xid); |
| if (!panel) { |
| LOG(WARNING) << "Ignoring WM_NOTIFY_PANEL_DRAGGED message for " |
| << "non-panel window " << XidStr(xid); |
| return; |
| } |
| if (dragged_panel_ && panel != dragged_panel_) |
| HandlePanelDragComplete(dragged_panel_, false); // removed=false |
| if (panel != dragged_panel_) { |
| dragged_panel_ = panel; |
| panel->HandleDragStart(); |
| } |
| if (!dragged_panel_event_coalescer_->IsRunning()) |
| dragged_panel_event_coalescer_->Start(); |
| // We want the right edge of the panel, but pre-IPC-version-1 Chrome |
| // sends us the left edge of the titlebar instead. |
| Point drag_pos( |
| (wm()->wm_ipc_version() >= 1) ? |
| msg.param(1) : msg.param(1) + panel->titlebar_width(), |
| msg.param(2)); |
| dragged_panel_event_coalescer_->StorePosition(drag_pos); |
| break; |
| } |
| case chromeos::WM_IPC_MESSAGE_WM_NOTIFY_PANEL_DRAG_COMPLETE: { |
| XWindow xid = msg.param(0); |
| Panel* panel = GetPanelByXid(xid); |
| if (!panel) { |
| LOG(WARNING) << "Ignoring WM_NOTIFY_PANEL_DRAG_COMPLETE message for " |
| << "non-panel window " << XidStr(xid); |
| return; |
| } |
| HandlePanelDragComplete(panel, false); // removed=false |
| break; |
| } |
| default: |
| return; |
| } |
| } |
| |
| void PanelManager::HandleClientMessage(XWindow xid, |
| XAtom message_type, |
| const long data[5]) { |
| Window* win = wm_->GetWindow(xid); |
| if (!win) |
| return; |
| |
| if (Panel* owner_panel = GetPanelOwningTransientWindow(*win)) { |
| owner_panel->HandleTransientWindowClientMessage(win, message_type, data); |
| return; |
| } |
| |
| Panel* panel = GetPanelByXid(xid); |
| if (!panel) |
| return; |
| |
| if (message_type == wm_->GetXAtom(ATOM_NET_ACTIVE_WINDOW)) { |
| DLOG(INFO) << "Got _NET_ACTIVE_WINDOW request to focus " << XidStr(xid) |
| << " (requestor says its currently-active window is " |
| << XidStr(data[2]) << "; real active window is " |
| << XidStr(wm_->active_window_xid()) << ")"; |
| if (PanelContainer* container = GetContainerForPanel(*panel)) |
| container->HandleFocusPanelMessage(panel, data[1]); |
| } else if (message_type == wm_->GetXAtom(ATOM_NET_WM_STATE)) { |
| if (panel->content_xid() == xid) { |
| map<XAtom, bool> states; |
| panel->content_win()->ParseWmStateMessage(data, &states); |
| map<XAtom, bool>::const_iterator it = |
| states.find(wm_->GetXAtom(ATOM_NET_WM_STATE_FULLSCREEN)); |
| if (it != states.end()) { |
| bool fullscreen = it->second; |
| DLOG(INFO) << "Panel " << panel->xid_str() << " " |
| << (fullscreen ? "set" : "unset") << " its fullscreen hint"; |
| if (fullscreen) |
| MakePanelFullscreen(panel); |
| else |
| RestoreFullscreenPanel(panel); |
| } |
| } |
| } |
| } |
| |
| void PanelManager::HandleWindowPropertyChange(XWindow xid, XAtom xatom) { |
| Window* win = wm_->GetWindowOrDie(xid); |
| Panel* panel = GetPanelByWindow(*win); |
| DCHECK(panel) << "Got property change for non-panel window " << XidStr(xid); |
| if (!panel || panel->content_win() != win) |
| return; |
| |
| if (xatom == wm_->GetXAtom(ATOM_WM_HINTS)) { |
| if (win->wm_hint_urgent() != panel->is_urgent()) { |
| panel->set_is_urgent(win->wm_hint_urgent()); |
| PanelContainer* container = GetContainerForPanel(*panel); |
| if (container) |
| container->HandlePanelUrgencyChange(panel); |
| } |
| } else if (xatom == wm_->GetXAtom(ATOM_WM_NORMAL_HINTS)) { |
| if (win == panel->content_win()) |
| panel->HandleContentWindowSizeHintsChange(); |
| } else { |
| LOG(DFATAL) << "Got unexpected property " << wm_->GetXAtomName(xatom) |
| << " (" << XidStr(xatom) << ") change for " << win->xid_str(); |
| } |
| } |
| |
| void PanelManager::HandleFocusChange() { |
| // If a fullscreen panel loses the focus, un-fullscreen it. |
| if (fullscreen_panel_ && !fullscreen_panel_->is_focused()) |
| RestoreFullscreenPanel(fullscreen_panel_); |
| } |
| |
| void PanelManager::RegisterAreaChangeListener( |
| PanelManagerAreaChangeListener* listener) { |
| DCHECK(listener); |
| bool added = area_change_listeners_.insert(listener).second; |
| DCHECK(added) << "Listener " << listener << " was already registered"; |
| } |
| |
| void PanelManager::UnregisterAreaChangeListener( |
| PanelManagerAreaChangeListener* listener) { |
| int num_removed = area_change_listeners_.erase(listener); |
| DCHECK_EQ(num_removed, 1) << "Listener " << listener << " wasn't registered"; |
| } |
| |
| void PanelManager::GetArea(int* left_width, int* right_width) const { |
| DCHECK(left_width); |
| DCHECK(right_width); |
| *left_width = |
| left_panel_dock_->is_visible() ? left_panel_dock_->width() : 0; |
| *right_width = |
| right_panel_dock_->is_visible() ? right_panel_dock_->width() : 0; |
| } |
| |
| void PanelManager::HandlePanelResizeByUser(Panel* panel) { |
| DCHECK(panel); |
| if (PanelContainer* container = GetContainerForPanel(*panel)) |
| container->HandlePanelResizeByUser(panel); |
| } |
| |
| void PanelManager::HandleDockVisibilityChange(PanelDock* dock) { |
| for (set<PanelManagerAreaChangeListener*>::const_iterator it = |
| area_change_listeners_.begin(); |
| it != area_change_listeners_.end(); ++it) { |
| (*it)->HandlePanelManagerAreaChange(); |
| } |
| } |
| |
| bool PanelManager::TakeFocus(XTime timestamp) { |
| return panel_bar_->TakeFocus(timestamp) || |
| left_panel_dock_->TakeFocus(timestamp) || |
| right_panel_dock_->TakeFocus(timestamp); |
| } |
| |
| Panel* PanelManager::GetPanelByXid(XWindow xid) { |
| Window* win = wm_->GetWindow(xid); |
| if (!win) |
| return NULL; |
| return GetPanelByWindow(*win); |
| } |
| |
| Panel* PanelManager::GetPanelByWindow(const Window& win) { |
| shared_ptr<Panel> panel = FindWithDefault( |
| panels_, win.xid(), shared_ptr<Panel>()); |
| if (panel.get()) |
| return panel.get(); |
| |
| return FindWithDefault( |
| panels_by_titlebar_xid_, win.xid(), static_cast<Panel*>(NULL)); |
| } |
| |
| Panel* PanelManager::GetPanelOwningTransientWindow(const Window& win) { |
| return FindWithDefault(transient_xids_to_owners_, |
| win.xid(), |
| static_cast<Panel*>(NULL)); |
| } |
| |
| Panel* PanelManager::GetPanelOwningInputWindow(XWindow xid) { |
| return FindWithDefault(panel_input_xids_, xid, static_cast<Panel*>(NULL)); |
| } |
| |
| PanelContainer* PanelManager::GetContainerOwningInputWindow(XWindow xid) { |
| return FindWithDefault( |
| container_input_xids_, xid, static_cast<PanelContainer*>(NULL)); |
| } |
| |
| void PanelManager::RegisterContainer(PanelContainer* container) { |
| vector<XWindow> input_xids; |
| container->GetInputWindows(&input_xids); |
| for (vector<XWindow>::const_iterator it = input_xids.begin(); |
| it != input_xids.end(); ++it) { |
| DLOG(INFO) << "Registering input window " << XidStr(*it) |
| << " for container " << container; |
| CHECK(container_input_xids_.insert(make_pair(*it, container)).second); |
| } |
| containers_.push_back(container); |
| } |
| |
| void PanelManager::DoInitialSetupForWindow(Window* win) { |
| win->SetVisibility(Window::VISIBILITY_HIDDEN); |
| } |
| |
| void PanelManager::HandleContentWindowInitialPixmapFetch(Window* win) { |
| if (win->type_params().empty()) { |
| LOG(WARNING) << "Panel " << win->xid_str() << " is missing type " |
| << "parameter for titlebar window"; |
| return; |
| } |
| Window* titlebar_win = wm_->GetWindow(win->type_params().at(0)); |
| if (!titlebar_win) { |
| LOG(WARNING) << "Unable to find titlebar " |
| << XidStr(win->type_params()[0]) |
| << " for panel " << win->xid_str(); |
| return; |
| } |
| |
| // TODO(derat): Make the second param required after Chrome has been |
| // updated. |
| bool expanded = win->type_params().size() >= 2 ? |
| win->type_params().at(1) : false; |
| DLOG(INFO) << "Adding " << (expanded ? "expanded" : "collapsed") |
| << " panel with content window " << win->xid_str() |
| << " and titlebar window " << titlebar_win->xid_str(); |
| |
| shared_ptr<Panel> panel(new Panel(this, win, titlebar_win, expanded)); |
| panel->SetTitlebarWidth(panel->content_width()); |
| |
| vector<XWindow> input_windows; |
| panel->GetInputWindows(&input_windows); |
| for (vector<XWindow>::const_iterator it = input_windows.begin(); |
| it != input_windows.end(); ++it) { |
| CHECK(panel_input_xids_.insert(make_pair(*it, panel.get())).second); |
| } |
| |
| CHECK(panels_.insert(make_pair(win->xid(), panel)).second); |
| CHECK(panels_by_titlebar_xid_.insert( |
| make_pair(titlebar_win->xid(), panel.get())).second); |
| |
| AddPanelToContainer(panel.get(), |
| panel_bar_.get(), |
| PanelContainer::PANEL_SOURCE_NEW); |
| |
| if (win->wm_state_fullscreen()) |
| MakePanelFullscreen(panel.get()); |
| } |
| |
| void PanelManager::HandlePeriodicPanelDragMotion() { |
| DCHECK(dragged_panel_); |
| if (!dragged_panel_) |
| return; |
| |
| const Point pos = dragged_panel_event_coalescer_->position(); |
| |
| bool container_handled_drag = false; |
| bool panel_was_detached = false; |
| PanelContainer* container = GetContainerForPanel(*dragged_panel_); |
| if (container) { |
| if (container->HandleNotifyPanelDraggedMessage(dragged_panel_, pos)) { |
| container_handled_drag = true; |
| } else { |
| DLOG(INFO) << "Container " << container << " told us to detach panel " |
| << dragged_panel_->xid_str() << " at " << pos; |
| RemovePanelFromContainer(dragged_panel_, container); |
| panel_was_detached = true; |
| } |
| } |
| |
| if (!container_handled_drag) { |
| if (panel_was_detached) { |
| dragged_panel_->SetTitlebarWidth(dragged_panel_->content_width()); |
| dragged_panel_->StackAtTopOfLayer(StackingManager::LAYER_DRAGGED_PANEL); |
| } |
| |
| // Offer the panel to all of the containers. If we find one that wants |
| // it, attach it; otherwise we just move the panel to the dragged location. |
| bool panel_was_reattached = false; |
| for (vector<PanelContainer*>::iterator it = containers_.begin(); |
| it != containers_.end(); ++it) { |
| if ((*it)->ShouldAddDraggedPanel(dragged_panel_, pos)) { |
| DLOG(INFO) << "Container " << *it << " told us to attach panel " |
| << dragged_panel_->xid_str() << " at " << pos; |
| AddPanelToContainer(dragged_panel_, |
| *it, |
| PanelContainer::PANEL_SOURCE_DRAGGED); |
| CHECK((*it)->HandleNotifyPanelDraggedMessage(dragged_panel_, pos)); |
| panel_was_reattached = true; |
| break; |
| } |
| } |
| if (!panel_was_reattached) { |
| dragged_panel_->Move(pos, panel_was_detached ? kDetachPanelAnimMs : 0); |
| } |
| } |
| } |
| |
| void PanelManager::HandlePanelDragComplete(Panel* panel, bool removed) { |
| DCHECK(panel); |
| DCHECK(dragged_panel_ == panel); |
| if (dragged_panel_ != panel) |
| return; |
| |
| panel->HandleDragEnd(); |
| |
| if (dragged_panel_event_coalescer_->IsRunning()) |
| dragged_panel_event_coalescer_->Stop(); |
| dragged_panel_ = NULL; |
| |
| if (!removed) { |
| PanelContainer* container = GetContainerForPanel(*panel); |
| if (container) { |
| container->HandleNotifyPanelDragCompleteMessage(panel); |
| } else { |
| DLOG(INFO) << "Attaching dropped panel " << panel->xid_str() |
| << " to panel bar"; |
| AddPanelToContainer(panel, |
| panel_bar_.get(), |
| PanelContainer::PANEL_SOURCE_DROPPED); |
| } |
| } |
| } |
| |
| void PanelManager::AddPanelToContainer(Panel* panel, |
| PanelContainer* container, |
| PanelContainer::PanelSource source) { |
| DCHECK(GetContainerForPanel(*panel) == NULL); |
| CHECK(containers_by_panel_.insert(make_pair(panel, container)).second); |
| container->AddPanel(panel, source); |
| } |
| |
| void PanelManager::RemovePanelFromContainer(Panel* panel, |
| PanelContainer* container) { |
| DCHECK(GetContainerForPanel(*panel) == container); |
| CHECK(containers_by_panel_.erase(panel) == static_cast<size_t>(1)); |
| container->RemovePanel(panel); |
| panel->SetResizable(false); |
| panel->SetShadowOpacity(1.0, kDetachPanelAnimMs); |
| panel->SetExpandedState(true); |
| } |
| |
| void PanelManager::MakePanelFullscreen(Panel* panel) { |
| DCHECK(panel); |
| if (panel->is_fullscreen()) { |
| LOG(WARNING) << "Ignoring request to fullscreen already-fullscreen " |
| << "panel " << panel->xid_str(); |
| return; |
| } |
| |
| // If there's already another fullscreen panel, unfullscreen it. |
| if (fullscreen_panel_) |
| RestoreFullscreenPanel(fullscreen_panel_); |
| DCHECK(!fullscreen_panel_); |
| |
| panel->SetFullscreenState(true); |
| fullscreen_panel_ = panel; |
| } |
| |
| void PanelManager::RestoreFullscreenPanel(Panel* panel) { |
| DCHECK(panel); |
| if (!panel->is_fullscreen()) { |
| LOG(WARNING) << "Ignoring request to restore non-fullscreen panel " |
| << panel->xid_str(); |
| return; |
| } |
| |
| panel->SetFullscreenState(false); |
| if (fullscreen_panel_ == panel) |
| fullscreen_panel_ = NULL; |
| } |
| |
| } // namespace window_manager |
