tools/relic/test/relicense_outputs/npl.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Netscape Public License
   6  * Version 1.1 (the "License"); you may not use this file except in
   7  * compliance with the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/NPL/
   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  *   Daniel Glazman <glazman@netscape.com>, foo@bar.org
  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 NPL, 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 NPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #ifndef nsHTMLCSSUtils_h__
  40 #define nsHTMLCSSUtils_h__
  41
  42 #include "nsCOMPtr.h"
  43 #include "nsString.h"
  44 #include "nsIDOMViewCSS.h"
  45 #include "nsIDOMNode.h"
  46 #include "nsIDOMElement.h"
  47 #include "nsIHTMLEditor.h"
  48 #include "ChangeCSSInlineStyleTxn.h"
  49 #include "nsEditProperty.h"
  50 #include "nsIDOMCSSStyleDeclaration.h"
  51
  52 #define SPECIFIED_STYLE_TYPE    1
  53 #define COMPUTED_STYLE_TYPE     2
  54
  55 class nsHTMLEditor;
  56
  57 typedef void (*nsProcessValueFunc)(const nsAString * aInputString, nsAString & aOutputString,
  58                                    const char * aDefaultValueString,
  59                                    const char * aPrependString, const char* aAppendString);
  60
  61 class nsHTMLCSSUtils
  62 {
  63 public:
  64   nsHTMLCSSUtils();
  65   ~nsHTMLCSSUtils();
  66
  67   enum nsCSSEditableProperty {
  68     eCSSEditableProperty_NONE=0,
  69     eCSSEditableProperty_background_color,
  70     eCSSEditableProperty_background_image,
  71     eCSSEditableProperty_border,
  72     eCSSEditableProperty_caption_side,
  73     eCSSEditableProperty_color,
  74     eCSSEditableProperty_float,
  75     eCSSEditableProperty_font_family,
  76     eCSSEditableProperty_font_size,
  77     eCSSEditableProperty_font_style,
  78     eCSSEditableProperty_font_weight,
  79     eCSSEditableProperty_height,
  80     eCSSEditableProperty_list_style_type,
  81     eCSSEditableProperty_margin_left,
  82     eCSSEditableProperty_margin_right,
  83     eCSSEditableProperty_text_align,
  84     eCSSEditableProperty_text_decoration,
  85     eCSSEditableProperty_vertical_align,
  86     eCSSEditableProperty_whitespace,
  87     eCSSEditableProperty_width
  88   };
  89
  90
  91   struct CSSEquivTable {
  92     nsCSSEditableProperty cssProperty;
  93     nsProcessValueFunc processValueFunctor;
  94     const char * defaultValue;
  95     const char * prependValue;
  96     const char * appendValue;
  97     PRBool gettable;
  98     PRBool caseSensitiveValue;
  99   };
 100
 101 public:
 102   nsresult    Init(nsHTMLEditor * aEditor);
 103
 104   /** answers true if the given combination element_name/attribute_name
 105     * has a CSS equivalence in this implementation
 106     *
 107     * @return               a boolean saying if the tag/attribute has a css equiv
 108     * @param aNode          [IN] a DOM node
 109     * @param aProperty      [IN] an atom containing a HTML tag name
 110     * @param aAttribute     [IN] a string containing the name of a HTML attribute carried by the element above
 111     */
 112   PRBool      IsCSSEditableProperty(nsIDOMNode * aNode, nsIAtom * aProperty, const nsAString * aAttribute);
 113
 114   /** adds/remove a CSS declaration to the STYLE atrribute carried by a given element
 115     *
 116     * @param aElement       [IN] a DOM element
 117     * @param aProperty      [IN] an atom containing the CSS property to set
 118     * @param aValue         [IN] a string containing the value of the CSS property
 119     * @param aSuppressTransaction [IN] a boolean indicating, when true,
 120     *                                  that no transaction should be recorded
 121     */
 122   nsresult    SetCSSProperty(nsIDOMElement * aElement, nsIAtom * aProperty,
 123                              const nsAString & aValue,
 124                              PRBool aSuppressTransaction);
 125   nsresult    RemoveCSSProperty(nsIDOMElement * aElement, nsIAtom * aProperty,
 126                                 const nsAString & aPropertyValue, PRBool aSuppressTransaction);
 127
 128   /** directly adds/remove a CSS declaration to the STYLE atrribute carried by
 129     * a given element without going through the txn manager
 130     *
 131     * @param aElement       [IN] a DOM element
 132     * @param aProperty      [IN] a string containing the CSS property to set/remove
 133     * @param aValue         [IN] a string containing the new value of the CSS property
 134     */
 135   nsresult    SetCSSProperty(nsIDOMElement * aElement,
 136                              const nsAString & aProperty,
 137                              const nsAString & aValue);
 138   nsresult    RemoveCSSProperty(nsIDOMElement * aElement,
 139                                 const nsAString & aProperty);
 140
 141   /** gets the specified/computed style value of a CSS property for a given node (or its element
 142     * ancestor if it is not an element)
 143     *
 144     * @param aNode          [IN] a DOM node
 145     * @param aProperty      [IN] an atom containing the CSS property to get
 146     * @param aPropertyValue [OUT] the retrieved value of the property
 147     */
 148   nsresult    GetSpecifiedProperty(nsIDOMNode *aNode, nsIAtom *aProperty,
 149                                    nsAString & aValue);
 150   nsresult    GetComputedProperty(nsIDOMNode *aNode, nsIAtom *aProperty,
 151                                   nsAString & aValue);
 152
 153   /** Removes a CSS property from the specified declarations in STYLE attribute
 154    ** and removes the node if it is an useless span
 155    *
 156    * @param aNode           [IN] the specific node we want to remove a style from
 157    * @param aProperty       [IN] the CSS property atom to remove
 158    * @param aPropertyValue  [IN] the value of the property we have to rremove if the property
 159    *                             accepts more than one value
 160    */
 161   nsresult    RemoveCSSInlineStyle(nsIDOMNode * aNode, nsIAtom * aProperty, const nsAString & aPropertyValue);
 162
 163    /** Answers true is the property can be removed by setting a "none" CSS value
 164      * on a node
 165      *
 166      * @return              a boolean saying if the property can be remove by setting a "none" value
 167      * @param aProperty     [IN] an atom containing a CSS property
 168      * @param aAttribute    [IN] pointer to an attribute name or null if this information is irrelevant
 169      */
 170   PRBool      IsCSSInvertable(nsIAtom * aProperty, const nsAString * aAttribute);
 171
 172   /** Get the default browser background color if we need it for GetCSSBackgroundColorState
 173     *
 174     * @param aColor         [OUT] the default color as it is defined in prefs
 175     */
 176   nsresult    GetDefaultBackgroundColor(nsAString & aColor);
 177
 178   /** Get the default length unit used for CSS Indent/Outdent
 179     *
 180     * @param aLengthUnit    [OUT] the default length unit as it is defined in prefs
 181     */
 182   nsresult    GetDefaultLengthUnit(nsAString & aLengthUnit);
 183
 184   /** asnwers true if the element aElement carries an ID or a class
 185     *
 186     * @param aElement       [IN] a DOM element
 187     * @param aReturn        [OUT] the boolean answer
 188     */
 189   nsresult    HasClassOrID(nsIDOMElement * aElement, PRBool & aReturn);
 190
 191   /** returns the list of values for the CSS equivalences to
 192     * the passed HTML style for the passed node
 193     *
 194     * @param aNode          [IN] a DOM node
 195     * @param aHTMLProperty  [IN] an atom containing an HTML property
 196     * @param aAttribute     [IN] a pointer to an attribute name or nsnull if irrelevant
 197     * @param aValueString   [OUT] the list of css values
 198     * @param aStyleType     [IN] SPECIFIED_STYLE_TYPE to query the specified style values
 199                                  COMPUTED_STYLE_TYPE  to query the computed style values
 200     */
 201   nsresult    GetCSSEquivalentToHTMLInlineStyleSet(nsIDOMNode * aNode,
 202                                                    nsIAtom * aHTMLProperty,
 203                                                    const nsAString * aAttribute,
 204                                                    nsAString & aValueString,
 205                                                    PRUint8 aStyleType);
 206
 207   /** Does the node aNode (or his parent if it is not an element node) carries
 208     * the CSS equivalent styles to the HTML style for this node ?
 209     *
 210     * @param aNode          [IN] a DOM node
 211     * @param aHTMLProperty  [IN] an atom containing an HTML property
 212     * @param aAttribute     [IN] a pointer to an attribute name or nsnull if irrelevant
 213     * @param aIsSet         [OUT] a boolean being true if the css properties are set
 214     * @param aValueString   [IN/OUT] the attribute value (in) the list of css values (out)
 215     * @param aStyleType     [IN] SPECIFIED_STYLE_TYPE to query the specified style values
 216                                  COMPUTED_STYLE_TYPE  to query the computed style values
 217     */
 218   nsresult    IsCSSEquivalentToHTMLInlineStyleSet(nsIDOMNode * aNode,
 219                                                   nsIAtom * aHTMLProperty,
 220                                                   const nsAString * aAttribute,
 221                                                   PRBool & aIsSet,
 222                                                   nsAString & aValueString,
 223                                                   PRUint8 aStyleType);
 224
 225   /** Adds to the node the CSS inline styles equivalent to the HTML style
 226     * and return the number of CSS properties set by the call
 227     *
 228     * @param aNode          [IN] a DOM node
 229     * @param aHTMLProperty  [IN] an atom containing an HTML property
 230     * @param aAttribute     [IN] a pointer to an attribute name or nsnull if irrelevant
 231     * @param aValue         [IN] the attribute value
 232     * @param aCount         [OUT] the number of CSS properties set by the call
 233     * @param aSuppressTransaction [IN] a boolean indicating, when true,
 234     *                                  that no transaction should be recorded
 235     */
 236   nsresult    SetCSSEquivalentToHTMLStyle(nsIDOMNode * aNode,
 237                                           nsIAtom * aHTMLProperty,
 238                                           const nsAString * aAttribute,
 239                                           const nsAString * aValue,
 240                                           PRInt32 * aCount,
 241                                           PRBool aSuppressTransaction);
 242
 243   /** removes from the node the CSS inline styles equivalent to the HTML style
 244     *
 245     * @param aNode          [IN] a DOM node
 246     * @param aHTMLProperty  [IN] an atom containing an HTML property
 247     * @param aAttribute     [IN] a pointer to an attribute name or nsnull if irrelevant
 248     * @param aValue         [IN] the attribute value
 249     * @param aSuppressTransaction [IN] a boolean indicating, when true,
 250     *                                  that no transaction should be recorded
 251     */
 252   nsresult    RemoveCSSEquivalentToHTMLStyle(nsIDOMNode * aNode,
 253                                              nsIAtom *aHTMLProperty,
 254                                              const nsAString *aAttribute,
 255                                              const nsAString *aValue,
 256                                              PRBool aSuppressTransaction);
 257
 258   /** parses a "xxxx.xxxxxuuu" string where x is a digit and u an alpha char
 259     * we need such a parser because nsIDOMCSSStyleDeclaration::GetPropertyCSSValue() is not
 260     * implemented
 261     *
 262     * @param aString        [IN] input string to parse
 263     * @param aValue         [OUT] numeric part
 264     * @param aUnit          [OUT] unit part
 265     */
 266   void        ParseLength(const nsAString & aString, float * aValue, nsIAtom ** aUnit);
 267
 268   /** sets the mIsCSSPrefChecked private member ; used as callback from observer when
 269     * the css pref state is changed
 270     *
 271     * @param aIsCSSPrefChecked [IN] the new boolean state for the pref
 272     */
 273   nsresult    SetCSSEnabled(PRBool aIsCSSPrefChecked);
 274
 275   /** retrieves the mIsCSSPrefChecked private member, true if the css pref is checked,
 276     * false if it is not
 277     *
 278     * @return                 the boolean value of the css pref
 279     */
 280   PRBool      IsCSSPrefChecked();
 281
 282   /** ElementsSameStyle compares two elements and checks if they have the same
 283     * specified CSS declarations in the STYLE attribute
 284     * The answer is always false if at least one of them carries an ID or a class
 285     *
 286     * @return                     true if the two elements are considered to have same styles
 287     * @param aFirstNode           [IN] a DOM node
 288     * @param aSecondNode          [IN] a DOM node
 289     */
 290   PRBool ElementsSameStyle(nsIDOMNode *aFirstNode, nsIDOMNode *aSecondNode);
 291
 292   /** get the specified inline styles (style attribute) for an element
 293     *
 294     * @param aElement        [IN] the element node
 295     * @param aCssDecl        [OUT] the CSS declaration corresponding to the style attr
 296     * @param aLength         [OUT] the number of declarations in aCssDecl
 297     */
 298   nsresult GetInlineStyles(nsIDOMElement * aElement, nsIDOMCSSStyleDeclaration ** aCssDecl,
 299                            PRUint32 * aLength);
 300
 301   /** returns aNode itself if it is an element node, or the first ancestors being an element
 302     * node if aNode is not one itself
 303     *
 304     * @param aNode           [IN] a node
 305     * @param aElement        [OUT] the deepest element node containing aNode (possibly aNode itself)
 306     */
 307   nsresult GetElementContainerOrSelf(nsIDOMNode * aNode, nsIDOMElement ** aElement);
 308
 309   /** Gets the default DOMView for a given node
 310    *
 311    * @param aNode               the node we want the default DOMView for
 312    * @param aViewCSS            [OUT] the default DOMViewCSS
 313    */
 314   nsresult        GetDefaultViewCSS(nsIDOMNode * aNode, nsIDOMViewCSS ** aViewCSS);
 315
 316
 317 private:
 318
 319   /** retrieves the css property atom from an enum
 320     *
 321     * @param aProperty          [IN] the enum value for the property
 322     * @param aAtom              [OUT] the corresponding atom
 323     */
 324   void  GetCSSPropertyAtom(nsCSSEditableProperty aProperty, nsIAtom ** aAtom);
 325
 326   /** retrieves the CSS declarations equivalent to a HTML style value for
 327     * a given equivalence table
 328     *
 329     * @param aPropertyArray     [OUT] the array of css properties
 330     * @param aValueArray        [OUT] the array of values for the css properties above
 331     * @param aEquivTable        [IN] the equivalence table
 332     * @param aValue             [IN] the HTML style value
 333     * @param aGetOrRemoveRequest [IN] a boolean value being true if the call to the current method
 334     *                                 is made for GetCSSEquivalentToHTMLInlineStyleSet or
 335     *                                 RemoveCSSEquivalentToHTMLInlineStyleSet
 336     */
 337
 338   void      BuildCSSDeclarations(nsVoidArray & aPropertyArray,
 339                                  nsStringArray & cssValueArray,
 340                                  const CSSEquivTable * aEquivTable,
 341                                  const nsAString * aValue,
 342                                  PRBool aGetOrRemoveRequest);
 343
 344   /** retrieves the CSS declarations equivalent to the given HTML property/attribute/value
 345     * for a given node
 346     *
 347     * @param aNode              [IN] the DOM node
 348     * @param aHTMLProperty      [IN] an atom containing an HTML property
 349     * @param aAttribute         [IN] a pointer to an attribute name or nsnull if irrelevant
 350     * @param aValue             [IN] the attribute value
 351     * @param aPropertyArray     [OUT] the array of css properties
 352     * @param aValueArray        [OUT] the array of values for the css properties above
 353     * @param aGetOrRemoveRequest [IN] a boolean value being true if the call to the current method
 354     *                                 is made for GetCSSEquivalentToHTMLInlineStyleSet or
 355     *                                 RemoveCSSEquivalentToHTMLInlineStyleSet
 356     */
 357   void      GenerateCSSDeclarationsFromHTMLStyle(nsIDOMNode * aNode,
 358                                                  nsIAtom * aHTMLProperty,
 359                                                  const nsAString *aAttribute,
 360                                                  const nsAString *aValue,
 361                                                  nsVoidArray & aPropertyArray,
 362                                                  nsStringArray & aValueArray,
 363                                                  PRBool aGetOrRemoveRequest);
 364
 365   /** creates a Transaction for setting or removing a css property
 366     *
 367     * @param aElement           [IN] a DOM element
 368     * @param aProperty          [IN] a CSS property
 369     * @param aValue             [IN] the value to remove for this CSS property or the empty string if irrelevant
 370     * @param aTxn               [OUT] the created transaction
 371     * @param aRemoveProperty    [IN] true if we create a "remove" transaction, false for a "set"
 372     */
 373   nsresult    CreateCSSPropertyTxn(nsIDOMElement * aElement,
 374                                    nsIAtom * aProperty,
 375                                    const nsAString & aValue,
 376                                    ChangeCSSInlineStyleTxn ** aTxn,
 377                                    PRBool aRemoveProperty);
 378
 379   /** back-end for GetSpecifiedProperty and GetComputedProperty
 380     *
 381     * @param aNode               [IN] a DOM node
 382     * @param aProperty           [IN] a CSS property
 383     * @param aValue              [OUT] the retrieved value for this property
 384     * @param aViewCSS            [IN] the ViewCSS we need in case we query computed styles
 385     * @param aStyleType          [IN] SPECIFIED_STYLE_TYPE to query the specified style values
 386                                       COMPUTED_STYLE_TYPE  to query the computed style values
 387     */
 388   nsresult    GetCSSInlinePropertyBase(nsIDOMNode * aNode, nsIAtom * aProperty,
 389                                        nsAString & aValue,
 390                                        nsIDOMViewCSS * aViewCSS,
 391                                        PRUint8 aStyleType);
 392
 393
 394 private:
 395   nsHTMLEditor            *mHTMLEditor;
 396   PRBool                  mIsCSSPrefChecked;
 397
 398 };
 399
 400 nsresult NS_NewHTMLCSSUtils(nsHTMLCSSUtils** aInstancePtrResult);
 401
 402 #define NS_EDITOR_INDENT_INCREMENT_IN        0.4134f
 403 #define NS_EDITOR_INDENT_INCREMENT_CM        1.05f
 404 #define NS_EDITOR_INDENT_INCREMENT_MM        10.5f
 405 #define NS_EDITOR_INDENT_INCREMENT_PT        29.76f
 406 #define NS_EDITOR_INDENT_INCREMENT_PC        2.48f
 407 #define NS_EDITOR_INDENT_INCREMENT_EM        3
 408 #define NS_EDITOR_INDENT_INCREMENT_EX        6
 409 #define NS_EDITOR_INDENT_INCREMENT_PX        40
 410 #define NS_EDITOR_INDENT_INCREMENT_PERCENT   4
 411
 412 #endif /* nsHTMLCSSUtils_h__ */