layout/base/nsCSSRendering.h

   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 mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /* utility functions for drawing borders and backgrounds */
  39
  40 #ifndef nsCSSRendering_h___
  41 #define nsCSSRendering_h___
  42
  43 #include "nsIRenderingContext.h"
  44 #include "nsStyleConsts.h"
  45 #include "gfxBlur.h"
  46 #include "gfxContext.h"
  47 #include "gfxImageSurface.h"
  48
  49 struct nsPoint;
  50 class nsStyleContext;
  51 class nsPresContext;
  52
  53 struct nsCSSRendering {
  54   /**
  55    * Initialize any static variables used by nsCSSRendering.
  56    */
  57   static nsresult Init();
  58
  59   /**
  60    * Clean up any static variables used by nsCSSRendering.
  61    */
  62   static void Shutdown();
  63
  64   static void PaintBoxShadow(nsPresContext* aPresContext,
  65                              nsIRenderingContext& aRenderingContext,
  66                              nsIFrame* aForFrame,
  67                              const nsPoint& aForFramePt,
  68                              const nsRect& aDirtyRect);
  69
  70   /**
  71    * Render the border for an element using css rendering rules
  72    * for borders. aSkipSides is a bitmask of the sides to skip
  73    * when rendering. If 0 then no sides are skipped.
  74    *
  75    * Both aDirtyRect and aBorderArea are in the local coordinate space
  76    * of aForFrame
  77    */
  78   static void PaintBorder(nsPresContext* aPresContext,
  79                           nsIRenderingContext& aRenderingContext,
  80                           nsIFrame* aForFrame,
  81                           const nsRect& aDirtyRect,
  82                           const nsRect& aBorderArea,
  83                           const nsStyleBorder& aBorderStyle,
  84                           nsStyleContext* aStyleContext,
  85                           PRIntn aSkipSides = 0);
  86
  87   /**
  88    * Render the outline for an element using css rendering rules
  89    * for borders. aSkipSides is a bitmask of the sides to skip
  90    * when rendering. If 0 then no sides are skipped.
  91    *
  92    * Both aDirtyRect and aBorderArea are in the local coordinate space
  93    * of aForFrame
  94    */
  95   static void PaintOutline(nsPresContext* aPresContext,
  96                           nsIRenderingContext& aRenderingContext,
  97                           nsIFrame* aForFrame,
  98                           const nsRect& aDirtyRect,
  99                           const nsRect& aBorderArea,
 100                           const nsStyleBorder& aBorderStyle,
 101                           const nsStyleOutline& aOutlineStyle,
 102                           nsStyleContext* aStyleContext);
 103
 104   /**
 105    * Render keyboard focus on an element.
 106    * |aFocusRect| is the outer rectangle of the focused element.
 107    * Uses a fixed style equivalent to "1px dotted |aColor|".
 108    * Not used for controls, because the native theme may differ.
 109    */
 110   static void PaintFocus(nsPresContext* aPresContext,
 111                          nsIRenderingContext& aRenderingContext,
 112                          const nsRect& aFocusRect,
 113                          nscolor aColor);
 114
 115   /**
 116    * Fill in an nsStyleBackground to be used to paint the background for
 117    * an element.  The nsStyleBackground should first be initialized
 118    * using the pres context.  This applies the rules for propagating
 119    * backgrounds between BODY, the root element, and the canvas.
 120    * @return PR_TRUE if there is some meaningful background.
 121    */
 122   static PRBool FindBackground(nsPresContext* aPresContext,
 123                                nsIFrame* aForFrame,
 124                                const nsStyleBackground** aBackground,
 125                                PRBool* aIsCanvas);
 126
 127   /**
 128    * Find a non-transparent background, for various table-related and
 129    * HR-related backwards-compatibility hacks.  Be very hesitant if
 130    * you're considering calling this function -- it's usually not what
 131    * you want.
 132    */
 133   static const nsStyleBackground*
 134   FindNonTransparentBackground(nsStyleContext* aContext,
 135                                PRBool aStartAtParent = PR_FALSE);
 136
 137   /**
 138    * Render the background for an element using css rendering rules
 139    * for backgrounds.
 140    *
 141    * Both aDirtyRect and aBorderArea are in the local coordinate space
 142    * of aForFrame
 143    */
 144   static void PaintBackground(nsPresContext* aPresContext,
 145                               nsIRenderingContext& aRenderingContext,
 146                               nsIFrame* aForFrame,
 147                               const nsRect& aDirtyRect,
 148                               const nsRect& aBorderArea,
 149                               PRBool aUsePrintSettings,
 150                               nsRect* aBGClipRect = nsnull);
 151
 152   /**
 153    * Same as |PaintBackground|, except using the provided style structs.
 154    * This short-circuits the code that ensures that the root element's
 155    * background is drawn on the canvas.
 156    */
 157   static void PaintBackgroundWithSC(nsPresContext* aPresContext,
 158                                     nsIRenderingContext& aRenderingContext,
 159                                     nsIFrame* aForFrame,
 160                                     const nsRect& aDirtyRect,
 161                                     const nsRect& aBorderArea,
 162                                     const nsStyleBackground& aColor,
 163                                     const nsStyleBorder& aBorder,
 164                                     PRBool aUsePrintSettings = PR_FALSE,
 165                                     nsRect* aBGClipRect = nsnull);
 166
 167   /**
 168    * Called by the presShell when painting is finished, so we can clear our
 169    * inline background data cache.
 170    */
 171   static void DidPaint();
 172
 173   // Draw a border segment in the table collapsing border model without
 174   // beveling corners
 175   static void DrawTableBorderSegment(nsIRenderingContext& aContext,
 176                                      PRUint8              aBorderStyle,
 177                                      nscolor              aBorderColor,
 178                                      const nsStyleBackground* aBGColor,
 179                                      const nsRect&        aBorderRect,
 180                                      PRInt32              aAppUnitsPerCSSPixel,
 181                                      PRUint8              aStartBevelSide = 0,
 182                                      nscoord              aStartBevelOffset = 0,
 183                                      PRUint8              aEndBevelSide = 0,
 184                                      nscoord              aEndBevelOffset = 0);
 185
 186   /**
 187    * Function for painting the decoration lines for the text.
 188    * NOTE: aPt, aLineSize, aAscent and aOffset are non-rounded device pixels,
 189    *       not app units.
 190    *   input:
 191    *     @param aGfxContext
 192    *     @param aColor            the color of the decoration line
 193    *     @param aPt               the top/left edge of the text
 194    *     @param aLineSize         the width and the height of the decoration
 195    *                              line
 196    *     @param aAscent           the ascent of the text
 197    *     @param aOffset           the offset of the decoration line from
 198    *                              the baseline of the text (if the value is
 199    *                              positive, the line is lifted up)
 200    *     @param aDecoration       which line will be painted. The value can be
 201    *                              NS_STYLE_TEXT_DECORATION_UNDERLINE or
 202    *                              NS_STYLE_TEXT_DECORATION_OVERLINE or
 203    *                              NS_STYLE_TEXT_DECORATION_LINE_THROUGH.
 204    *     @param aStyle            the style of the decoration line. The value
 205    *                              can be NS_STYLE_BORDER_STYLE_SOLID or
 206    *                              NS_STYLE_BORDER_STYLE_DOTTED or
 207    *                              NS_STYLE_BORDER_STYLE_DASHED or
 208    *                              NS_STYLE_BORDER_STYLE_DOUBLE.
 209    */
 210   static void PaintDecorationLine(gfxContext* aGfxContext,
 211                                   const nscolor aColor,
 212                                   const gfxPoint& aPt,
 213                                   const gfxSize& aLineSize,
 214                                   const gfxFloat aAscent,
 215                                   const gfxFloat aOffset,
 216                                   const PRUint8 aDecoration,
 217                                   const PRUint8 aStyle);
 218
 219   /**
 220    * Function for getting the decoration line rect for the text.
 221    * NOTE: aLineSize, aAscent and aOffset are non-rounded device pixels,
 222    *       not app units.
 223    *   input:
 224    *     @param aPresContext
 225    *     @param aLineSize         the width and the height of the decoration
 226    *                              line
 227    *     @param aAscent           the ascent of the text
 228    *     @param aOffset           the offset of the decoration line from
 229    *                              the baseline of the text (if the value is
 230    *                              positive, the line is lifted up)
 231    *     @param aDecoration       which line will be painted. The value can be
 232    *                              NS_STYLE_TEXT_DECORATION_UNDERLINE or
 233    *                              NS_STYLE_TEXT_DECORATION_OVERLINE or
 234    *                              NS_STYLE_TEXT_DECORATION_LINE_THROUGH.
 235    *     @param aStyle            the style of the decoration line. The value
 236    *                              can be NS_STYLE_BORDER_STYLE_SOLID or
 237    *                              NS_STYLE_BORDER_STYLE_DOTTED or
 238    *                              NS_STYLE_BORDER_STYLE_DASHED or
 239    *                              NS_STYLE_BORDER_STYLE_DOUBLE.
 240    *   output:
 241    *     @return                  the decoration line rect for the input,
 242    *                              the each values are app units.
 243    */
 244   static nsRect GetTextDecorationRect(nsPresContext* aPresContext,
 245                                       const gfxSize& aLineSize,
 246                                       const gfxFloat aAscent,
 247                                       const gfxFloat aOffset,
 248                                       const PRUint8 aDecoration,
 249                                       const PRUint8 aStyle);
 250 };
 251
 252 /*
 253  * nsContextBoxBlur
 254  * Creates an 8-bit alpha channel context for callers to draw in, blurs the
 255  * contents of that context and applies it as a 1-color mask on a
 256  * different existing context. Uses gfxAlphaBoxBlur as its back end.
 257  *
 258  * You must call Init() first to create a suitable temporary surface to draw
 259  * on.  You must then draw any desired content onto the given context, then
 260  * call DoPaint() to apply the blurred content as a single-color mask. You
 261  * can only call Init() once, so objects cannot be reused.
 262  *
 263  * This is very useful for creating drop shadows or silhouettes.
 264  */
 265 class nsContextBoxBlur {
 266 public:
 267   /**
 268    * Prepares a gfxContext to draw on. Do not call this twice; if you want
 269    * to get the gfxContext again use GetContext().
 270    *
 271    * @param aRect                The coordinates of the surface to create.
 272    *                             All coordinates must be in app units.
 273    *                             This must not include the blur radius, pass
 274    *                             it as the second parameter and everything
 275    *                             is taken care of.
 276    *
 277    * @param aBlurRadius          The blur radius in app units.
 278    *
 279    * @param aAppUnitsPerDevPixel The number of app units in a device pixel,
 280    *                             for conversion.  Most of the time you'll
 281    *                             pass this from the current PresContext if
 282    *                             available.
 283    *
 284    * @param aDestinationCtx      The graphics context to apply the blurred
 285    *                             mask to when you call DoPaint(). Make sure
 286    *                             it is not destroyed before you call
 287    *                             DoPaint(). To set the color of the
 288    *                             resulting blurred graphic mask, you must
 289    *                             set the color on this context before
 290    *                             calling Init().
 291    *
 292    * @param aDirtyRect           The absolute dirty rect in app units. Used to
 293    *                             optimize the temporary surface size and speed up blur.
 294    *
 295    * @return            A blank 8-bit alpha-channel-only graphics context to
 296    *                    draw on, or null on error. Must not be freed. The
 297    *                    context has a device offset applied to it given by
 298    *                    aRect. This means you can use coordinates as if it
 299    *                    were at the desired position at aRect and you don't
 300    *                    need to worry about translating any coordinates to
 301    *                    draw on this temporary surface.
 302    *
 303    * If aBlurRadius is 0, the returned context is aDestinationCtx and
 304    * DoPaint() does nothing, because no blurring is required. Therefore, you
 305    * should prepare the destination context as if you were going to draw
 306    * directly on it instead of any temporary surface created in this class.
 307    */
 308   gfxContext* Init(const gfxRect& aRect, nscoord aBlurRadius,
 309                    PRInt32 aAppUnitsPerDevPixel, gfxContext* aDestinationCtx,
 310                    const gfxRect& aDirtyRect);
 311
 312   /**
 313    * Does the actual blurring and mask applying. Users of this object *must*
 314    * have called Init() first, then have drawn whatever they want to be
 315    * blurred onto the internal gfxContext before calling this.
 316    */
 317   void DoPaint();
 318
 319   /**
 320    * Gets the internal gfxContext at any time. Must not be freed. Avoid
 321    * calling this before calling Init() since the context would not be
 322    * constructed at that point.
 323    */
 324   gfxContext* GetContext();
 325
 326 protected:
 327   gfxAlphaBoxBlur blur;
 328   nsRefPtr<gfxContext> mContext;
 329   gfxContext* mDestinationCtx;
 330
 331 };
 332
 333 #endif /* nsCSSRendering_h___ */