| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2009 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/views/default_non_client_view.h" | |
| 6 | |
| 7 #include "base/win_util.h" | |
| 8 #include "chrome/common/gfx/path.h" | |
| 9 #include "chrome/common/gfx/chrome_font.h" | |
| 10 #include "chrome/common/resource_bundle.h" | |
| 11 #include "chrome/common/win_util.h" | |
| 12 #include "chrome/views/client_view.h" | |
| 13 #include "grit/theme_resources.h" | |
| 14 | |
| 15 namespace views { | |
| 16 | |
| 17 // An enumeration of bitmap resources used by this window. | |
| 18 enum { | |
| 19 FRAME_PART_BITMAP_FIRST = 0, // Must be first. | |
| 20 | |
| 21 // Window Controls. | |
| 22 FRAME_CLOSE_BUTTON_ICON, | |
| 23 FRAME_CLOSE_BUTTON_ICON_H, | |
| 24 FRAME_CLOSE_BUTTON_ICON_P, | |
| 25 FRAME_CLOSE_BUTTON_ICON_SA, | |
| 26 FRAME_CLOSE_BUTTON_ICON_SA_H, | |
| 27 FRAME_CLOSE_BUTTON_ICON_SA_P, | |
| 28 FRAME_RESTORE_BUTTON_ICON, | |
| 29 FRAME_RESTORE_BUTTON_ICON_H, | |
| 30 FRAME_RESTORE_BUTTON_ICON_P, | |
| 31 FRAME_MAXIMIZE_BUTTON_ICON, | |
| 32 FRAME_MAXIMIZE_BUTTON_ICON_H, | |
| 33 FRAME_MAXIMIZE_BUTTON_ICON_P, | |
| 34 FRAME_MINIMIZE_BUTTON_ICON, | |
| 35 FRAME_MINIMIZE_BUTTON_ICON_H, | |
| 36 FRAME_MINIMIZE_BUTTON_ICON_P, | |
| 37 | |
| 38 // Window Frame Border. | |
| 39 FRAME_BOTTOM_EDGE, | |
| 40 FRAME_BOTTOM_LEFT_CORNER, | |
| 41 FRAME_BOTTOM_RIGHT_CORNER, | |
| 42 FRAME_LEFT_EDGE, | |
| 43 FRAME_RIGHT_EDGE, | |
| 44 FRAME_TOP_EDGE, | |
| 45 FRAME_TOP_LEFT_CORNER, | |
| 46 FRAME_TOP_RIGHT_CORNER, | |
| 47 | |
| 48 // Client Edge Border. | |
| 49 FRAME_CLIENT_EDGE_TOP_LEFT, | |
| 50 FRAME_CLIENT_EDGE_TOP, | |
| 51 FRAME_CLIENT_EDGE_TOP_RIGHT, | |
| 52 FRAME_CLIENT_EDGE_RIGHT, | |
| 53 FRAME_CLIENT_EDGE_BOTTOM_RIGHT, | |
| 54 FRAME_CLIENT_EDGE_BOTTOM, | |
| 55 FRAME_CLIENT_EDGE_BOTTOM_LEFT, | |
| 56 FRAME_CLIENT_EDGE_LEFT, | |
| 57 | |
| 58 FRAME_PART_BITMAP_COUNT // Must be last. | |
| 59 }; | |
| 60 | |
| 61 class ActiveWindowResources : public WindowResources { | |
| 62 public: | |
| 63 ActiveWindowResources() { | |
| 64 InitClass(); | |
| 65 } | |
| 66 virtual ~ActiveWindowResources() { | |
| 67 } | |
| 68 | |
| 69 // WindowResources implementation: | |
| 70 virtual SkBitmap* GetPartBitmap(FramePartBitmap part) const { | |
| 71 return standard_frame_bitmaps_[part]; | |
| 72 } | |
| 73 | |
| 74 private: | |
| 75 static void InitClass() { | |
| 76 static bool initialized = false; | |
| 77 if (!initialized) { | |
| 78 static const int kFramePartBitmapIds[] = { | |
| 79 0, | |
| 80 IDR_CLOSE, IDR_CLOSE_H, IDR_CLOSE_P, | |
| 81 IDR_CLOSE_SA, IDR_CLOSE_SA_H, IDR_CLOSE_SA_P, | |
| 82 IDR_RESTORE, IDR_RESTORE_H, IDR_RESTORE_P, | |
| 83 IDR_MAXIMIZE, IDR_MAXIMIZE_H, IDR_MAXIMIZE_P, | |
| 84 IDR_MINIMIZE, IDR_MINIMIZE_H, IDR_MINIMIZE_P, | |
| 85 IDR_WINDOW_BOTTOM_CENTER, IDR_WINDOW_BOTTOM_LEFT_CORNER, | |
| 86 IDR_WINDOW_BOTTOM_RIGHT_CORNER, IDR_WINDOW_LEFT_SIDE, | |
| 87 IDR_WINDOW_RIGHT_SIDE, IDR_WINDOW_TOP_CENTER, | |
| 88 IDR_WINDOW_TOP_LEFT_CORNER, IDR_WINDOW_TOP_RIGHT_CORNER, | |
| 89 IDR_APP_TOP_LEFT, IDR_APP_TOP_CENTER, IDR_APP_TOP_RIGHT, | |
| 90 IDR_CONTENT_RIGHT_SIDE, IDR_CONTENT_BOTTOM_RIGHT_CORNER, | |
| 91 IDR_CONTENT_BOTTOM_CENTER, IDR_CONTENT_BOTTOM_LEFT_CORNER, | |
| 92 IDR_CONTENT_LEFT_SIDE, | |
| 93 0 | |
| 94 }; | |
| 95 | |
| 96 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); | |
| 97 for (int i = 0; i < FRAME_PART_BITMAP_COUNT; ++i) { | |
| 98 int id = kFramePartBitmapIds[i]; | |
| 99 if (id != 0) | |
| 100 standard_frame_bitmaps_[i] = rb.GetBitmapNamed(id); | |
| 101 } | |
| 102 initialized = true; | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 static SkBitmap* standard_frame_bitmaps_[FRAME_PART_BITMAP_COUNT]; | |
| 107 static ChromeFont title_font_; | |
| 108 | |
| 109 DISALLOW_EVIL_CONSTRUCTORS(ActiveWindowResources); | |
| 110 }; | |
| 111 | |
| 112 class InactiveWindowResources : public WindowResources { | |
| 113 public: | |
| 114 InactiveWindowResources() { | |
| 115 InitClass(); | |
| 116 } | |
| 117 virtual ~InactiveWindowResources() { | |
| 118 } | |
| 119 | |
| 120 // WindowResources implementation: | |
| 121 virtual SkBitmap* GetPartBitmap(FramePartBitmap part) const { | |
| 122 return standard_frame_bitmaps_[part]; | |
| 123 } | |
| 124 | |
| 125 private: | |
| 126 static void InitClass() { | |
| 127 static bool initialized = false; | |
| 128 if (!initialized) { | |
| 129 static const int kFramePartBitmapIds[] = { | |
| 130 0, | |
| 131 IDR_CLOSE, IDR_CLOSE_H, IDR_CLOSE_P, | |
| 132 IDR_CLOSE_SA, IDR_CLOSE_SA_H, IDR_CLOSE_SA_P, | |
| 133 IDR_RESTORE, IDR_RESTORE_H, IDR_RESTORE_P, | |
| 134 IDR_MAXIMIZE, IDR_MAXIMIZE_H, IDR_MAXIMIZE_P, | |
| 135 IDR_MINIMIZE, IDR_MINIMIZE_H, IDR_MINIMIZE_P, | |
| 136 IDR_DEWINDOW_BOTTOM_CENTER, IDR_DEWINDOW_BOTTOM_LEFT_CORNER, | |
| 137 IDR_DEWINDOW_BOTTOM_RIGHT_CORNER, IDR_DEWINDOW_LEFT_SIDE, | |
| 138 IDR_DEWINDOW_RIGHT_SIDE, IDR_DEWINDOW_TOP_CENTER, | |
| 139 IDR_DEWINDOW_TOP_LEFT_CORNER, IDR_DEWINDOW_TOP_RIGHT_CORNER, | |
| 140 IDR_APP_TOP_LEFT, IDR_APP_TOP_CENTER, IDR_APP_TOP_RIGHT, | |
| 141 IDR_CONTENT_RIGHT_SIDE, IDR_CONTENT_BOTTOM_RIGHT_CORNER, | |
| 142 IDR_CONTENT_BOTTOM_CENTER, IDR_CONTENT_BOTTOM_LEFT_CORNER, | |
| 143 IDR_CONTENT_LEFT_SIDE, | |
| 144 0 | |
| 145 }; | |
| 146 | |
| 147 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); | |
| 148 for (int i = 0; i < FRAME_PART_BITMAP_COUNT; ++i) { | |
| 149 int id = kFramePartBitmapIds[i]; | |
| 150 if (id != 0) | |
| 151 standard_frame_bitmaps_[i] = rb.GetBitmapNamed(id); | |
| 152 } | |
| 153 initialized = true; | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 static SkBitmap* standard_frame_bitmaps_[FRAME_PART_BITMAP_COUNT]; | |
| 158 | |
| 159 DISALLOW_EVIL_CONSTRUCTORS(InactiveWindowResources); | |
| 160 }; | |
| 161 | |
| 162 // static | |
| 163 SkBitmap* ActiveWindowResources::standard_frame_bitmaps_[]; | |
| 164 SkBitmap* InactiveWindowResources::standard_frame_bitmaps_[]; | |
| 165 | |
| 166 // static | |
| 167 WindowResources* DefaultNonClientView::active_resources_ = NULL; | |
| 168 WindowResources* DefaultNonClientView::inactive_resources_ = NULL; | |
| 169 ChromeFont DefaultNonClientView::title_font_; | |
| 170 | |
| 171 namespace { | |
| 172 // The frame border is only visible in restored mode and is hardcoded to 4 px on | |
| 173 // each side regardless of the system window border size. | |
| 174 const int kFrameBorderThickness = 4; | |
| 175 // Various edges of the frame border have a 1 px shadow along their edges; in a | |
| 176 // few cases we shift elements based on this amount for visual appeal. | |
| 177 const int kFrameShadowThickness = 1; | |
| 178 // While resize areas on Windows are normally the same size as the window | |
| 179 // borders, our top area is shrunk by 1 px to make it easier to move the window | |
| 180 // around with our thinner top grabbable strip. (Incidentally, our side and | |
| 181 // bottom resize areas don't match the frame border thickness either -- they | |
| 182 // span the whole nonclient area, so there's no "dead zone" for the mouse.) | |
| 183 const int kTopResizeAdjust = 1; | |
| 184 // In the window corners, the resize areas don't actually expand bigger, but the | |
| 185 // 16 px at the end of each edge triggers diagonal resizing. | |
| 186 const int kResizeAreaCornerSize = 16; | |
| 187 // The titlebar never shrinks to less than 18 px tall, plus the height of the | |
| 188 // frame border and any bottom edge. | |
| 189 const int kTitlebarMinimumHeight = 18; | |
| 190 // The icon is inset 2 px from the left frame border. | |
| 191 const int kIconLeftSpacing = 2; | |
| 192 // The icon takes up 16/25th of the available titlebar height. (This is | |
| 193 // expressed as two ints to avoid precision losses leading to off-by-one pixel | |
| 194 // errors.) | |
| 195 const int kIconHeightFractionNumerator = 16; | |
| 196 const int kIconHeightFractionDenominator = 25; | |
| 197 // The icon never shrinks below 16 px on a side. | |
| 198 const int kIconMinimumSize = 16; | |
| 199 // Because our frame border has a different "3D look" than Windows', with a less | |
| 200 // cluttered top edge, we need to shift the icon up by 1 px in restored mode so | |
| 201 // it looks more centered. | |
| 202 const int kIconRestoredAdjust = 1; | |
| 203 // There is a 4 px gap between the icon and the title text. | |
| 204 const int kIconTitleSpacing = 4; | |
| 205 // The title text starts 2 px below the bottom of the top frame border. | |
| 206 const int kTitleTopSpacing = 2; | |
| 207 // There is a 5 px gap between the title text and the caption buttons. | |
| 208 const int kTitleCaptionSpacing = 5; | |
| 209 // The caption buttons are always drawn 1 px down from the visible top of the | |
| 210 // window (the true top in restored mode, or the top of the screen in maximized | |
| 211 // mode). | |
| 212 const int kCaptionTopSpacing = 1; | |
| 213 } | |
| 214 | |
| 215 /////////////////////////////////////////////////////////////////////////////// | |
| 216 // DefaultNonClientView, public: | |
| 217 | |
| 218 DefaultNonClientView::DefaultNonClientView( | |
| 219 CustomFrameWindow* container) | |
| 220 : NonClientView(), | |
| 221 client_view_(NULL), | |
| 222 close_button_(new Button), | |
| 223 restore_button_(new Button), | |
| 224 maximize_button_(new Button), | |
| 225 minimize_button_(new Button), | |
| 226 system_menu_button_(new Button), | |
| 227 should_show_minmax_buttons_(false), | |
| 228 container_(container) { | |
| 229 InitClass(); | |
| 230 WindowResources* resources = active_resources_; | |
| 231 | |
| 232 // Close button images will be set in LayoutWindowControls(). | |
| 233 close_button_->SetListener(this, -1); | |
| 234 AddChildView(close_button_); | |
| 235 | |
| 236 restore_button_->SetImage(Button::BS_NORMAL, | |
| 237 resources->GetPartBitmap(FRAME_RESTORE_BUTTON_ICON)); | |
| 238 restore_button_->SetImage(Button::BS_HOT, | |
| 239 resources->GetPartBitmap(FRAME_RESTORE_BUTTON_ICON_H)); | |
| 240 restore_button_->SetImage(Button::BS_PUSHED, | |
| 241 resources->GetPartBitmap(FRAME_RESTORE_BUTTON_ICON_P)); | |
| 242 restore_button_->SetListener(this, -1); | |
| 243 AddChildView(restore_button_); | |
| 244 | |
| 245 maximize_button_->SetImage(Button::BS_NORMAL, | |
| 246 resources->GetPartBitmap(FRAME_MAXIMIZE_BUTTON_ICON)); | |
| 247 maximize_button_->SetImage(Button::BS_HOT, | |
| 248 resources->GetPartBitmap(FRAME_MAXIMIZE_BUTTON_ICON_H)); | |
| 249 maximize_button_->SetImage(Button::BS_PUSHED, | |
| 250 resources->GetPartBitmap(FRAME_MAXIMIZE_BUTTON_ICON_P)); | |
| 251 maximize_button_->SetListener(this, -1); | |
| 252 AddChildView(maximize_button_); | |
| 253 | |
| 254 minimize_button_->SetImage(Button::BS_NORMAL, | |
| 255 resources->GetPartBitmap(FRAME_MINIMIZE_BUTTON_ICON)); | |
| 256 minimize_button_->SetImage(Button::BS_HOT, | |
| 257 resources->GetPartBitmap(FRAME_MINIMIZE_BUTTON_ICON_H)); | |
| 258 minimize_button_->SetImage(Button::BS_PUSHED, | |
| 259 resources->GetPartBitmap(FRAME_MINIMIZE_BUTTON_ICON_P)); | |
| 260 minimize_button_->SetListener(this, -1); | |
| 261 AddChildView(minimize_button_); | |
| 262 | |
| 263 should_show_minmax_buttons_ = container->window_delegate()->CanMaximize(); | |
| 264 | |
| 265 AddChildView(system_menu_button_); | |
| 266 } | |
| 267 | |
| 268 DefaultNonClientView::~DefaultNonClientView() { | |
| 269 } | |
| 270 | |
| 271 /////////////////////////////////////////////////////////////////////////////// | |
| 272 // DefaultNonClientView, CustomFrameWindow::NonClientView implementation: | |
| 273 | |
| 274 gfx::Rect DefaultNonClientView::CalculateClientAreaBounds(int width, | |
| 275 int height) const { | |
| 276 int top_height = NonClientTopBorderHeight(); | |
| 277 int border_thickness = NonClientBorderThickness(); | |
| 278 return gfx::Rect(border_thickness, top_height, | |
| 279 std::max(0, width - (2 * border_thickness)), | |
| 280 std::max(0, height - top_height - border_thickness)); | |
| 281 } | |
| 282 | |
| 283 gfx::Size DefaultNonClientView::CalculateWindowSizeForClientSize( | |
| 284 int width, | |
| 285 int height) const { | |
| 286 int border_thickness = NonClientBorderThickness(); | |
| 287 return gfx::Size(width + (2 * border_thickness), | |
| 288 height + NonClientTopBorderHeight() + border_thickness); | |
| 289 } | |
| 290 | |
| 291 gfx::Point DefaultNonClientView::GetSystemMenuPoint() const { | |
| 292 gfx::Point system_menu_point(FrameBorderThickness(), | |
| 293 NonClientTopBorderHeight() - BottomEdgeThicknessWithinNonClientHeight()); | |
| 294 ConvertPointToScreen(this, &system_menu_point); | |
| 295 return system_menu_point; | |
| 296 } | |
| 297 | |
| 298 int DefaultNonClientView::NonClientHitTest(const gfx::Point& point) { | |
| 299 if (!bounds().Contains(point)) | |
| 300 return HTNOWHERE; | |
| 301 | |
| 302 int frame_component = container_->client_view()->NonClientHitTest(point); | |
| 303 if (frame_component != HTNOWHERE) | |
| 304 return frame_component; | |
| 305 | |
| 306 // Then see if the point is within any of the window controls. | |
| 307 if (close_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains(point)) | |
| 308 return HTCLOSE; | |
| 309 if (restore_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains( | |
| 310 point)) | |
| 311 return HTMAXBUTTON; | |
| 312 if (maximize_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains( | |
| 313 point)) | |
| 314 return HTMAXBUTTON; | |
| 315 if (minimize_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains( | |
| 316 point)) | |
| 317 return HTMINBUTTON; | |
| 318 if (system_menu_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains( | |
| 319 point)) | |
| 320 return HTSYSMENU; | |
| 321 | |
| 322 int window_component = GetHTComponentForFrame(point, FrameBorderThickness(), | |
| 323 NonClientBorderThickness(), kResizeAreaCornerSize, kResizeAreaCornerSize, | |
| 324 container_->window_delegate()->CanResize()); | |
| 325 // Fall back to the caption if no other component matches. | |
| 326 return (window_component == HTNOWHERE) ? HTCAPTION : window_component; | |
| 327 } | |
| 328 | |
| 329 void DefaultNonClientView::GetWindowMask(const gfx::Size& size, | |
| 330 gfx::Path* window_mask) { | |
| 331 DCHECK(window_mask); | |
| 332 | |
| 333 // Redefine the window visible region for the new size. | |
| 334 window_mask->moveTo(0, 3); | |
| 335 window_mask->lineTo(1, 2); | |
| 336 window_mask->lineTo(1, 1); | |
| 337 window_mask->lineTo(2, 1); | |
| 338 window_mask->lineTo(3, 0); | |
| 339 | |
| 340 window_mask->lineTo(SkIntToScalar(size.width() - 3), 0); | |
| 341 window_mask->lineTo(SkIntToScalar(size.width() - 2), 1); | |
| 342 window_mask->lineTo(SkIntToScalar(size.width() - 1), 1); | |
| 343 window_mask->lineTo(SkIntToScalar(size.width() - 1), 2); | |
| 344 window_mask->lineTo(SkIntToScalar(size.width()), 3); | |
| 345 | |
| 346 window_mask->lineTo(SkIntToScalar(size.width()), | |
| 347 SkIntToScalar(size.height())); | |
| 348 window_mask->lineTo(0, SkIntToScalar(size.height())); | |
| 349 window_mask->close(); | |
| 350 } | |
| 351 | |
| 352 void DefaultNonClientView::EnableClose(bool enable) { | |
| 353 close_button_->SetEnabled(enable); | |
| 354 } | |
| 355 | |
| 356 void DefaultNonClientView::ResetWindowControls() { | |
| 357 restore_button_->SetState(Button::BS_NORMAL); | |
| 358 minimize_button_->SetState(Button::BS_NORMAL); | |
| 359 maximize_button_->SetState(Button::BS_NORMAL); | |
| 360 // The close button isn't affected by this constraint. | |
| 361 } | |
| 362 | |
| 363 /////////////////////////////////////////////////////////////////////////////// | |
| 364 // DefaultNonClientView, View overrides: | |
| 365 | |
| 366 void DefaultNonClientView::Paint(ChromeCanvas* canvas) { | |
| 367 if (container_->IsMaximized()) | |
| 368 PaintMaximizedFrameBorder(canvas); | |
| 369 else | |
| 370 PaintRestoredFrameBorder(canvas); | |
| 371 PaintTitleBar(canvas); | |
| 372 if (!container_->IsMaximized()) | |
| 373 PaintRestoredClientEdge(canvas); | |
| 374 } | |
| 375 | |
| 376 void DefaultNonClientView::Layout() { | |
| 377 LayoutWindowControls(); | |
| 378 LayoutTitleBar(); | |
| 379 LayoutClientView(); | |
| 380 } | |
| 381 | |
| 382 gfx::Size DefaultNonClientView::GetPreferredSize() { | |
| 383 gfx::Size pref = client_view_->GetPreferredSize(); | |
| 384 DCHECK(pref.width() > 0 && pref.height() > 0); | |
| 385 return CalculateWindowSizeForClientSize(pref.width(), pref.height()); | |
| 386 } | |
| 387 | |
| 388 void DefaultNonClientView::ViewHierarchyChanged(bool is_add, | |
| 389 View* parent, | |
| 390 View* child) { | |
| 391 // Add our Client View as we are added to the Widget so that if we are | |
| 392 // subsequently resized all the parent-child relationships are established. | |
| 393 if (is_add && GetWidget() && child == this) | |
| 394 AddChildView(container_->client_view()); | |
| 395 } | |
| 396 | |
| 397 /////////////////////////////////////////////////////////////////////////////// | |
| 398 // DefaultNonClientView, BaseButton::ButtonListener implementation: | |
| 399 | |
| 400 void DefaultNonClientView::ButtonPressed(BaseButton* sender) { | |
| 401 if (sender == close_button_) | |
| 402 container_->ExecuteSystemMenuCommand(SC_CLOSE); | |
| 403 else if (sender == minimize_button_) | |
| 404 container_->ExecuteSystemMenuCommand(SC_MINIMIZE); | |
| 405 else if (sender == maximize_button_) | |
| 406 container_->ExecuteSystemMenuCommand(SC_MAXIMIZE); | |
| 407 else if (sender == restore_button_) | |
| 408 container_->ExecuteSystemMenuCommand(SC_RESTORE); | |
| 409 } | |
| 410 | |
| 411 /////////////////////////////////////////////////////////////////////////////// | |
| 412 // DefaultNonClientView, private: | |
| 413 | |
| 414 int DefaultNonClientView::FrameBorderThickness() const { | |
| 415 return container_->IsMaximized() ? | |
| 416 GetSystemMetrics(SM_CXSIZEFRAME) : kFrameBorderThickness; | |
| 417 } | |
| 418 | |
| 419 int DefaultNonClientView::NonClientBorderThickness() const { | |
| 420 // In maximized mode, we don't show a client edge. | |
| 421 return FrameBorderThickness() + | |
| 422 (container_->IsMaximized() ? 0 : kClientEdgeThickness); | |
| 423 } | |
| 424 | |
| 425 int DefaultNonClientView::NonClientTopBorderHeight() const { | |
| 426 int title_top_spacing, title_thickness; | |
| 427 return TitleCoordinates(&title_top_spacing, &title_thickness); | |
| 428 } | |
| 429 | |
| 430 int DefaultNonClientView::BottomEdgeThicknessWithinNonClientHeight() const { | |
| 431 return kFrameShadowThickness + | |
| 432 (container_->IsMaximized() ? 0 : kClientEdgeThickness); | |
| 433 } | |
| 434 | |
| 435 int DefaultNonClientView::TitleCoordinates(int* title_top_spacing, | |
| 436 int* title_thickness) const { | |
| 437 int frame_thickness = FrameBorderThickness(); | |
| 438 int min_titlebar_height = kTitlebarMinimumHeight + frame_thickness; | |
| 439 *title_top_spacing = frame_thickness + kTitleTopSpacing; | |
| 440 // The bottom spacing should be the same apparent height as the top spacing. | |
| 441 // Because the actual top spacing height varies based on the system border | |
| 442 // thickness, we calculate this based on the restored top spacing and then | |
| 443 // adjust for maximized mode. We also don't include the frame shadow here, | |
| 444 // since while it's part of the bottom spacing it will be added in at the end. | |
| 445 int title_bottom_spacing = | |
| 446 kFrameBorderThickness + kTitleTopSpacing - kFrameShadowThickness; | |
| 447 if (container_->IsMaximized()) { | |
| 448 // When we maximize, the top border appears to be chopped off; shift the | |
| 449 // title down to stay centered within the remaining space. | |
| 450 int title_adjust = (kFrameBorderThickness / 2); | |
| 451 *title_top_spacing += title_adjust; | |
| 452 title_bottom_spacing -= title_adjust; | |
| 453 } | |
| 454 *title_thickness = std::max(title_font_.height(), | |
| 455 min_titlebar_height - *title_top_spacing - title_bottom_spacing); | |
| 456 return *title_top_spacing + *title_thickness + title_bottom_spacing + | |
| 457 BottomEdgeThicknessWithinNonClientHeight(); | |
| 458 } | |
| 459 | |
| 460 void DefaultNonClientView::PaintRestoredFrameBorder(ChromeCanvas* canvas) { | |
| 461 SkBitmap* top_left_corner = resources()->GetPartBitmap(FRAME_TOP_LEFT_CORNER); | |
| 462 SkBitmap* top_right_corner = | |
| 463 resources()->GetPartBitmap(FRAME_TOP_RIGHT_CORNER); | |
| 464 SkBitmap* top_edge = resources()->GetPartBitmap(FRAME_TOP_EDGE); | |
| 465 SkBitmap* right_edge = resources()->GetPartBitmap(FRAME_RIGHT_EDGE); | |
| 466 SkBitmap* left_edge = resources()->GetPartBitmap(FRAME_LEFT_EDGE); | |
| 467 SkBitmap* bottom_left_corner = | |
| 468 resources()->GetPartBitmap(FRAME_BOTTOM_LEFT_CORNER); | |
| 469 SkBitmap* bottom_right_corner = | |
| 470 resources()->GetPartBitmap(FRAME_BOTTOM_RIGHT_CORNER); | |
| 471 SkBitmap* bottom_edge = resources()->GetPartBitmap(FRAME_BOTTOM_EDGE); | |
| 472 | |
| 473 // Top. | |
| 474 canvas->DrawBitmapInt(*top_left_corner, 0, 0); | |
| 475 canvas->TileImageInt(*top_edge, top_left_corner->width(), 0, | |
| 476 width() - top_right_corner->width(), top_edge->height()); | |
| 477 canvas->DrawBitmapInt(*top_right_corner, | |
| 478 width() - top_right_corner->width(), 0); | |
| 479 | |
| 480 // Right. | |
| 481 canvas->TileImageInt(*right_edge, width() - right_edge->width(), | |
| 482 top_right_corner->height(), right_edge->width(), | |
| 483 height() - top_right_corner->height() - | |
| 484 bottom_right_corner->height()); | |
| 485 | |
| 486 // Bottom. | |
| 487 canvas->DrawBitmapInt(*bottom_right_corner, | |
| 488 width() - bottom_right_corner->width(), | |
| 489 height() - bottom_right_corner->height()); | |
| 490 canvas->TileImageInt(*bottom_edge, bottom_left_corner->width(), | |
| 491 height() - bottom_edge->height(), | |
| 492 width() - bottom_left_corner->width() - | |
| 493 bottom_right_corner->width(), | |
| 494 bottom_edge->height()); | |
| 495 canvas->DrawBitmapInt(*bottom_left_corner, 0, | |
| 496 height() - bottom_left_corner->height()); | |
| 497 | |
| 498 // Left. | |
| 499 canvas->TileImageInt(*left_edge, 0, top_left_corner->height(), | |
| 500 left_edge->width(), | |
| 501 height() - top_left_corner->height() - bottom_left_corner->height()); | |
| 502 } | |
| 503 | |
| 504 void DefaultNonClientView::PaintMaximizedFrameBorder( | |
| 505 ChromeCanvas* canvas) { | |
| 506 SkBitmap* top_edge = resources()->GetPartBitmap(FRAME_TOP_EDGE); | |
| 507 canvas->TileImageInt(*top_edge, 0, FrameBorderThickness(), width(), | |
| 508 top_edge->height()); | |
| 509 | |
| 510 // The bottom of the titlebar actually comes from the top of the Client Edge | |
| 511 // graphic, with the actual client edge clipped off the bottom. | |
| 512 SkBitmap* titlebar_bottom = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_TOP); | |
| 513 int edge_height = titlebar_bottom->height() - kClientEdgeThickness; | |
| 514 canvas->TileImageInt(*titlebar_bottom, 0, | |
| 515 container_->client_view()->y() - edge_height, width(), edge_height); | |
| 516 } | |
| 517 | |
| 518 void DefaultNonClientView::PaintTitleBar(ChromeCanvas* canvas) { | |
| 519 WindowDelegate* d = container_->window_delegate(); | |
| 520 | |
| 521 // It seems like in some conditions we can be asked to paint after the window | |
| 522 // that contains us is WM_DESTROYed. At this point, our delegate is NULL. The | |
| 523 // correct long term fix may be to shut down the RootView in WM_DESTROY. | |
| 524 if (!d) | |
| 525 return; | |
| 526 | |
| 527 canvas->DrawStringInt(d->GetWindowTitle(), title_font_, SK_ColorWHITE, | |
| 528 MirroredLeftPointForRect(title_bounds_), title_bounds_.y(), | |
| 529 title_bounds_.width(), title_bounds_.height()); | |
| 530 } | |
| 531 | |
| 532 void DefaultNonClientView::PaintRestoredClientEdge(ChromeCanvas* canvas) { | |
| 533 gfx::Rect client_area_bounds = container_->client_view()->bounds(); | |
| 534 int client_area_top = client_area_bounds.y(); | |
| 535 | |
| 536 SkBitmap* top_left = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_LEFT); | |
| 537 SkBitmap* top = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_TOP); | |
| 538 SkBitmap* top_right = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_RIGHT); | |
| 539 SkBitmap* right = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_RIGHT); | |
| 540 SkBitmap* bottom_right = | |
| 541 resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM_RIGHT); | |
| 542 SkBitmap* bottom = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM); | |
| 543 SkBitmap* bottom_left = | |
| 544 resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM_LEFT); | |
| 545 SkBitmap* left = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_LEFT); | |
| 546 | |
| 547 // Top. | |
| 548 // This next calculation is necessary because the top center bitmap is shorter | |
| 549 // than the top left and right bitmaps. We need their top edges to line up, | |
| 550 // and we need the left and right edges to start below the corners' bottoms. | |
| 551 int top_edge_y = client_area_top - top->height(); | |
| 552 client_area_top = top_edge_y + top_left->height(); | |
| 553 canvas->DrawBitmapInt(*top_left, client_area_bounds.x() - top_left->width(), | |
| 554 top_edge_y); | |
| 555 canvas->TileImageInt(*top, client_area_bounds.x(), top_edge_y, | |
| 556 client_area_bounds.width(), top->height()); | |
| 557 canvas->DrawBitmapInt(*top_right, client_area_bounds.right(), top_edge_y); | |
| 558 | |
| 559 // Right. | |
| 560 int client_area_bottom = | |
| 561 std::max(client_area_top, client_area_bounds.bottom()); | |
| 562 int client_area_height = client_area_bottom - client_area_top; | |
| 563 canvas->TileImageInt(*right, client_area_bounds.right(), client_area_top, | |
| 564 right->width(), client_area_height); | |
| 565 | |
| 566 // Bottom. | |
| 567 canvas->DrawBitmapInt(*bottom_right, client_area_bounds.right(), | |
| 568 client_area_bottom); | |
| 569 canvas->TileImageInt(*bottom, client_area_bounds.x(), client_area_bottom, | |
| 570 client_area_bounds.width(), bottom_right->height()); | |
| 571 canvas->DrawBitmapInt(*bottom_left, | |
| 572 client_area_bounds.x() - bottom_left->width(), client_area_bottom); | |
| 573 | |
| 574 // Left. | |
| 575 canvas->TileImageInt(*left, client_area_bounds.x() - left->width(), | |
| 576 client_area_top, left->width(), client_area_height); | |
| 577 } | |
| 578 | |
| 579 void DefaultNonClientView::LayoutWindowControls() { | |
| 580 close_button_->SetImageAlignment(Button::ALIGN_LEFT, Button::ALIGN_BOTTOM); | |
| 581 // Maximized buttons start at window top so that even if their images aren't | |
| 582 // drawn flush with the screen edge, they still obey Fitts' Law. | |
| 583 bool is_maximized = container_->IsMaximized(); | |
| 584 int frame_thickness = FrameBorderThickness(); | |
| 585 int caption_y = is_maximized ? frame_thickness : kCaptionTopSpacing; | |
| 586 int top_extra_height = is_maximized ? kCaptionTopSpacing : 0; | |
| 587 // There should always be the same number of non-shadow pixels visible to the | |
| 588 // side of the caption buttons. In maximized mode we extend the rightmost | |
| 589 // button to the screen corner to obey Fitts' Law. | |
| 590 int right_extra_width = is_maximized ? | |
| 591 (kFrameBorderThickness - kFrameShadowThickness) : 0; | |
| 592 int right_spacing = is_maximized ? | |
| 593 (GetSystemMetrics(SM_CXSIZEFRAME) + right_extra_width) : frame_thickness; | |
| 594 gfx::Size close_button_size = close_button_->GetPreferredSize(); | |
| 595 close_button_->SetBounds(width() - close_button_size.width() - right_spacing, | |
| 596 caption_y, | |
| 597 close_button_size.width() + right_extra_width, | |
| 598 close_button_size.height() + top_extra_height); | |
| 599 | |
| 600 // When the window is restored, we show a maximized button; otherwise, we show | |
| 601 // a restore button. | |
| 602 bool is_restored = !is_maximized && !container_->IsMinimized(); | |
| 603 views::Button* invisible_button = is_restored ? | |
| 604 restore_button_ : maximize_button_; | |
| 605 invisible_button->SetVisible(false); | |
| 606 | |
| 607 views::Button* visible_button = is_restored ? | |
| 608 maximize_button_ : restore_button_; | |
| 609 FramePartBitmap normal_part, hot_part, pushed_part; | |
| 610 if (should_show_minmax_buttons_) { | |
| 611 visible_button->SetVisible(true); | |
| 612 visible_button->SetImageAlignment(Button::ALIGN_LEFT, Button::ALIGN_BOTTOM); | |
| 613 gfx::Size visible_button_size = visible_button->GetPreferredSize(); | |
| 614 visible_button->SetBounds(close_button_->x() - visible_button_size.width(), | |
| 615 caption_y, visible_button_size.width(), | |
| 616 visible_button_size.height() + top_extra_height); | |
| 617 | |
| 618 minimize_button_->SetVisible(true); | |
| 619 minimize_button_->SetImageAlignment(Button::ALIGN_LEFT, | |
| 620 Button::ALIGN_BOTTOM); | |
| 621 gfx::Size minimize_button_size = minimize_button_->GetPreferredSize(); | |
| 622 minimize_button_->SetBounds( | |
| 623 visible_button->x() - minimize_button_size.width(), caption_y, | |
| 624 minimize_button_size.width(), | |
| 625 minimize_button_size.height() + top_extra_height); | |
| 626 | |
| 627 normal_part = FRAME_CLOSE_BUTTON_ICON; | |
| 628 hot_part = FRAME_CLOSE_BUTTON_ICON_H; | |
| 629 pushed_part = FRAME_CLOSE_BUTTON_ICON_P; | |
| 630 } else { | |
| 631 visible_button->SetVisible(false); | |
| 632 minimize_button_->SetVisible(false); | |
| 633 | |
| 634 normal_part = FRAME_CLOSE_BUTTON_ICON_SA; | |
| 635 hot_part = FRAME_CLOSE_BUTTON_ICON_SA_H; | |
| 636 pushed_part = FRAME_CLOSE_BUTTON_ICON_SA_P; | |
| 637 } | |
| 638 | |
| 639 close_button_->SetImage(Button::BS_NORMAL, | |
| 640 active_resources_->GetPartBitmap(normal_part)); | |
| 641 close_button_->SetImage(Button::BS_HOT, | |
| 642 active_resources_->GetPartBitmap(hot_part)); | |
| 643 close_button_->SetImage(Button::BS_PUSHED, | |
| 644 active_resources_->GetPartBitmap(pushed_part)); | |
| 645 } | |
| 646 | |
| 647 void DefaultNonClientView::LayoutTitleBar() { | |
| 648 // Always lay out the icon, even when it's not present, so we can lay out the | |
| 649 // window title based on its position. | |
| 650 int frame_thickness = FrameBorderThickness(); | |
| 651 int icon_x = frame_thickness + kIconLeftSpacing; | |
| 652 | |
| 653 // The usable height of the titlebar area is the total height minus the top | |
| 654 // resize border and any edge area we draw at its bottom. | |
| 655 int title_top_spacing, title_thickness; | |
| 656 int top_height = TitleCoordinates(&title_top_spacing, &title_thickness); | |
| 657 int available_height = top_height - frame_thickness - | |
| 658 BottomEdgeThicknessWithinNonClientHeight(); | |
| 659 | |
| 660 // The icon takes up a constant fraction of the available height, down to a | |
| 661 // minimum size, and is always an even number of pixels on a side (presumably | |
| 662 // to make scaled icons look better). It's centered within the usable height. | |
| 663 int icon_size = std::max((available_height * kIconHeightFractionNumerator / | |
| 664 kIconHeightFractionDenominator) / 2 * 2, kIconMinimumSize); | |
| 665 int icon_y = ((available_height - icon_size) / 2) + frame_thickness; | |
| 666 | |
| 667 // Hack: Our frame border has a different "3D look" than Windows'. Theirs has | |
| 668 // a more complex gradient on the top that they push their icon/title below; | |
| 669 // then the maximized window cuts this off and the icon/title are centered in | |
| 670 // the remaining space. Because the apparent shape of our border is simpler, | |
| 671 // using the same positioning makes things look slightly uncentered with | |
| 672 // restored windows, so we come up to compensate. | |
| 673 if (!container_->IsMaximized()) | |
| 674 icon_y -= kIconRestoredAdjust; | |
| 675 | |
| 676 views::WindowDelegate* d = container_->window_delegate(); | |
| 677 if (!d->ShouldShowWindowIcon()) | |
| 678 icon_size = 0; | |
| 679 system_menu_button_->SetBounds(icon_x, icon_y, icon_size, icon_size); | |
| 680 | |
| 681 // Size the title. | |
| 682 int icon_right = icon_x + icon_size; | |
| 683 int title_x = | |
| 684 icon_right + (d->ShouldShowWindowIcon() ? kIconTitleSpacing : 0); | |
| 685 int title_right = (should_show_minmax_buttons_ ? | |
| 686 minimize_button_->x() : close_button_->x()) - kTitleCaptionSpacing; | |
| 687 title_bounds_.SetRect(title_x, | |
| 688 title_top_spacing + ((title_thickness - title_font_.height()) / 2), | |
| 689 std::max(0, title_right - title_x), title_font_.height()); | |
| 690 } | |
| 691 | |
| 692 void DefaultNonClientView::LayoutClientView() { | |
| 693 container_->client_view()->SetBounds(CalculateClientAreaBounds(width(), | |
| 694 height())); | |
| 695 } | |
| 696 | |
| 697 // static | |
| 698 void DefaultNonClientView::InitClass() { | |
| 699 static bool initialized = false; | |
| 700 if (!initialized) { | |
| 701 active_resources_ = new ActiveWindowResources; | |
| 702 inactive_resources_ = new InactiveWindowResources; | |
| 703 | |
| 704 title_font_ = win_util::GetWindowTitleFont(); | |
| 705 | |
| 706 initialized = true; | |
| 707 } | |
| 708 } | |
| 709 | |
| 710 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 27317:
Support DWM switching.... (Closed)
Base URL: svn://chrome-svn.corp.google.com/chrome/trunk/src/