dip_util.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. // Copyright 2014 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. #include "ui/gfx/geometry/dip_util.h"
  5. #include "base/numerics/safe_conversions.h"
  6. #include "build/build_config.h"
  7. #include "ui/gfx/geometry/insets.h"
  8. #include "ui/gfx/geometry/insets_f.h"
  9. #include "ui/gfx/geometry/point.h"
  10. #include "ui/gfx/geometry/point_f.h"
  11. #include "ui/gfx/geometry/rect.h"
  12. #include "ui/gfx/geometry/rect_conversions.h"
  13. #include "ui/gfx/geometry/size.h"
  14. #include "ui/gfx/geometry/size_conversions.h"
  15. namespace gfx {
  16. #if BUILDFLAG(IS_MAC)
  17. // Returns true if the floating point value is holding an integer, modulo
  18. // floating point error. The value `f` can be safely converted to its integer
  19. // form with base::ClampRound().
  20. static bool IsIntegerInFloat(float f) {
  21. return std::abs(f - base::ClampRound(f)) < 0.01f;
  22. }
  23. #endif
  24. PointF ConvertPointToDips(const Point& point_in_pixels,
  25. float device_scale_factor) {
  26. #if BUILDFLAG(IS_MAC)
  27. // Device scale factor on MacOSX is always an integer.
  28. DCHECK(IsIntegerInFloat(device_scale_factor));
  29. #endif
  30. return ScalePoint(PointF(point_in_pixels), 1.f / device_scale_factor);
  31. }
  32. PointF ConvertPointToDips(const PointF& point_in_pixels,
  33. float device_scale_factor) {
  34. #if BUILDFLAG(IS_MAC)
  35. // Device scale factor on MacOSX is always an integer.
  36. DCHECK(IsIntegerInFloat(device_scale_factor));
  37. #endif
  38. return ScalePoint(point_in_pixels, 1.f / device_scale_factor);
  39. }
  40. PointF ConvertPointToPixels(const Point& point_in_dips,
  41. float device_scale_factor) {
  42. #if BUILDFLAG(IS_MAC)
  43. // Device scale factor on MacOSX is always an integer.
  44. DCHECK(IsIntegerInFloat(device_scale_factor));
  45. #endif
  46. return ScalePoint(PointF(point_in_dips), device_scale_factor);
  47. }
  48. PointF ConvertPointToPixels(const PointF& point_in_dips,
  49. float device_scale_factor) {
  50. #if BUILDFLAG(IS_MAC)
  51. // Device scale factor on MacOSX is always an integer.
  52. DCHECK(IsIntegerInFloat(device_scale_factor));
  53. #endif
  54. return ScalePoint(point_in_dips, device_scale_factor);
  55. }
  56. SizeF ConvertSizeToDips(const Size& size_in_pixels, float device_scale_factor) {
  57. #if BUILDFLAG(IS_MAC)
  58. // Device scale factor on MacOSX is always an integer.
  59. DCHECK(IsIntegerInFloat(device_scale_factor));
  60. #endif
  61. return ScaleSize(SizeF(size_in_pixels), 1.f / device_scale_factor);
  62. }
  63. SizeF ConvertSizeToDips(const SizeF& size_in_pixels,
  64. float device_scale_factor) {
  65. #if BUILDFLAG(IS_MAC)
  66. // Device scale factor on MacOSX is always an integer.
  67. DCHECK(IsIntegerInFloat(device_scale_factor));
  68. #endif
  69. return ScaleSize(size_in_pixels, 1.f / device_scale_factor);
  70. }
  71. SizeF ConvertSizeToPixels(const Size& size_in_dips, float device_scale_factor) {
  72. #if BUILDFLAG(IS_MAC)
  73. // Device scale factor on MacOSX is always an integer.
  74. DCHECK(IsIntegerInFloat(device_scale_factor));
  75. #endif
  76. return ScaleSize(SizeF(size_in_dips), device_scale_factor);
  77. }
  78. SizeF ConvertSizeToPixels(const SizeF& size_in_dips,
  79. float device_scale_factor) {
  80. #if BUILDFLAG(IS_MAC)
  81. // Device scale factor on MacOSX is always an integer.
  82. DCHECK(IsIntegerInFloat(device_scale_factor));
  83. #endif
  84. return ScaleSize(size_in_dips, device_scale_factor);
  85. }
  86. RectF ConvertRectToDips(const Rect& rect_in_pixels, float device_scale_factor) {
  87. #if BUILDFLAG(IS_MAC)
  88. // Device scale factor on MacOSX is always an integer.
  89. DCHECK(IsIntegerInFloat(device_scale_factor));
  90. #endif
  91. return ScaleRect(RectF(rect_in_pixels), 1.f / device_scale_factor);
  92. }
  93. RectF ConvertRectToDips(const RectF& rect_in_pixels,
  94. float device_scale_factor) {
  95. #if BUILDFLAG(IS_MAC)
  96. // Device scale factor on MacOSX is always an integer.
  97. DCHECK(IsIntegerInFloat(device_scale_factor));
  98. #endif
  99. return ScaleRect(rect_in_pixels, 1.f / device_scale_factor);
  100. }
  101. RectF ConvertRectToPixels(const Rect& rect_in_dips, float device_scale_factor) {
  102. #if BUILDFLAG(IS_MAC)
  103. // Device scale factor on MacOSX is always an integer.
  104. DCHECK(IsIntegerInFloat(device_scale_factor));
  105. #endif
  106. return ScaleRect(RectF(rect_in_dips), device_scale_factor);
  107. }
  108. RectF ConvertRectToPixels(const RectF& rect_in_dips,
  109. float device_scale_factor) {
  110. #if BUILDFLAG(IS_MAC)
  111. // Device scale factor on MacOSX is always an integer.
  112. DCHECK(IsIntegerInFloat(device_scale_factor));
  113. #endif
  114. return ScaleRect(rect_in_dips, device_scale_factor);
  115. }
  116. InsetsF ConvertInsetsToDips(const gfx::Insets& insets_in_pixels,
  117. float device_scale_factor) {
  118. #if BUILDFLAG(IS_MAC)
  119. // Device scale factor on MacOSX is always an integer.
  120. DCHECK(IsIntegerInFloat(device_scale_factor));
  121. #endif
  122. return ScaleInsets(InsetsF(insets_in_pixels), 1.f / device_scale_factor);
  123. }
  124. InsetsF ConvertInsetsToDips(const gfx::InsetsF& insets_in_pixels,
  125. float device_scale_factor) {
  126. #if BUILDFLAG(IS_MAC)
  127. // Device scale factor on MacOSX is always an integer.
  128. DCHECK(IsIntegerInFloat(device_scale_factor));
  129. #endif
  130. return ScaleInsets(insets_in_pixels, 1.f / device_scale_factor);
  131. }
  132. InsetsF ConvertInsetsToPixels(const gfx::Insets& insets_in_dips,
  133. float device_scale_factor) {
  134. #if BUILDFLAG(IS_MAC)
  135. // Device scale factor on MacOSX is always an integer.
  136. DCHECK(IsIntegerInFloat(device_scale_factor));
  137. #endif
  138. return ScaleInsets(InsetsF(insets_in_dips), device_scale_factor);
  139. }
  140. InsetsF ConvertInsetsToPixels(const gfx::InsetsF& insets_in_dips,
  141. float device_scale_factor) {
  142. #if BUILDFLAG(IS_MAC)
  143. // Device scale factor on MacOSX is always an integer.
  144. DCHECK(IsIntegerInFloat(device_scale_factor));
  145. #endif
  146. return ScaleInsets(insets_in_dips, device_scale_factor);
  147. }
  148. } // namespace gfx