| 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 "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 void NonClientFrameView::GetAccessibleState(ui::AXViewState* state) { | |
| 313 state->role = ui::AX_ROLE_CLIENT; | |
| 314 } | |
| 315 | |
| 316 const char* NonClientFrameView::GetClassName() const { | |
| 317 return kViewClassName; | |
| 318 } | |
| 319 | |
| 320 //////////////////////////////////////////////////////////////////////////////// | |
| 321 // NonClientFrameView, protected: | |
| 322 | |
| 323 NonClientFrameView::NonClientFrameView() : inactive_rendering_disabled_(false) { | |
| 324 SetEventTargeter( | |
| 325 scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this))); | |
| 326 } | |
| 327 | |
| 328 // ViewTargeterDelegate: | |
| 329 bool NonClientFrameView::DoesIntersectRect(const View* target, | |
| 330 const gfx::Rect& rect) const { | |
| 331 CHECK_EQ(target, this); | |
| 332 | |
| 333 // For the default case, we assume the non-client frame view never overlaps | |
| 334 // the client view. | |
| 335 return !GetWidget()->client_view()->bounds().Intersects(rect); | |
| 336 } | |
| 337 | |
| 338 void NonClientFrameView::OnBoundsChanged(const gfx::Rect& previous_bounds) { | |
| 339 // Overridden to do nothing. The NonClientView manually calls Layout on the | |
| 340 // FrameView when it is itself laid out, see comment in NonClientView::Layout. | |
| 341 } | |
| 342 | |
| 343 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
