layout/mathml/base/src/nsMathMLmtableFrame.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 MathML Project.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * The University Of Queensland.
  19  * Portions created by the Initial Developer are Copyright (C) 1999
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Roger B. Sidje <rbs@maths.uq.edu.au>
  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 #ifndef nsMathMLmtableFrame_h___
  40 #define nsMathMLmtableFrame_h___
  41
  42 #include "nsCOMPtr.h"
  43 #include "nsMathMLContainerFrame.h"
  44
  45 //
  46 // <mtable> -- table or matrix
  47 //
  48
  49 class nsMathMLmtableOuterFrame : public nsTableOuterFrame,
  50                                  public nsMathMLFrame
  51 {
  52 public:
  53   friend nsIFrame* NS_NewMathMLmtableOuterFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
  54
  55   NS_DECL_ISUPPORTS_INHERITED
  56
  57   // Overloaded nsIMathMLFrame methods
  58
  59   NS_IMETHOD
  60   InheritAutomaticData(nsIFrame* aParent);
  61
  62   NS_IMETHOD
  63   UpdatePresentationData(PRUint32 aFlagsValues,
  64                          PRUint32 aWhichFlags);
  65
  66   NS_IMETHOD
  67   UpdatePresentationDataFromChildAt(PRInt32         aFirstIndex,
  68                                     PRInt32         aLastIndex,
  69                                     PRUint32        aFlagsValues,
  70                                     PRUint32        aWhichFlags);
  71
  72   // overloaded nsTableOuterFrame methods
  73
  74   NS_IMETHOD
  75   Reflow(nsPresContext*          aPresContext,
  76          nsHTMLReflowMetrics&     aDesiredSize,
  77          const nsHTMLReflowState& aReflowState,
  78          nsReflowStatus&          aStatus);
  79
  80   NS_IMETHOD
  81   AttributeChanged(PRInt32  aNameSpaceID,
  82                    nsIAtom* aAttribute,
  83                    PRInt32  aModType);
  84
  85   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
  86   {
  87     return nsTableOuterFrame::IsFrameOfType(aFlags &
  88       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
  89   }
  90
  91 protected:
  92   nsMathMLmtableOuterFrame(nsStyleContext* aContext) : nsTableOuterFrame(aContext) {}
  93   virtual ~nsMathMLmtableOuterFrame();
  94
  95   // helper to find the row frame at a given index, positive or negative, e.g.,
  96   // 1..n means the first row down to the last row, -1..-n means the last row
  97   // up to the first row. Used for alignments that are relative to a given row
  98   nsIFrame*
  99   GetRowFrameAt(nsPresContext* aPresContext,
 100                 PRInt32         aRowIndex);
 101 }; // class nsMathMLmtableOuterFrame
 102
 103 // --------------
 104
 105 class nsMathMLmtableFrame : public nsTableFrame
 106 {
 107 public:
 108   friend nsIFrame* NS_NewMathMLmtableFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 109
 110   NS_DECL_ISUPPORTS_INHERITED
 111
 112   // Overloaded nsTableFrame methods
 113
 114   NS_IMETHOD
 115   SetInitialChildList(nsIAtom*  aListName,
 116                       nsIFrame* aChildList);
 117
 118   NS_IMETHOD
 119   AppendFrames(nsIAtom*  aListName,
 120                nsIFrame* aFrameList)
 121   {
 122     nsresult rv = nsTableFrame::AppendFrames(aListName, aFrameList);
 123     RestyleTable();
 124     return rv;
 125   }
 126
 127   NS_IMETHOD
 128   InsertFrames(nsIAtom*  aListName,
 129                nsIFrame* aPrevFrame,
 130                nsIFrame* aFrameList)
 131   {
 132     nsresult rv = nsTableFrame::InsertFrames(aListName, aPrevFrame, aFrameList);
 133     RestyleTable();
 134     return rv;
 135   }
 136
 137   NS_IMETHOD
 138   RemoveFrame(nsIAtom*  aListName,
 139               nsIFrame* aOldFrame)
 140   {
 141     nsresult rv = nsTableFrame::RemoveFrame(aListName, aOldFrame);
 142     RestyleTable();
 143     return rv;
 144   }
 145
 146   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
 147   {
 148     return nsTableFrame::IsFrameOfType(aFlags &
 149       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
 150   }
 151
 152   // helper to restyle and reflow the table when a row is changed -- since MathML
 153   // attributes are inter-dependent and row/colspan can affect the table, it is
 154   // safer (albeit grossly suboptimal) to just relayout the whole thing.
 155   void RestyleTable();
 156
 157 protected:
 158   nsMathMLmtableFrame(nsStyleContext* aContext) : nsTableFrame(aContext) {}
 159   virtual ~nsMathMLmtableFrame();
 160 }; // class nsMathMLmtableFrame
 161
 162 // --------------
 163
 164 class nsMathMLmtrFrame : public nsTableRowFrame
 165 {
 166 public:
 167   friend nsIFrame* NS_NewMathMLmtrFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 168
 169   NS_DECL_ISUPPORTS_INHERITED
 170
 171   // overloaded nsTableRowFrame methods
 172
 173   NS_IMETHOD
 174   AttributeChanged(PRInt32  aNameSpaceID,
 175                    nsIAtom* aAttribute,
 176                    PRInt32  aModType);
 177
 178   NS_IMETHOD
 179   AppendFrames(nsIAtom*  aListName,
 180                nsIFrame* aFrameList)
 181   {
 182     nsresult rv = nsTableRowFrame::AppendFrames(aListName, aFrameList);
 183     RestyleTable();
 184     return rv;
 185   }
 186
 187   NS_IMETHOD
 188   InsertFrames(nsIAtom*  aListName,
 189                nsIFrame* aPrevFrame,
 190                nsIFrame* aFrameList)
 191   {
 192     nsresult rv = nsTableRowFrame::InsertFrames(aListName, aPrevFrame, aFrameList);
 193     RestyleTable();
 194     return rv;
 195   }
 196
 197   NS_IMETHOD
 198   RemoveFrame(nsIAtom*  aListName,
 199               nsIFrame* aOldFrame)
 200   {
 201     nsresult rv = nsTableRowFrame::RemoveFrame(aListName, aOldFrame);
 202     RestyleTable();
 203     return rv;
 204   }
 205
 206   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
 207   {
 208     return nsTableRowFrame::IsFrameOfType(aFlags &
 209       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
 210   }
 211
 212   // helper to restyle and reflow the table -- @see nsMathMLmtableFrame.
 213   void RestyleTable()
 214   {
 215     nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
 216     if (tableFrame && tableFrame->IsFrameOfType(nsIFrame::eMathML)) {
 217       // relayout the table
 218       ((nsMathMLmtableFrame*)tableFrame)->RestyleTable();
 219     }
 220   }
 221
 222 protected:
 223   nsMathMLmtrFrame(nsStyleContext* aContext) : nsTableRowFrame(aContext) {}
 224   virtual ~nsMathMLmtrFrame();
 225 }; // class nsMathMLmtrFrame
 226
 227 // --------------
 228
 229 class nsMathMLmtdFrame : public nsTableCellFrame
 230 {
 231 public:
 232   friend nsIFrame* NS_NewMathMLmtdFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 233
 234   NS_DECL_ISUPPORTS_INHERITED
 235
 236   // overloaded nsTableCellFrame methods
 237
 238   NS_IMETHOD
 239   AttributeChanged(PRInt32  aNameSpaceID,
 240                    nsIAtom* aAttribute,
 241                    PRInt32  aModType);
 242
 243   virtual PRInt32 GetRowSpan();
 244   virtual PRInt32 GetColSpan();
 245   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
 246   {
 247     return nsTableCellFrame::IsFrameOfType(aFlags &
 248       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
 249   }
 250
 251 protected:
 252   nsMathMLmtdFrame(nsStyleContext* aContext) : nsTableCellFrame(aContext) {}
 253   virtual ~nsMathMLmtdFrame();
 254 }; // class nsMathMLmtdFrame
 255
 256 // --------------
 257
 258 class nsMathMLmtdInnerFrame : public nsBlockFrame,
 259                               public nsMathMLFrame {
 260 public:
 261   friend nsIFrame* NS_NewMathMLmtdInnerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 262
 263   NS_DECL_ISUPPORTS_INHERITED
 264
 265   // Overloaded nsIMathMLFrame methods
 266
 267   NS_IMETHOD
 268   UpdatePresentationDataFromChildAt(PRInt32         aFirstIndex,
 269                                     PRInt32         aLastIndex,
 270                                     PRUint32        aFlagsValues,
 271                                     PRUint32        aFlagsToUpdate)
 272   {
 273     nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(this,
 274       aFirstIndex, aLastIndex, aFlagsValues, aFlagsToUpdate);
 275     return NS_OK;
 276   }
 277
 278   NS_IMETHOD
 279   Reflow(nsPresContext*          aPresContext,
 280          nsHTMLReflowMetrics&     aDesiredSize,
 281          const nsHTMLReflowState& aReflowState,
 282          nsReflowStatus&          aStatus);
 283
 284   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
 285   {
 286     return nsBlockFrame::IsFrameOfType(aFlags &
 287       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
 288   }
 289
 290 protected:
 291   nsMathMLmtdInnerFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) {}
 292   virtual ~nsMathMLmtdInnerFrame();
 293
 294   virtual PRIntn GetSkipSides() const { return 0; }
 295 };  // class nsMathMLmtdInnerFrame
 296
 297 #endif /* nsMathMLmtableFrame_h___ */