layout/base/AccessibleCaret.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 #include "AccessibleCaret.h"
   8
   9 #include "AccessibleCaretLogger.h"
  10 #include "mozilla/Assertions.h"
  11 #include "mozilla/ErrorResult.h"
  12 #include "mozilla/FloatingPoint.h"
  13 #include "mozilla/PresShell.h"
  14 #include "mozilla/StaticPrefs_layout.h"
  15 #include "mozilla/dom/Document.h"
  16 #include "mozilla/dom/ShadowRoot.h"
  17 #include "mozilla/ToString.h"
  18 #include "nsCanvasFrame.h"
  19 #include "nsCaret.h"
  20 #include "nsCSSFrameConstructor.h"
  21 #include "nsDOMTokenList.h"
  22 #include "nsGenericHTMLElement.h"
  23 #include "nsIFrame.h"
  24 #include "nsLayoutUtils.h"
  25 #include "nsPlaceholderFrame.h"
  26
  27 namespace mozilla {
  28 using namespace dom;
  29
  30 #undef AC_LOG
  31 #define AC_LOG(message, ...) \
  32   AC_LOG_BASE("AccessibleCaret (%p): " message, this, ##__VA_ARGS__);
  33
  34 #undef AC_LOGV
  35 #define AC_LOGV(message, ...) \
  36   AC_LOGV_BASE("AccessibleCaret (%p): " message, this, ##__VA_ARGS__);
  37
  38 NS_IMPL_ISUPPORTS(AccessibleCaret::DummyTouchListener, nsIDOMEventListener)
  39
  40 static constexpr auto kTextOverlayElementId = u"text-overlay"_ns;
  41 static constexpr auto kCaretImageElementId = u"image"_ns;
  42
  43 #define AC_PROCESS_ENUM_TO_STREAM(e) \
  44   case (e):                          \
  45     aStream << #e;                   \
  46     break;
  47 std::ostream& operator<<(std::ostream& aStream,
  48                          const AccessibleCaret::Appearance& aAppearance) {
  49   using Appearance = AccessibleCaret::Appearance;
  50   switch (aAppearance) {
  51     AC_PROCESS_ENUM_TO_STREAM(Appearance::None);
  52     AC_PROCESS_ENUM_TO_STREAM(Appearance::Normal);
  53     AC_PROCESS_ENUM_TO_STREAM(Appearance::NormalNotShown);
  54     AC_PROCESS_ENUM_TO_STREAM(Appearance::Left);
  55     AC_PROCESS_ENUM_TO_STREAM(Appearance::Right);
  56   }
  57   return aStream;
  58 }
  59
  60 std::ostream& operator<<(
  61     std::ostream& aStream,
  62     const AccessibleCaret::PositionChangedResult& aResult) {
  63   using PositionChangedResult = AccessibleCaret::PositionChangedResult;
  64   switch (aResult) {
  65     AC_PROCESS_ENUM_TO_STREAM(PositionChangedResult::NotChanged);
  66     AC_PROCESS_ENUM_TO_STREAM(PositionChangedResult::Position);
  67     AC_PROCESS_ENUM_TO_STREAM(PositionChangedResult::Zoom);
  68     AC_PROCESS_ENUM_TO_STREAM(PositionChangedResult::Invisible);
  69   }
  70   return aStream;
  71 }
  72 #undef AC_PROCESS_ENUM_TO_STREAM
  73
  74 // -----------------------------------------------------------------------------
  75 // Implementation of AccessibleCaret methods
  76
  77 AccessibleCaret::AccessibleCaret(PresShell* aPresShell)
  78     : mPresShell(aPresShell) {
  79   // Check all resources required.
  80   if (mPresShell) {
  81     MOZ_ASSERT(mPresShell->GetDocument());
  82     InjectCaretElement(mPresShell->GetDocument());
  83   }
  84 }
  85
  86 AccessibleCaret::~AccessibleCaret() {
  87   if (mPresShell) {
  88     RemoveCaretElement(mPresShell->GetDocument());
  89   }
  90 }
  91
  92 dom::Element* AccessibleCaret::TextOverlayElement() const {
  93   return mCaretElementHolder->Root()->GetElementById(kTextOverlayElementId);
  94 }
  95
  96 dom::Element* AccessibleCaret::CaretImageElement() const {
  97   return mCaretElementHolder->Root()->GetElementById(kCaretImageElementId);
  98 }
  99
 100 void AccessibleCaret::SetAppearance(Appearance aAppearance) {
 101   if (mAppearance == aAppearance) {
 102     return;
 103   }
 104
 105   IgnoredErrorResult rv;
 106   CaretElement().ClassList()->Remove(AppearanceString(mAppearance), rv);
 107   MOZ_ASSERT(!rv.Failed(), "Remove old appearance failed!");
 108
 109   CaretElement().ClassList()->Add(AppearanceString(aAppearance), rv);
 110   MOZ_ASSERT(!rv.Failed(), "Add new appearance failed!");
 111
 112   AC_LOG("%s: %s -> %s", __FUNCTION__, ToString(mAppearance).c_str(),
 113          ToString(aAppearance).c_str());
 114
 115   mAppearance = aAppearance;
 116
 117   // Need to reset rect since the cached rect will be compared in SetPosition.
 118   if (mAppearance == Appearance::None) {
 119     ClearCachedData();
 120   }
 121 }
 122
 123 /* static */
 124 nsAutoString AccessibleCaret::AppearanceString(Appearance aAppearance) {
 125   nsAutoString string;
 126   switch (aAppearance) {
 127     case Appearance::None:
 128       string = u"none"_ns;
 129       break;
 130     case Appearance::NormalNotShown:
 131       string = u"hidden"_ns;
 132       break;
 133     case Appearance::Normal:
 134       string = u"normal"_ns;
 135       break;
 136     case Appearance::Right:
 137       string = u"right"_ns;
 138       break;
 139     case Appearance::Left:
 140       string = u"left"_ns;
 141       break;
 142   }
 143   return string;
 144 }
 145
 146 bool AccessibleCaret::Intersects(const AccessibleCaret& aCaret) const {
 147   MOZ_ASSERT(mPresShell == aCaret.mPresShell);
 148
 149   if (!IsVisuallyVisible() || !aCaret.IsVisuallyVisible()) {
 150     return false;
 151   }
 152
 153   nsRect rect =
 154       nsLayoutUtils::GetRectRelativeToFrame(&CaretElement(), RootFrame());
 155   nsRect rhsRect = nsLayoutUtils::GetRectRelativeToFrame(&aCaret.CaretElement(),
 156                                                          RootFrame());
 157   return rect.Intersects(rhsRect);
 158 }
 159
 160 bool AccessibleCaret::Contains(const nsPoint& aPoint,
 161                                TouchArea aTouchArea) const {
 162   if (!IsVisuallyVisible()) {
 163     return false;
 164   }
 165
 166   nsRect textOverlayRect =
 167       nsLayoutUtils::GetRectRelativeToFrame(TextOverlayElement(), RootFrame());
 168   nsRect caretImageRect =
 169       nsLayoutUtils::GetRectRelativeToFrame(CaretImageElement(), RootFrame());
 170
 171   if (aTouchArea == TouchArea::CaretImage) {
 172     return caretImageRect.Contains(aPoint);
 173   }
 174
 175   MOZ_ASSERT(aTouchArea == TouchArea::Full, "Unexpected TouchArea type!");
 176   return textOverlayRect.Contains(aPoint) || caretImageRect.Contains(aPoint);
 177 }
 178
 179 void AccessibleCaret::EnsureApzAware() {
 180   // If the caret element was cloned, the listener might have been lost. So
 181   // if that's the case we register a dummy listener if there isn't one on
 182   // the element already.
 183   if (!CaretElement().IsApzAware()) {
 184     CaretElement().AddEventListener(u"touchstart"_ns, mDummyTouchListener,
 185                                     false);
 186   }
 187 }
 188
 189 bool AccessibleCaret::IsInPositionFixedSubtree() const {
 190   return nsLayoutUtils::IsInPositionFixedSubtree(
 191       mImaginaryCaretReferenceFrame.GetFrame());
 192 }
 193
 194 void AccessibleCaret::InjectCaretElement(Document* aDocument) {
 195   mCaretElementHolder =
 196       aDocument->InsertAnonymousContent(/* aForce = */ false, IgnoreErrors());
 197   MOZ_RELEASE_ASSERT(mCaretElementHolder, "We must have anonymous content!");
 198
 199   CreateCaretElement();
 200   EnsureApzAware();
 201 }
 202
 203 void AccessibleCaret::CreateCaretElement() const {
 204   // Content structure of AccessibleCaret
 205   // <div class="moz-accessiblecaret">  <- CaretElement()
 206   //   <#shadow-root>
 207   //     <link rel="stylesheet" href="accessiblecaret.css">
 208   //     <div id="text-overlay">          <- TextOverlayElement()
 209   //     <div id="image">                 <- CaretImageElement()
 210
 211   constexpr bool kNotify = false;
 212
 213   Element& host = CaretElement();
 214   host.SetAttr(kNameSpaceID_None, nsGkAtoms::_class,
 215                u"moz-accessiblecaret none"_ns, kNotify);
 216
 217   ShadowRoot* root = mCaretElementHolder->Root();
 218   Document* doc = host.OwnerDoc();
 219   {
 220     RefPtr<NodeInfo> linkNodeInfo = doc->NodeInfoManager()->GetNodeInfo(
 221         nsGkAtoms::link, nullptr, kNameSpaceID_XHTML, nsINode::ELEMENT_NODE);
 222     RefPtr<nsGenericHTMLElement> link =
 223         NS_NewHTMLLinkElement(linkNodeInfo.forget());
 224     if (NS_WARN_IF(!link)) {
 225       return;
 226     }
 227     link->SetAttr(nsGkAtoms::rel, u"stylesheet"_ns, IgnoreErrors());
 228     link->SetAttr(nsGkAtoms::href,
 229                   u"resource://content-accessible/accessiblecaret.css"_ns,
 230                   IgnoreErrors());
 231     root->AppendChildTo(link, kNotify, IgnoreErrors());
 232   }
 233
 234   auto CreateAndAppendChildElement = [&](const nsLiteralString& aElementId) {
 235     RefPtr<Element> child = doc->CreateHTMLElement(nsGkAtoms::div);
 236     child->SetAttr(kNameSpaceID_None, nsGkAtoms::id, aElementId, kNotify);
 237     mCaretElementHolder->Root()->AppendChildTo(child, kNotify, IgnoreErrors());
 238   };
 239
 240   CreateAndAppendChildElement(kTextOverlayElementId);
 241   CreateAndAppendChildElement(kCaretImageElementId);
 242 }
 243
 244 void AccessibleCaret::RemoveCaretElement(Document* aDocument) {
 245   CaretElement().RemoveEventListener(u"touchstart"_ns, mDummyTouchListener,
 246                                      false);
 247
 248   aDocument->RemoveAnonymousContent(*mCaretElementHolder);
 249 }
 250
 251 void AccessibleCaret::ClearCachedData() {
 252   mImaginaryCaretRect = nsRect();
 253   mImaginaryCaretRectInContainerFrame = nsRect();
 254   mImaginaryCaretReferenceFrame = nullptr;
 255   mZoomLevel = 0.0f;
 256 }
 257
 258 AccessibleCaret::PositionChangedResult AccessibleCaret::SetPosition(
 259     nsIFrame* aFrame, int32_t aOffset) {
 260   if (!CustomContentContainerFrame()) {
 261     return PositionChangedResult::NotChanged;
 262   }
 263
 264   nsRect imaginaryCaretRectInFrame =
 265       nsCaret::GetGeometryForFrame(aFrame, aOffset, nullptr);
 266
 267   imaginaryCaretRectInFrame =
 268       nsLayoutUtils::ClampRectToScrollFrames(aFrame, imaginaryCaretRectInFrame);
 269
 270   if (imaginaryCaretRectInFrame.IsEmpty()) {
 271     // Don't bother to set the caret position since it's invisible.
 272     ClearCachedData();
 273     return PositionChangedResult::Invisible;
 274   }
 275
 276   // SetCaretElementStyle() requires the input rect relative to the custom
 277   // content container frame.
 278   nsRect imaginaryCaretRectInContainerFrame = imaginaryCaretRectInFrame;
 279   nsLayoutUtils::TransformRect(aFrame, CustomContentContainerFrame(),
 280                                imaginaryCaretRectInContainerFrame);
 281   const float zoomLevel = GetZoomLevel();
 282   const bool isSamePosition = imaginaryCaretRectInContainerFrame.IsEqualEdges(
 283       mImaginaryCaretRectInContainerFrame);
 284   const bool isSameZoomLevel = FuzzyEqualsMultiplicative(zoomLevel, mZoomLevel);
 285
 286   // Always update cached mImaginaryCaretRect (relative to the root frame)
 287   // because it can change when the caret is scrolled.
 288   mImaginaryCaretRect = imaginaryCaretRectInFrame;
 289   nsLayoutUtils::TransformRect(aFrame, RootFrame(), mImaginaryCaretRect);
 290
 291   if (isSamePosition && isSameZoomLevel) {
 292     return PositionChangedResult::NotChanged;
 293   }
 294
 295   mImaginaryCaretRectInContainerFrame = imaginaryCaretRectInContainerFrame;
 296   mImaginaryCaretReferenceFrame = aFrame;
 297   mZoomLevel = zoomLevel;
 298
 299   SetCaretElementStyle(imaginaryCaretRectInContainerFrame, mZoomLevel);
 300
 301   return isSamePosition ? PositionChangedResult::Zoom
 302                         : PositionChangedResult::Position;
 303 }
 304
 305 nsIFrame* AccessibleCaret::RootFrame() const {
 306   return mPresShell->GetRootFrame();
 307 }
 308
 309 nsIFrame* AccessibleCaret::CustomContentContainerFrame() const {
 310   nsCanvasFrame* canvasFrame = mPresShell->GetCanvasFrame();
 311   Element* container = canvasFrame->GetCustomContentContainer();
 312   nsIFrame* containerFrame = container->GetPrimaryFrame();
 313   return containerFrame;
 314 }
 315
 316 void AccessibleCaret::SetCaretElementStyle(const nsRect& aRect,
 317                                            float aZoomLevel) {
 318   nsPoint position = CaretElementPosition(aRect);
 319   nsAutoString styleStr;
 320   // We can't use AppendPrintf here, because it does locale-specific
 321   // formatting of floating-point values.
 322   styleStr.AppendLiteral("left: ");
 323   styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(position.x));
 324   styleStr.AppendLiteral("px; top: ");
 325   styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(position.y));
 326   styleStr.AppendLiteral("px; width: ");
 327   styleStr.AppendFloat(StaticPrefs::layout_accessiblecaret_width() /
 328                        aZoomLevel);
 329   styleStr.AppendLiteral("px; margin-left: ");
 330   styleStr.AppendFloat(StaticPrefs::layout_accessiblecaret_margin_left() /
 331                        aZoomLevel);
 332   styleStr.AppendLiteral("px; transition-duration: ");
 333   styleStr.AppendFloat(
 334       StaticPrefs::layout_accessiblecaret_transition_duration());
 335   styleStr.AppendLiteral("ms");
 336
 337   CaretElement().SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleStr, true);
 338   AC_LOG("%s: %s", __FUNCTION__, NS_ConvertUTF16toUTF8(styleStr).get());
 339
 340   // Set style string for children.
 341   SetTextOverlayElementStyle(aRect, aZoomLevel);
 342   SetCaretImageElementStyle(aRect, aZoomLevel);
 343 }
 344
 345 void AccessibleCaret::SetTextOverlayElementStyle(const nsRect& aRect,
 346                                                  float aZoomLevel) {
 347   nsAutoString styleStr;
 348   styleStr.AppendLiteral("height: ");
 349   styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(aRect.height));
 350   styleStr.AppendLiteral("px;");
 351   TextOverlayElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleStr,
 352                                 true);
 353   AC_LOG("%s: %s", __FUNCTION__, NS_ConvertUTF16toUTF8(styleStr).get());
 354 }
 355
 356 void AccessibleCaret::SetCaretImageElementStyle(const nsRect& aRect,
 357                                                 float aZoomLevel) {
 358   nsAutoString styleStr;
 359   styleStr.AppendLiteral("height: ");
 360   styleStr.AppendFloat(StaticPrefs::layout_accessiblecaret_height() /
 361                        aZoomLevel);
 362   styleStr.AppendLiteral("px;");
 363   CaretImageElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleStr,
 364                                true);
 365   AC_LOG("%s: %s", __FUNCTION__, NS_ConvertUTF16toUTF8(styleStr).get());
 366 }
 367
 368 float AccessibleCaret::GetZoomLevel() {
 369   // Full zoom on desktop.
 370   float fullZoom = mPresShell->GetPresContext()->GetFullZoom();
 371
 372   // Pinch-zoom on fennec.
 373   float resolution = mPresShell->GetCumulativeResolution();
 374
 375   return fullZoom * resolution;
 376 }
 377
 378 }  // namespace mozilla