chrome/browser/ui/views/frame/minimize_button_metrics_win.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "chrome/browser/ui/views/frame/minimize_button_metrics_win.h"

#include <dwmapi.h>

#include "base/check.h"
#include "base/i18n/rtl.h"
#include "ui/display/win/screen_win.h"
#include "ui/gfx/geometry/point.h"

namespace {

const int kButtonBoundsPositionOffset = 6;
const int kInvalidOffset = static_cast<int>(0x80000000);

using display::win::ScreenWin;

}  // namespace

// static
int MinimizeButtonMetrics::last_cached_minimize_button_x_delta_ = 0;

// static
int MinimizeButtonMetrics::button_bounds_position_offset_ = kInvalidOffset;

MinimizeButtonMetrics::MinimizeButtonMetrics() = default;

MinimizeButtonMetrics::~MinimizeButtonMetrics() = default;

void MinimizeButtonMetrics::Init(HWND hwnd) {
  DCHECK(!hwnd_);
  hwnd_ = hwnd;
}

void MinimizeButtonMetrics::OnHWNDActivated() {
  was_activated_ = true;
  // NOTE: we don't cache here as it seems only after the activate is the value
  // correct.
}

void MinimizeButtonMetrics::OnDpiChanged() {
  // This ensures that the next time GetMinimizeButtonOffsetX() is called, it
  // will be recalculated, given the new scale factor.
  cached_minimize_button_x_delta_ = 0;
}

// This function attempts to calculate the odd and varying difference
// between the results of DwmGetWindowAttribute with the
// DWMWA_CAPTION_BUTTON_BOUNDS flag and the information from the
// WM_GETTITLEBARINFOEX message. It will return an empirically determined
// offset until the window has been activated and the message returns
// valid rectangles.
int MinimizeButtonMetrics::GetButtonBoundsPositionOffset(
    const RECT& button_bounds,
    const RECT& window_bounds) const {
  if (button_bounds_position_offset_ == kInvalidOffset) {
    if (!was_activated_ || !IsWindowVisible(hwnd_)) {
      return kButtonBoundsPositionOffset;
    }
    TITLEBARINFOEX info = {0};
    info.cbSize = sizeof(info);
    SendMessage(hwnd_, WM_GETTITLEBARINFOEX, 0,
                reinterpret_cast<LPARAM>(&info));
    if (info.rgrect[2].right == info.rgrect[2].left ||
        (info.rgstate[2] & (STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN |
                            STATE_SYSTEM_UNAVAILABLE))) {
      return kButtonBoundsPositionOffset;
    }
    button_bounds_position_offset_ =
        info.rgrect[2].left - (button_bounds.left + window_bounds.left);
  }
  return button_bounds_position_offset_;
}

int MinimizeButtonMetrics::GetMinimizeButtonOffsetForWindow() const {
  bool dwm_button_pos = false;
  POINT minimize_button_corner = {0};
  RECT button_bounds = {0};
  if (SUCCEEDED(DwmGetWindowAttribute(hwnd_, DWMWA_CAPTION_BUTTON_BOUNDS,
                                      &button_bounds, sizeof(button_bounds)))) {
    if (button_bounds.left != button_bounds.right) {
      // This converts the button coordinate into screen coordinates
      // thus, ensuring that the identity switcher is placed in the
      // same location as before. An additional constant is added because
      // there is a difference between the caption button bounds and
      // the values obtained through WM_GETTITLEBARINFOEX. This difference
      // varies between OS versions, and no metric describing this difference
      // has been located.
      RECT window_bounds = {0};
      if (GetWindowRect(hwnd_, &window_bounds)) {
        int offset =
            GetButtonBoundsPositionOffset(button_bounds, window_bounds);
        minimize_button_corner = {
            button_bounds.left + window_bounds.left + offset, 0};
        dwm_button_pos = true;
      }
    }
  }
  if (!dwm_button_pos) {
    // Fallback to using the message for the titlebar info only if the above
    // code fails. It can fail if DWM is disabled globally or only for the
    // given HWND. The WM_GETTITLEBARINFOEX message can fail if we are not
    // active/visible. By fail we get a location of 0; the return status
    // code is always the same and similarly the state never seems to change
    // (titlebar_info.rgstate).
    TITLEBARINFOEX titlebar_info = {0};
    titlebar_info.cbSize = sizeof(TITLEBARINFOEX);
    SendMessage(hwnd_, WM_GETTITLEBARINFOEX, 0,
                reinterpret_cast<LPARAM>(&titlebar_info));

    // Under DWM WM_GETTITLEBARINFOEX won't return the right thing until after
    // WM_NCACTIVATE (maybe it returns classic values?). In an attempt to
    // return a consistant value we cache the last value across instances and
    // use it until we get the activate.
    if (titlebar_info.rgrect[2].left == titlebar_info.rgrect[2].right ||
        (titlebar_info.rgstate[2] &
         (STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN |
          STATE_SYSTEM_UNAVAILABLE))) {
      return 0;
    }
    minimize_button_corner = {titlebar_info.rgrect[2].left, 0};
  }

  // WM_GETTITLEBARINFOEX returns rects in screen coordinates in pixels.
  // DWMNA_CAPTION_BUTTON_BOUNDS is in window (not client) coordinates,
  // but it has been converted to screen coordinates above. We need to
  // convert the minimize button corner offset to DIP before returning it.
  MapWindowPoints(HWND_DESKTOP, hwnd_, &minimize_button_corner, 1);
  gfx::Point pixel_point = {minimize_button_corner.x, 0};
  gfx::Point dip_point =
      display::win::GetScreenWin()->ClientToDIPPoint(hwnd_, pixel_point);
  return dip_point.x();
}

int MinimizeButtonMetrics::GetMinimizeButtonOffsetX() const {
  // Under DWM WM_GETTITLEBARINFOEX won't return the right thing until after
  // WM_NCACTIVATE (maybe it returns classic values?). In an attempt to return a
  // consistant value we cache the last value across instances and use it until
  // we get the activate.
  if (was_activated_ || cached_minimize_button_x_delta_ == 0) {
    const int minimize_button_offset = GetAndCacheMinimizeButtonOffsetX();
    if (minimize_button_offset > 0) {
      return minimize_button_offset;
    }
  }

  // If we fail to get the minimize button offset via the WM_GETTITLEBARINFOEX
  // message then calculate and return this via the
  // cached_minimize_button_x_delta_ member value. Please see
  // CacheMinimizeButtonDelta() for more details.
  DCHECK(cached_minimize_button_x_delta_);

  if (base::i18n::IsRTL()) {
    return cached_minimize_button_x_delta_;
  }

  RECT client_rect = {0};
  GetClientRect(hwnd_, &client_rect);
  return client_rect.right - cached_minimize_button_x_delta_;
}

int MinimizeButtonMetrics::GetAndCacheMinimizeButtonOffsetX() const {
  const int minimize_button_offset = GetMinimizeButtonOffsetForWindow();
  if (minimize_button_offset <= 0) {
    return 0;
  }

  if (base::i18n::IsRTL()) {
    cached_minimize_button_x_delta_ = minimize_button_offset;
  } else {
    RECT client_rect = {0};
    GetClientRect(hwnd_, &client_rect);
    cached_minimize_button_x_delta_ =
        client_rect.right - minimize_button_offset;
  }
  last_cached_minimize_button_x_delta_ = cached_minimize_button_x_delta_;
  return minimize_button_offset;
}