1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ui/views/window/non_client_view.h" 6 7 #include "ui/accessibility/ax_view_state.h" 8 #include "ui/base/hit_test.h" 9 #include "ui/gfx/rect_conversions.h" 10 #include "ui/views/rect_based_targeting_utils.h" 11 #include "ui/views/view_targeter.h" 12 #include "ui/views/widget/root_view.h" 13 #include "ui/views/widget/widget.h" 14 #include "ui/views/window/client_view.h" 15 16 namespace views { 17 18 // static 19 const char NonClientFrameView::kViewClassName[] = 20 "ui/views/window/NonClientFrameView"; 21 22 const char NonClientView::kViewClassName[] = 23 "ui/views/window/NonClientView"; 24 25 // The frame view and the client view are always at these specific indices, 26 // because the RootView message dispatch sends messages to items higher in the 27 // z-order first and we always want the client view to have first crack at 28 // handling mouse messages. 29 static const int kFrameViewIndex = 0; 30 static const int kClientViewIndex = 1; 31 // The overlay view is always on top (index == child_count() - 1). 32 33 //////////////////////////////////////////////////////////////////////////////// 34 // NonClientView, public: 35 36 NonClientView::NonClientView() 37 : client_view_(NULL), 38 overlay_view_(NULL) { 39 SetEventTargeter( 40 scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this))); 41 } 42 43 NonClientView::~NonClientView() { 44 // This value may have been reset before the window hierarchy shuts down, 45 // so we need to manually remove it. 46 RemoveChildView(frame_view_.get()); 47 } 48 49 void NonClientView::SetFrameView(NonClientFrameView* frame_view) { 50 // See comment in header about ownership. 51 frame_view->set_owned_by_client(); 52 if (frame_view_.get()) 53 RemoveChildView(frame_view_.get()); 54 frame_view_.reset(frame_view); 55 if (parent()) 56 AddChildViewAt(frame_view_.get(), kFrameViewIndex); 57 } 58 59 void NonClientView::SetOverlayView(View* view) { 60 if (overlay_view_) 61 RemoveChildView(overlay_view_); 62 63 if (!view) 64 return; 65 66 overlay_view_ = view; 67 if (parent()) 68 AddChildView(overlay_view_); 69 } 70 71 bool NonClientView::CanClose() { 72 return client_view_->CanClose(); 73 } 74 75 void NonClientView::WindowClosing() { 76 client_view_->WidgetClosing(); 77 } 78 79 void NonClientView::UpdateFrame() { 80 Widget* widget = GetWidget(); 81 SetFrameView(widget->CreateNonClientFrameView()); 82 widget->ThemeChanged(); 83 Layout(); 84 SchedulePaint(); 85 } 86 87 void NonClientView::SetInactiveRenderingDisabled(bool disable) { 88 frame_view_->SetInactiveRenderingDisabled(disable); 89 } 90 91 gfx::Rect NonClientView::GetWindowBoundsForClientBounds( 92 const gfx::Rect client_bounds) const { 93 return frame_view_->GetWindowBoundsForClientBounds(client_bounds); 94 } 95 96 int NonClientView::NonClientHitTest(const gfx::Point& point) { 97 // The NonClientFrameView is responsible for also asking the ClientView. 98 return frame_view_->NonClientHitTest(point); 99 } 100 101 void NonClientView::GetWindowMask(const gfx::Size& size, 102 gfx::Path* window_mask) { 103 frame_view_->GetWindowMask(size, window_mask); 104 } 105 106 void NonClientView::ResetWindowControls() { 107 frame_view_->ResetWindowControls(); 108 } 109 110 void NonClientView::UpdateWindowIcon() { 111 frame_view_->UpdateWindowIcon(); 112 } 113 114 void NonClientView::UpdateWindowTitle() { 115 frame_view_->UpdateWindowTitle(); 116 } 117 118 void NonClientView::SizeConstraintsChanged() { 119 frame_view_->SizeConstraintsChanged(); 120 } 121 122 void NonClientView::LayoutFrameView() { 123 // First layout the NonClientFrameView, which determines the size of the 124 // ClientView... 125 frame_view_->SetBounds(0, 0, width(), height()); 126 127 // We need to manually call Layout here because layout for the frame view can 128 // change independently of the bounds changing - e.g. after the initial 129 // display of the window the metrics of the native window controls can change, 130 // which does not change the bounds of the window but requires a re-layout to 131 // trigger a repaint. We override OnBoundsChanged() for the NonClientFrameView 132 // to do nothing so that SetBounds above doesn't cause Layout to be called 133 // twice. 134 frame_view_->Layout(); 135 } 136 137 void NonClientView::SetAccessibleName(const base::string16& name) { 138 accessible_name_ = name; 139 } 140 141 //////////////////////////////////////////////////////////////////////////////// 142 // NonClientView, View overrides: 143 144 gfx::Size NonClientView::GetPreferredSize() const { 145 // TODO(pkasting): This should probably be made to look similar to 146 // GetMinimumSize() below. This will require implementing GetPreferredSize() 147 // better in the various frame views. 148 gfx::Rect client_bounds(gfx::Point(), client_view_->GetPreferredSize()); 149 return GetWindowBoundsForClientBounds(client_bounds).size(); 150 } 151 152 gfx::Size NonClientView::GetMinimumSize() const { 153 return frame_view_->GetMinimumSize(); 154 } 155 156 gfx::Size NonClientView::GetMaximumSize() const { 157 return frame_view_->GetMaximumSize(); 158 } 159 160 void NonClientView::Layout() { 161 LayoutFrameView(); 162 163 // Then layout the ClientView, using those bounds. 164 client_view_->SetBoundsRect(frame_view_->GetBoundsForClientView()); 165 166 // We need to manually call Layout on the ClientView as well for the same 167 // reason as above. 168 client_view_->Layout(); 169 170 if (overlay_view_ && overlay_view_->visible()) 171 overlay_view_->SetBoundsRect(GetLocalBounds()); 172 } 173 174 void NonClientView::ViewHierarchyChanged( 175 const ViewHierarchyChangedDetails& details) { 176 // Add our two child views here as we are added to the Widget so that if we 177 // are subsequently resized all the parent-child relationships are 178 // established. 179 if (details.is_add && GetWidget() && details.child == this) { 180 AddChildViewAt(frame_view_.get(), kFrameViewIndex); 181 AddChildViewAt(client_view_, kClientViewIndex); 182 if (overlay_view_) 183 AddChildView(overlay_view_); 184 } 185 } 186 187 void NonClientView::GetAccessibleState(ui::AXViewState* state) { 188 state->role = ui::AX_ROLE_CLIENT; 189 state->name = accessible_name_; 190 } 191 192 const char* NonClientView::GetClassName() const { 193 return kViewClassName; 194 } 195 196 View* NonClientView::GetTooltipHandlerForPoint(const gfx::Point& point) { 197 // The same logic as for |TargetForRect()| applies here. 198 if (frame_view_->parent() == this) { 199 // During the reset of the frame_view_ it's possible to be in this code 200 // after it's been removed from the view hierarchy but before it's been 201 // removed from the NonClientView. 202 gfx::Point point_in_child_coords(point); 203 View::ConvertPointToTarget(this, frame_view_.get(), &point_in_child_coords); 204 View* handler = 205 frame_view_->GetTooltipHandlerForPoint(point_in_child_coords); 206 if (handler) 207 return handler; 208 } 209 210 return View::GetTooltipHandlerForPoint(point); 211 } 212 213 View* NonClientView::TargetForRect(View* root, const gfx::Rect& rect) { 214 CHECK_EQ(root, this); 215 216 if (!UsePointBasedTargeting(rect)) 217 return ViewTargeterDelegate::TargetForRect(root, rect); 218 219 // Because of the z-ordering of our child views (the client view is positioned 220 // over the non-client frame view, if the client view ever overlaps the frame 221 // view visually (as it does for the browser window), then it will eat 222 // events for the window controls. We override this method here so that we can 223 // detect this condition and re-route the events to the non-client frame view. 224 // The assumption is that the frame view's implementation of HitTest will only 225 // return true for area not occupied by the client view. 226 if (frame_view_->parent() == this) { 227 // During the reset of the frame_view_ it's possible to be in this code 228 // after it's been removed from the view hierarchy but before it's been 229 // removed from the NonClientView. 230 gfx::RectF rect_in_child_coords_f(rect); 231 View::ConvertRectToTarget(this, frame_view_.get(), &rect_in_child_coords_f); 232 gfx::Rect rect_in_child_coords = gfx::ToEnclosingRect( 233 rect_in_child_coords_f); 234 if (frame_view_->HitTestRect(rect_in_child_coords)) 235 return frame_view_->GetEventHandlerForRect(rect_in_child_coords); 236 } 237 238 return ViewTargeterDelegate::TargetForRect(root, rect); 239 } 240 241 //////////////////////////////////////////////////////////////////////////////// 242 // NonClientFrameView, public: 243 244 NonClientFrameView::~NonClientFrameView() { 245 } 246 247 void NonClientFrameView::SetInactiveRenderingDisabled(bool disable) { 248 if (inactive_rendering_disabled_ == disable) 249 return; 250 251 bool should_paint_as_active_old = ShouldPaintAsActive(); 252 inactive_rendering_disabled_ = disable; 253 254 // The widget schedules a paint when the activation changes. 255 if (should_paint_as_active_old != ShouldPaintAsActive()) 256 SchedulePaint(); 257 } 258 259 bool NonClientFrameView::ShouldPaintAsActive() const { 260 return inactive_rendering_disabled_ || GetWidget()->IsActive(); 261 } 262 263 int NonClientFrameView::GetHTComponentForFrame(const gfx::Point& point, 264 int top_resize_border_height, 265 int resize_border_thickness, 266 int top_resize_corner_height, 267 int resize_corner_width, 268 bool can_resize) { 269 // Tricky: In XP, native behavior is to return HTTOPLEFT and HTTOPRIGHT for 270 // a |resize_corner_size|-length strip of both the side and top borders, but 271 // only to return HTBOTTOMLEFT/HTBOTTOMRIGHT along the bottom border + corner 272 // (not the side border). Vista goes further and doesn't return these on any 273 // of the side borders. We allow callers to match either behavior. 274 int component; 275 if (point.x() < resize_border_thickness) { 276 if (point.y() < top_resize_corner_height) 277 component = HTTOPLEFT; 278 else if (point.y() >= (height() - resize_border_thickness)) 279 component = HTBOTTOMLEFT; 280 else 281 component = HTLEFT; 282 } else if (point.x() >= (width() - resize_border_thickness)) { 283 if (point.y() < top_resize_corner_height) 284 component = HTTOPRIGHT; 285 else if (point.y() >= (height() - resize_border_thickness)) 286 component = HTBOTTOMRIGHT; 287 else 288 component = HTRIGHT; 289 } else if (point.y() < top_resize_border_height) { 290 if (point.x() < resize_corner_width) 291 component = HTTOPLEFT; 292 else if (point.x() >= (width() - resize_corner_width)) 293 component = HTTOPRIGHT; 294 else 295 component = HTTOP; 296 } else if (point.y() >= (height() - resize_border_thickness)) { 297 if (point.x() < resize_corner_width) 298 component = HTBOTTOMLEFT; 299 else if (point.x() >= (width() - resize_corner_width)) 300 component = HTBOTTOMRIGHT; 301 else 302 component = HTBOTTOM; 303 } else { 304 return HTNOWHERE; 305 } 306 307 // If the window can't be resized, there are no resize boundaries, just 308 // window borders. 309 return can_resize ? component : HTBORDER; 310 } 311 312 //////////////////////////////////////////////////////////////////////////////// 313 // NonClientFrameView, protected: 314 315 void NonClientFrameView::GetAccessibleState(ui::AXViewState* state) { 316 state->role = ui::AX_ROLE_CLIENT; 317 } 318 319 const char* NonClientFrameView::GetClassName() const { 320 return kViewClassName; 321 } 322 323 void NonClientFrameView::OnBoundsChanged(const gfx::Rect& previous_bounds) { 324 // Overridden to do nothing. The NonClientView manually calls Layout on the 325 // FrameView when it is itself laid out, see comment in NonClientView::Layout. 326 } 327 328 NonClientFrameView::NonClientFrameView() : inactive_rendering_disabled_(false) { 329 SetEventTargeter( 330 scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this))); 331 } 332 333 // ViewTargeterDelegate: 334 bool NonClientFrameView::DoesIntersectRect(const View* target, 335 const gfx::Rect& rect) const { 336 CHECK_EQ(target, this); 337 338 // For the default case, we assume the non-client frame view never overlaps 339 // the client view. 340 return !GetWidget()->client_view()->bounds().Intersects(rect); 341 } 342 343 } // namespace views 344