layout/svg/base/src/nsSVGTextFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is the Mozilla SVG project.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Crocodile Clips Ltd..
  19  * Portions created by the Initial Developer are Copyright (C) 2002
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Alex Fritze <alex.fritze@crocodile-clips.com> (original author)
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsIDOMSVGTextElement.h"
  40 #include "nsSVGTextFrame.h"
  41 #include "nsWeakReference.h"
  42 #include "SVGLengthList.h"
  43 #include "nsIDOMSVGLength.h"
  44 #include "nsIDOMSVGAnimatedNumber.h"
  45 #include "nsISVGGlyphFragmentNode.h"
  46 #include "nsISVGGlyphFragmentLeaf.h"
  47 #include "nsSVGOuterSVGFrame.h"
  48 #include "nsIDOMSVGRect.h"
  49 #include "nsSVGRect.h"
  50 #include "nsSVGMatrix.h"
  51 #include "nsGkAtoms.h"
  52 #include "nsSVGTextPathFrame.h"
  53 #include "nsSVGPathElement.h"
  54 #include "nsSVGUtils.h"
  55 #include "nsSVGGraphicElement.h"
  56
  57 using namespace mozilla;
  58
  59 //----------------------------------------------------------------------
  60 // Implementation
  61
  62 nsIFrame*
  63 NS_NewSVGTextFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
  64 {
  65   return new (aPresShell) nsSVGTextFrame(aContext);
  66 }
  67
  68 NS_IMPL_FRAMEARENA_HELPERS(nsSVGTextFrame)
  69
  70 //----------------------------------------------------------------------
  71 // nsIFrame methods
  72 #ifdef DEBUG
  73 NS_IMETHODIMP
  74 nsSVGTextFrame::Init(nsIContent* aContent,
  75                      nsIFrame* aParent,
  76                      nsIFrame* aPrevInFlow)
  77 {
  78   nsCOMPtr<nsIDOMSVGTextElement> text = do_QueryInterface(aContent);
  79   NS_ASSERTION(text, "Content is not an SVG text");
  80
  81   return nsSVGTextFrameBase::Init(aContent, aParent, aPrevInFlow);
  82 }
  83 #endif /* DEBUG */
  84
  85 NS_IMETHODIMP
  86 nsSVGTextFrame::AttributeChanged(PRInt32         aNameSpaceID,
  87                                  nsIAtom*        aAttribute,
  88                                  PRInt32         aModType)
  89 {
  90   if (aNameSpaceID != kNameSpaceID_None)
  91     return NS_OK;
  92
  93   if (aAttribute == nsGkAtoms::transform) {
  94     // transform has changed
  95
  96     // make sure our cached transform matrix gets (lazily) updated
  97     mCanvasTM = nsnull;
  98
  99     nsSVGUtils::NotifyChildrenOfSVGChange(this, TRANSFORM_CHANGED);
 100
 101   } else if (aAttribute == nsGkAtoms::x ||
 102              aAttribute == nsGkAtoms::y ||
 103              aAttribute == nsGkAtoms::dx ||
 104              aAttribute == nsGkAtoms::dy ||
 105              aAttribute == nsGkAtoms::rotate) {
 106     NotifyGlyphMetricsChange();
 107   }
 108
 109  return NS_OK;
 110 }
 111
 112 nsIAtom *
 113 nsSVGTextFrame::GetType() const
 114 {
 115   return nsGkAtoms::svgTextFrame;
 116 }
 117
 118 //----------------------------------------------------------------------
 119 // nsSVGTextContainerFrame
 120 PRUint32
 121 nsSVGTextFrame::GetNumberOfChars()
 122 {
 123   UpdateGlyphPositioning(PR_FALSE);
 124
 125   return nsSVGTextFrameBase::GetNumberOfChars();
 126 }
 127
 128 float
 129 nsSVGTextFrame::GetComputedTextLength()
 130 {
 131   UpdateGlyphPositioning(PR_FALSE);
 132
 133   return nsSVGTextFrameBase::GetComputedTextLength();
 134 }
 135
 136 float
 137 nsSVGTextFrame::GetSubStringLength(PRUint32 charnum, PRUint32 nchars)
 138 {
 139   UpdateGlyphPositioning(PR_FALSE);
 140
 141   return nsSVGTextFrameBase::GetSubStringLength(charnum, nchars);
 142 }
 143
 144 PRInt32
 145 nsSVGTextFrame::GetCharNumAtPosition(nsIDOMSVGPoint *point)
 146 {
 147   UpdateGlyphPositioning(PR_FALSE);
 148
 149   return nsSVGTextFrameBase::GetCharNumAtPosition(point);
 150 }
 151
 152 NS_IMETHODIMP
 153 nsSVGTextFrame::GetStartPositionOfChar(PRUint32 charnum, nsIDOMSVGPoint **_retval)
 154 {
 155   UpdateGlyphPositioning(PR_FALSE);
 156
 157   return nsSVGTextFrameBase::GetStartPositionOfChar(charnum,  _retval);
 158 }
 159
 160 NS_IMETHODIMP
 161 nsSVGTextFrame::GetEndPositionOfChar(PRUint32 charnum, nsIDOMSVGPoint **_retval)
 162 {
 163   UpdateGlyphPositioning(PR_FALSE);
 164
 165   return nsSVGTextFrameBase::GetEndPositionOfChar(charnum,  _retval);
 166 }
 167
 168 NS_IMETHODIMP
 169 nsSVGTextFrame::GetExtentOfChar(PRUint32 charnum, nsIDOMSVGRect **_retval)
 170 {
 171   UpdateGlyphPositioning(PR_FALSE);
 172
 173   return nsSVGTextFrameBase::GetExtentOfChar(charnum,  _retval);
 174 }
 175
 176 NS_IMETHODIMP
 177 nsSVGTextFrame::GetRotationOfChar(PRUint32 charnum, float *_retval)
 178 {
 179   UpdateGlyphPositioning(PR_FALSE);
 180
 181   return nsSVGTextFrameBase::GetRotationOfChar(charnum,  _retval);
 182 }
 183
 184 //----------------------------------------------------------------------
 185 // nsISVGChildFrame methods
 186
 187 void
 188 nsSVGTextFrame::NotifySVGChanged(PRUint32 aFlags)
 189 {
 190   if (aFlags & TRANSFORM_CHANGED) {
 191     // make sure our cached transform matrix gets (lazily) updated
 192     mCanvasTM = nsnull;
 193   }
 194
 195   nsSVGTextFrameBase::NotifySVGChanged(aFlags);
 196
 197   if (aFlags & COORD_CONTEXT_CHANGED) {
 198     // If we are positioned using percentage values we need to update our
 199     // position whenever our viewport's dimensions change.
 200
 201     // XXX We could check here whether the text frame or any of its children
 202     // have any percentage co-ordinates and only update if they don't. This
 203     // may not be worth it as we might need to check each glyph
 204     NotifyGlyphMetricsChange();
 205   }
 206 }
 207
 208 NS_IMETHODIMP
 209 nsSVGTextFrame::NotifyRedrawSuspended()
 210 {
 211   mMetricsState = suspended;
 212
 213   return nsSVGTextFrameBase::NotifyRedrawSuspended();
 214 }
 215
 216 NS_IMETHODIMP
 217 nsSVGTextFrame::NotifyRedrawUnsuspended()
 218 {
 219   mMetricsState = unsuspended;
 220   UpdateGlyphPositioning(PR_FALSE);
 221   return nsSVGTextFrameBase::NotifyRedrawUnsuspended();
 222 }
 223
 224 NS_IMETHODIMP
 225 nsSVGTextFrame::PaintSVG(nsSVGRenderState* aContext,
 226                          const nsIntRect *aDirtyRect)
 227 {
 228   UpdateGlyphPositioning(PR_TRUE);
 229
 230   return nsSVGTextFrameBase::PaintSVG(aContext, aDirtyRect);
 231 }
 232
 233 NS_IMETHODIMP_(nsIFrame*)
 234 nsSVGTextFrame::GetFrameForPoint(const nsPoint &aPoint)
 235 {
 236   UpdateGlyphPositioning(PR_TRUE);
 237
 238   return nsSVGTextFrameBase::GetFrameForPoint(aPoint);
 239 }
 240
 241 NS_IMETHODIMP
 242 nsSVGTextFrame::UpdateCoveredRegion()
 243 {
 244   UpdateGlyphPositioning(PR_TRUE);
 245
 246   return nsSVGTextFrameBase::UpdateCoveredRegion();
 247 }
 248
 249 NS_IMETHODIMP
 250 nsSVGTextFrame::InitialUpdate()
 251 {
 252   nsresult rv = nsSVGTextFrameBase::InitialUpdate();
 253
 254   UpdateGlyphPositioning(PR_FALSE);
 255
 256   return rv;
 257 }
 258
 259 gfxRect
 260 nsSVGTextFrame::GetBBoxContribution(const gfxMatrix &aToBBoxUserspace)
 261 {
 262   UpdateGlyphPositioning(PR_TRUE);
 263
 264   return nsSVGTextFrameBase::GetBBoxContribution(aToBBoxUserspace);
 265 }
 266
 267 //----------------------------------------------------------------------
 268 // nsSVGContainerFrame methods:
 269
 270 gfxMatrix
 271 nsSVGTextFrame::GetCanvasTM()
 272 {
 273   if (!mCanvasTM) {
 274     NS_ASSERTION(mParent, "null parent");
 275
 276     nsSVGContainerFrame *parent = static_cast<nsSVGContainerFrame*>(mParent);
 277     nsSVGGraphicElement *content = static_cast<nsSVGGraphicElement*>(mContent);
 278
 279     gfxMatrix tm = content->PrependLocalTransformTo(parent->GetCanvasTM());
 280
 281     mCanvasTM = NS_NewSVGMatrix(tm);
 282   }
 283
 284   return nsSVGUtils::ConvertSVGMatrixToThebes(mCanvasTM);
 285 }
 286
 287 //----------------------------------------------------------------------
 288 //
 289
 290 void
 291 nsSVGTextFrame::NotifyGlyphMetricsChange()
 292 {
 293   mPositioningDirty = PR_TRUE;
 294   UpdateGlyphPositioning(PR_FALSE);
 295 }
 296
 297 void
 298 nsSVGTextFrame::UpdateGlyphPositioning(PRBool aForceGlobalTransform)
 299 {
 300   if (mMetricsState == suspended || !mPositioningDirty)
 301     return;
 302
 303   SetWhitespaceHandling();
 304
 305   nsISVGGlyphFragmentNode* node = GetFirstGlyphFragmentChildNode();
 306   if (!node) return;
 307
 308   mPositioningDirty = PR_FALSE;
 309
 310   nsISVGGlyphFragmentLeaf *fragment, *firstFragment;
 311
 312   firstFragment = node->GetFirstGlyphFragment();
 313   if (!firstFragment) {
 314     return;
 315   }
 316
 317   BuildPositionList(0, 0);
 318
 319   gfxPoint ctp(0.0, 0.0);
 320
 321   // loop over chunks
 322   while (firstFragment) {
 323     nsSVGTextPathFrame *textPath = firstFragment->FindTextPathParent();
 324
 325     nsTArray<float> effectiveXList, effectiveYList;
 326     firstFragment->GetEffectiveXY(firstFragment->GetNumberOfChars(),
 327                                   effectiveXList, effectiveYList);
 328     if (!effectiveXList.IsEmpty()) ctp.x = effectiveXList[0];
 329     if (!textPath && !effectiveYList.IsEmpty()) ctp.y = effectiveYList[0];
 330
 331     // check for startOffset on textPath
 332     if (textPath) {
 333       if (!textPath->GetPathFrame()) {
 334         // invalid text path, give up
 335         return;
 336       }
 337       ctp.x = textPath->GetStartOffset();
 338     }
 339
 340     // determine x offset based on text_anchor:
 341
 342     PRUint8 anchor = firstFragment->GetTextAnchor();
 343
 344     /**
 345      * XXXsmontagu: The SVG spec is very vague as to how 'text-anchor'
 346      *  interacts with bidirectional text. It says:
 347      *
 348      *   "For scripts that are inherently right to left such as Hebrew and
 349      *   Arabic [text-anchor: start] is equivalent to right alignment."
 350      * and
 351      *   "For scripts that are inherently right to left such as Hebrew and
 352      *   Arabic, [text-anchor: end] is equivalent to left alignment.
 353      *
 354      * It's not clear how this should be implemented in terms of defined
 355      * properties, i.e. how one should determine that a particular element
 356      * contains a script that is inherently right to left.
 357      *
 358      * The code below follows http://www.w3.org/TR/SVGTiny12/text.html#TextAnchorProperty
 359      * and swaps the values of text-anchor: end and  text-anchor: start
 360      * whenever the 'direction' property is rtl.
 361      *
 362      * This is probably the "right" thing to do, but other browsers don't do it,
 363      * so I am leaving it inside #if 0 for now for interoperability.
 364      *
 365      * See also XXXsmontagu comments in nsSVGGlyphFrame::EnsureTextRun
 366      */
 367 #if 0
 368     if (GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) {
 369       if (anchor == NS_STYLE_TEXT_ANCHOR_END) {
 370         anchor = NS_STYLE_TEXT_ANCHOR_START;
 371       } else if (anchor == NS_STYLE_TEXT_ANCHOR_START) {
 372         anchor = NS_STYLE_TEXT_ANCHOR_END;
 373       }
 374     }
 375 #endif
 376
 377     float chunkLength = 0.0f;
 378     if (anchor != NS_STYLE_TEXT_ANCHOR_START) {
 379       // need to get the total chunk length
 380
 381       fragment = firstFragment;
 382       while (fragment) {
 383         chunkLength += fragment->GetAdvance(aForceGlobalTransform);
 384         fragment = fragment->GetNextGlyphFragment();
 385         if (fragment && fragment->IsAbsolutelyPositioned())
 386           break;
 387       }
 388     }
 389
 390     if (anchor == NS_STYLE_TEXT_ANCHOR_MIDDLE)
 391       ctp.x -= chunkLength/2.0f;
 392     else if (anchor == NS_STYLE_TEXT_ANCHOR_END)
 393       ctp.x -= chunkLength;
 394
 395     // set position of each fragment in this chunk:
 396
 397     fragment = firstFragment;
 398     while (fragment) {
 399
 400       fragment->SetGlyphPosition(&ctp, aForceGlobalTransform);
 401       fragment = fragment->GetNextGlyphFragment();
 402       if (fragment && fragment->IsAbsolutelyPositioned())
 403         break;
 404     }
 405     firstFragment = fragment;
 406   }
 407   nsSVGUtils::UpdateGraphic(this);
 408 }