widget/nsNativeBasicTheme.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef nsNativeBasicTheme_h
   8 #define nsNativeBasicTheme_h
   9
  10 #include "Units.h"
  11 #include "mozilla/StaticPrefs_layout.h"
  12 #include "mozilla/ClearOnShutdown.h"
  13 #include "mozilla/dom/HTMLMeterElement.h"
  14 #include "mozilla/dom/HTMLProgressElement.h"
  15 #include "mozilla/gfx/2D.h"
  16 #include "mozilla/gfx/Rect.h"
  17 #include "mozilla/gfx/Types.h"
  18 #include "nsColorControlFrame.h"
  19 #include "nsDateTimeControlFrame.h"
  20 #include "nsDeviceContext.h"
  21 #include "nsITheme.h"
  22 #include "nsMeterFrame.h"
  23 #include "nsNativeTheme.h"
  24 #include "nsProgressFrame.h"
  25 #include "nsRangeFrame.h"
  26
  27 namespace mozilla {
  28 namespace widget {
  29
  30 static const gfx::sRGBColor sColorWhite(gfx::sRGBColor::OpaqueWhite());
  31 static const gfx::sRGBColor sColorWhiteAlpha50(gfx::sRGBColor::White(0.5f));
  32 static const gfx::sRGBColor sColorWhiteAlpha80(gfx::sRGBColor::White(0.8f));
  33 static const gfx::sRGBColor sColorBlack(gfx::sRGBColor::OpaqueBlack());
  34
  35 static const gfx::sRGBColor sColorGrey10(
  36     gfx::sRGBColor::UnusualFromARGB(0xffe9e9ed));
  37 static const gfx::sRGBColor sColorGrey10Alpha50(
  38     gfx::sRGBColor::UnusualFromARGB(0x7fe9e9ed));
  39 static const gfx::sRGBColor sColorGrey20(
  40     gfx::sRGBColor::UnusualFromARGB(0xffd0d0d7));
  41 static const gfx::sRGBColor sColorGrey30(
  42     gfx::sRGBColor::UnusualFromARGB(0xffb1b1b9));
  43 static const gfx::sRGBColor sColorGrey40(
  44     gfx::sRGBColor::UnusualFromARGB(0xff8f8f9d));
  45 static const gfx::sRGBColor sColorGrey40Alpha50(
  46     gfx::sRGBColor::UnusualFromARGB(0x7f8f8f9d));
  47 static const gfx::sRGBColor sColorGrey50(
  48     gfx::sRGBColor::UnusualFromARGB(0xff676774));
  49 static const gfx::sRGBColor sColorGrey50Alpha50(
  50     gfx::sRGBColor::UnusualFromARGB(0x7f676774));
  51 static const gfx::sRGBColor sColorGrey60(
  52     gfx::sRGBColor::UnusualFromARGB(0xff484851));
  53 static const gfx::sRGBColor sColorGrey60Alpha50(
  54     gfx::sRGBColor::UnusualFromARGB(0x7f484851));
  55
  56 static const gfx::sRGBColor sColorAccentLight(
  57     gfx::sRGBColor::UnusualFromARGB(0x4d008deb));
  58 static const gfx::sRGBColor sColorAccent(
  59     gfx::sRGBColor::UnusualFromARGB(0xff0060df));
  60 static const gfx::sRGBColor sColorAccentDark(
  61     gfx::sRGBColor::UnusualFromARGB(0xff0250bb));
  62 static const gfx::sRGBColor sColorAccentDarker(
  63     gfx::sRGBColor::UnusualFromARGB(0xff054096));
  64
  65 static const gfx::sRGBColor sColorMeterGreen10(
  66     gfx::sRGBColor::UnusualFromARGB(0xff00ab60));
  67 static const gfx::sRGBColor sColorMeterGreen20(
  68     gfx::sRGBColor::UnusualFromARGB(0xff056139));
  69 static const gfx::sRGBColor sColorMeterYellow10(
  70     gfx::sRGBColor::UnusualFromARGB(0xffffbd4f));
  71 static const gfx::sRGBColor sColorMeterYellow20(
  72     gfx::sRGBColor::UnusualFromARGB(0xffd2811e));
  73 static const gfx::sRGBColor sColorMeterRed10(
  74     gfx::sRGBColor::UnusualFromARGB(0xffe22850));
  75 static const gfx::sRGBColor sColorMeterRed20(
  76     gfx::sRGBColor::UnusualFromARGB(0xff810220));
  77
  78 static const gfx::sRGBColor sScrollbarColor(gfx::sRGBColor(0.94f, 0.94f,
  79                                                            0.94f));
  80 static const gfx::sRGBColor sScrollbarBorderColor(gfx::sRGBColor(1.0f, 1.0f,
  81                                                                  1.0f));
  82 static const gfx::sRGBColor sScrollbarThumbColor(gfx::sRGBColor(0.8f, 0.8f,
  83                                                                 0.8f));
  84 static const gfx::sRGBColor sScrollbarThumbColorActive(gfx::sRGBColor(0.375f,
  85                                                                       0.375f,
  86                                                                       0.375f));
  87 static const gfx::sRGBColor sScrollbarThumbColorHover(gfx::sRGBColor(0.65f,
  88                                                                      0.65f,
  89                                                                      0.65f));
  90 static const gfx::sRGBColor sScrollbarArrowColor(gfx::sRGBColor(0.375f, 0.375f,
  91                                                                 0.375f));
  92 static const gfx::sRGBColor sScrollbarArrowColorActive(gfx::sRGBColor(1.0f,
  93                                                                       1.0f,
  94                                                                       1.0f));
  95 static const gfx::sRGBColor sScrollbarArrowColorHover(gfx::sRGBColor(0.0f, 0.0f,
  96                                                                      0.0f));
  97 static const gfx::sRGBColor sScrollbarButtonColor(sScrollbarColor);
  98 static const gfx::sRGBColor sScrollbarButtonActiveColor(gfx::sRGBColor(0.375f,
  99                                                                        0.375f,
 100                                                                        0.375f));
 101 static const gfx::sRGBColor sScrollbarButtonHoverColor(gfx::sRGBColor(0.86f,
 102                                                                       0.86f,
 103                                                                       0.86f));
 104
 105 static const CSSIntCoord kMinimumWidgetSize = 14;
 106 static const CSSIntCoord kMinimumScrollbarSize = 14;
 107 static const CSSIntCoord kMinimumThinScrollbarSize = 6;
 108 static const CSSIntCoord kMinimumColorPickerHeight = 32;
 109 static const CSSIntCoord kMinimumRangeThumbSize = 20;
 110 static const CSSIntCoord kMinimumDropdownArrowButtonWidth = 18;
 111 static const CSSIntCoord kMinimumSpinnerButtonWidth = 31;
 112 static const CSSCoord kButtonBorderWidth = 1.0f;
 113 static const CSSCoord kMenulistBorderWidth = 1.0f;
 114 static const CSSCoord kTextFieldBorderWidth = 1.0f;
 115 static const CSSCoord kSpinnerBorderWidth = 1.0f;
 116 static const CSSCoord kRangeHeight = 6.0f;
 117 static const CSSCoord kProgressbarHeight = 6.0f;
 118 static const CSSCoord kMeterHeight = 12.0f;
 119
 120 }  // namespace widget
 121 }  // namespace mozilla
 122
 123 class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
 124  protected:
 125   using sRGBColor = mozilla::gfx::sRGBColor;
 126   using CSSCoord = mozilla::CSSCoord;
 127   using CSSIntCoord = mozilla::CSSIntCoord;
 128   using ComputedStyle = mozilla::ComputedStyle;
 129   using EventStates = mozilla::EventStates;
 130   using DrawTarget = mozilla::gfx::DrawTarget;
 131   using Path = mozilla::gfx::Path;
 132   using Rect = mozilla::gfx::Rect;
 133   using RectCornerRadii = mozilla::gfx::RectCornerRadii;
 134
 135  public:
 136   NS_DECL_ISUPPORTS_INHERITED
 137
 138   // The nsITheme interface.
 139   NS_IMETHOD DrawWidgetBackground(gfxContext* aContext, nsIFrame* aFrame,
 140                                   StyleAppearance aAppearance,
 141                                   const nsRect& aRect,
 142                                   const nsRect& aDirtyRect) override;
 143   /*bool CreateWebRenderCommandsForWidget(mozilla::wr::DisplayListBuilder&
 144      aBuilder, mozilla::wr::IpcResourceUpdateQueue& aResources, const
 145      mozilla::layers::StackingContextHelper& aSc,
 146                                         mozilla::layers::RenderRootStateManager*
 147      aManager, nsIFrame* aFrame, StyleAppearance aAppearance, const nsRect&
 148      aRect) override;*/
 149   [[nodiscard]] LayoutDeviceIntMargin GetWidgetBorder(
 150       nsDeviceContext* aContext, nsIFrame* aFrame,
 151       StyleAppearance aAppearance) override;
 152   bool GetWidgetPadding(nsDeviceContext* aContext, nsIFrame* aFrame,
 153                         StyleAppearance aAppearance,
 154                         LayoutDeviceIntMargin* aResult) override;
 155   bool GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame* aFrame,
 156                          StyleAppearance aAppearance,
 157                          nsRect* aOverflowRect) override;
 158   NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame,
 159                                   StyleAppearance aAppearance,
 160                                   mozilla::LayoutDeviceIntSize* aResult,
 161                                   bool* aIsOverridable) override;
 162   Transparency GetWidgetTransparency(nsIFrame* aFrame,
 163                                      StyleAppearance aAppearance) override;
 164   NS_IMETHOD WidgetStateChanged(nsIFrame* aFrame, StyleAppearance aAppearance,
 165                                 nsAtom* aAttribute, bool* aShouldRepaint,
 166                                 const nsAttrValue* aOldValue) override;
 167   NS_IMETHOD ThemeChanged() override;
 168   bool WidgetAppearanceDependsOnWindowFocus(
 169       StyleAppearance aAppearance) override;
 170   /*bool NeedToClearBackgroundBehindWidget(
 171       nsIFrame* aFrame, StyleAppearance aAppearance) override;*/
 172   ThemeGeometryType ThemeGeometryTypeForWidget(
 173       nsIFrame* aFrame, StyleAppearance aAppearance) override;
 174   bool ThemeSupportsWidget(nsPresContext* aPresContext, nsIFrame* aFrame,
 175                            StyleAppearance aAppearance) override;
 176   bool WidgetIsContainer(StyleAppearance aAppearance) override;
 177   bool ThemeDrawsFocusForWidget(StyleAppearance aAppearance) override;
 178   bool ThemeNeedsComboboxDropmarker() override;
 179
 180  protected:
 181   nsNativeBasicTheme() = default;
 182   virtual ~nsNativeBasicTheme() = default;
 183
 184   static uint32_t GetDPIRatio(nsIFrame* aFrame);
 185   static bool IsDateTimeResetButton(nsIFrame* aFrame);
 186   static bool IsDateTimeTextField(nsIFrame* aFrame);
 187   static bool IsColorPickerButton(nsIFrame* aFrame);
 188   static bool IsRootScrollbar(nsIFrame* aFrame);
 189   static std::pair<sRGBColor, sRGBColor> ComputeCheckColors(
 190       const EventStates& aState);
 191   static Rect FixAspectRatio(const Rect& aRect);
 192
 193   // This pushes and pops a clip rect to the draw target.
 194   //
 195   // This is done to reduce fuzz in places where we may have antialiasing,
 196   // because skia is not clip-invariant: given different clips, it does not
 197   // guarantee the same result, even if the painted content doesn't intersect
 198   // the clips.
 199   //
 200   // This is a bit sad, overall, but...
 201   struct MOZ_RAII AutoClipRect {
 202     AutoClipRect(DrawTarget& aDt, const Rect& aRect) : mDt(aDt) {
 203       mDt.PushClipRect(aRect);
 204     }
 205
 206     ~AutoClipRect() { mDt.PopClip(); }
 207
 208    private:
 209     DrawTarget& mDt;
 210   };
 211
 212   static void GetFocusStrokeRect(DrawTarget* aDrawTarget, Rect& aFocusRect,
 213                                  CSSCoord aOffset, const CSSCoord aRadius,
 214                                  CSSCoord aFocusWidth, RefPtr<Path>& aOutRect);
 215   static void PaintRoundedFocusRect(DrawTarget* aDrawTarget, const Rect& aRect,
 216                                     uint32_t aDpiRatio, CSSCoord aRadius,
 217                                     CSSCoord aOffset);
 218   static void PaintRoundedRect(DrawTarget* aDrawTarget, const Rect& aRect,
 219                                const sRGBColor& aBackgroundColor,
 220                                const sRGBColor& aBorderColor,
 221                                CSSCoord aBorderWidth,
 222                                RectCornerRadii aDpiAdjustedRadii,
 223                                uint32_t aDpiRatio);
 224   static void PaintRoundedRectWithRadius(DrawTarget* aDrawTarget,
 225                                          const Rect& aRect,
 226                                          const sRGBColor& aBackgroundColor,
 227                                          const sRGBColor& aBorderColor,
 228                                          CSSCoord aBorderWidth,
 229                                          CSSCoord aRadius, uint32_t aDpiRatio);
 230   static void PaintCheckboxControl(DrawTarget* aDrawTarget, const Rect& aRect,
 231                                    const EventStates& aState,
 232                                    uint32_t aDpiRatio);
 233   static void PaintCheckMark(DrawTarget* aDrawTarget, const Rect& aRect,
 234                              const EventStates& aState, uint32_t aDpiRatio);
 235   static void PaintIndeterminateMark(DrawTarget* aDrawTarget, const Rect& aRect,
 236                                      const EventStates& aState,
 237                                      uint32_t aDpiRatio);
 238   static void PaintStrokedEllipse(DrawTarget* aDrawTarget, const Rect& aRect,
 239                                   const sRGBColor& aBackgroundColor,
 240                                   const sRGBColor& aBorderColor,
 241                                   const CSSCoord aBorderWidth,
 242                                   uint32_t aDpiRatio);
 243   static void PaintRadioControl(DrawTarget* aDrawTarget, const Rect& aRect,
 244                                 const EventStates& aState, uint32_t aDpiRatio);
 245   static void PaintRadioCheckMark(DrawTarget* aDrawTarget, const Rect& aRect,
 246                                   const EventStates& aState,
 247                                   uint32_t aDpiRatio);
 248   static sRGBColor ComputeBorderColor(const EventStates& aState);
 249   static void PaintTextField(DrawTarget* aDrawTarget, const Rect& aRect,
 250                              const EventStates& aState, uint32_t aDpiRatio);
 251   static std::pair<sRGBColor, sRGBColor> ComputeButtonColors(
 252       const EventStates& aState, nsIFrame* aFrame = nullptr);
 253   static sRGBColor ComputeRangeProgressBorderColor(const EventStates& aState);
 254   static sRGBColor ComputeRangeTrackBorderColor(const EventStates& aState);
 255   static std::pair<sRGBColor, sRGBColor> ComputeRangeProgressColors(
 256       const EventStates& aState);
 257   static std::pair<sRGBColor, sRGBColor> ComputeRangeTrackColors(
 258       const EventStates& aState);
 259   static std::pair<sRGBColor, sRGBColor> ComputeRangeThumbColors(
 260       const EventStates& aState);
 261   static sRGBColor ComputeScrollbarColor(const ComputedStyle& aStyle,
 262                                          const EventStates& aDocumentState,
 263                                          bool aIsRoot);
 264   static sRGBColor ComputeScrollbarthumbColor(
 265       const ComputedStyle& aStyle, const EventStates& aState,
 266       const EventStates& aDocumentState);
 267   static void PaintListbox(DrawTarget* aDrawTarget, const Rect& aRect,
 268                            const EventStates& aState, uint32_t aDpiRatio);
 269   static void PaintMenulist(DrawTarget* aDrawTarget, const Rect& aRect,
 270                             const EventStates& aState, uint32_t aDpiRatio);
 271   static void PaintArrow(DrawTarget* aDrawTarget, const Rect& aRect,
 272                          const int32_t aArrowPolygonX[],
 273                          const int32_t aArrowPolygonY[],
 274                          const int32_t aArrowNumPoints,
 275                          const int32_t aArrowSize, const sRGBColor aFillColor,
 276                          uint32_t aDpiRatio);
 277   static void PaintMenulistArrowButton(nsIFrame* aFrame,
 278                                        DrawTarget* aDrawTarget,
 279                                        const Rect& aRect,
 280                                        const EventStates& aState,
 281                                        uint32_t aDpiRatio);
 282   static void PaintSpinnerButton(nsIFrame* aFrame, DrawTarget* aDrawTarget,
 283                                  const Rect& aRect, const EventStates& aState,
 284                                  StyleAppearance aAppearance,
 285                                  uint32_t aDpiRatio);
 286   static void PaintRangeTrackBackground(nsIFrame* aFrame,
 287                                         DrawTarget* aDrawTarget,
 288                                         const Rect& aRect,
 289                                         const EventStates& aState,
 290                                         uint32_t aDpiRatio, bool aHorizontal);
 291   static void PaintRangeThumb(DrawTarget* aDrawTarget, const Rect& aRect,
 292                               const EventStates& aState, uint32_t aDpiRatio);
 293   static void PaintProgressBar(DrawTarget* aDrawTarget, const Rect& aRect,
 294                                const EventStates& aState, uint32_t aDpiRatio);
 295   static void PaintProgresschunk(nsIFrame* aFrame, DrawTarget* aDrawTarget,
 296                                  const Rect& aRect, const EventStates& aState,
 297                                  uint32_t aDpiRatio);
 298   static void PaintMeter(DrawTarget* aDrawTarget, const Rect& aRect,
 299                          const EventStates& aState, uint32_t aDpiRatio);
 300   static void PaintMeterchunk(nsIFrame* aFrame, DrawTarget* aDrawTarget,
 301                               const Rect& aRect, const EventStates& aState,
 302                               uint32_t aDpiRatio);
 303   static void PaintButton(nsIFrame* aFrame, DrawTarget* aDrawTarget,
 304                           const Rect& aRect, const EventStates& aState,
 305                           uint32_t aDpiRatio);
 306
 307   virtual void PaintScrollbarthumbHorizontal(DrawTarget* aDrawTarget,
 308                                              const Rect& aRect,
 309                                              const ComputedStyle& aStyle,
 310                                              const EventStates& aElementState,
 311                                              const EventStates& aDocumentState);
 312   virtual void PaintScrollbarthumbVertical(DrawTarget* aDrawTarget,
 313                                            const Rect& aRect,
 314                                            const ComputedStyle& aStyle,
 315                                            const EventStates& aElementState,
 316                                            const EventStates& aDocumentState);
 317   virtual void PaintScrollbarHorizontal(DrawTarget* aDrawTarget,
 318                                         const Rect& aRect,
 319                                         const ComputedStyle& aStyle,
 320                                         const EventStates& aDocumentState,
 321                                         bool aIsRoot);
 322   virtual void PaintScrollbarVerticalAndCorner(
 323       DrawTarget* aDrawTarget, const Rect& aRect, const ComputedStyle& aStyle,
 324       const EventStates& aDocumentState, uint32_t aDpiRatio, bool aIsRoot);
 325   virtual void PaintScrollbarbutton(
 326       DrawTarget* aDrawTarget, StyleAppearance aAppearance, const Rect& aRect,
 327       const ComputedStyle& aStyle, const EventStates& aElementState,
 328       const EventStates& aDocumentState, uint32_t aDpiRatio);
 329 };
 330
 331 #endif