1998-04-13 20:24:54 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The contents of this file are subject to the Netscape Public
|
|
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
|
|
* except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at http://www.mozilla.org/NPL/
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1998-04-13 20:24:54 +00:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 03:40:37 +00:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
1998-04-13 20:24:54 +00:00
|
|
|
*/
|
|
|
|
#ifndef nsTableRowGroupFrame_h__
|
|
|
|
#define nsTableRowGroupFrame_h__
|
|
|
|
|
|
|
|
#include "nscore.h"
|
1998-10-20 17:45:07 +00:00
|
|
|
#include "nsHTMLContainerFrame.h"
|
1998-04-23 17:29:07 +00:00
|
|
|
#include "nsIAtom.h"
|
2000-05-11 01:04:39 +00:00
|
|
|
#include "nsILineIterator.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-02-22 03:28:00 +00:00
|
|
|
class nsTableFrame;
|
1998-10-14 16:32:45 +00:00
|
|
|
class nsTableRowFrame;
|
2001-04-16 14:51:52 +00:00
|
|
|
class nsTableCellFrame;
|
2001-01-25 15:55:51 +00:00
|
|
|
#ifdef DEBUG_TABLE_REFLOW_TIMING
|
|
|
|
class nsReflowTimer;
|
|
|
|
#endif
|
1999-06-23 03:02:21 +00:00
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
struct nsRowGroupReflowState {
|
1999-06-23 03:02:21 +00:00
|
|
|
const nsHTMLReflowState& reflowState; // Our reflow state
|
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
nsTableFrame* tableFrame;
|
|
|
|
|
|
|
|
nsReflowReason reason;
|
|
|
|
|
1999-06-23 03:02:21 +00:00
|
|
|
// The available size (computed from the parent)
|
|
|
|
nsSize availSize;
|
|
|
|
|
|
|
|
// Running y-offset
|
|
|
|
nscoord y;
|
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
nsRowGroupReflowState(const nsHTMLReflowState& aReflowState,
|
|
|
|
nsTableFrame* aTableFrame)
|
|
|
|
:reflowState(aReflowState), tableFrame(aTableFrame)
|
1999-06-23 03:02:21 +00:00
|
|
|
{
|
2001-03-13 06:38:59 +00:00
|
|
|
availSize.width = reflowState.availableWidth;
|
1999-06-23 03:02:21 +00:00
|
|
|
availSize.height = reflowState.availableHeight;
|
2001-03-13 06:38:59 +00:00
|
|
|
reason = reflowState.reason;
|
|
|
|
y = 0;
|
1999-06-23 03:02:21 +00:00
|
|
|
}
|
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
~nsRowGroupReflowState() {}
|
1999-06-23 03:02:21 +00:00
|
|
|
};
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-01-30 15:52:19 +00:00
|
|
|
#define NS_ITABLEROWGROUPFRAME_IID \
|
|
|
|
{ 0xe940e7bc, 0xb534, 0x11d2, \
|
|
|
|
{ 0x95, 0xa2, 0x0, 0x60, 0xb0, 0xc3, 0x44, 0x14 } }
|
|
|
|
|
2000-11-15 22:26:35 +00:00
|
|
|
// use a bit from nsFrame's frame state bits to determine whether a
|
|
|
|
// thead or tfoot should be repeated on every printed page
|
|
|
|
#define NS_ROWGROUP_REPEATABLE 0x80000000
|
1998-04-13 20:24:54 +00:00
|
|
|
/**
|
1998-04-14 21:45:28 +00:00
|
|
|
* nsTableRowGroupFrame is the frame that maps row groups
|
|
|
|
* (HTML tags THEAD, TFOOT, and TBODY). This class cannot be reused
|
|
|
|
* outside of an nsTableFrame. It assumes that its parent is an nsTableFrame, and
|
|
|
|
* its children are nsTableRowFrames.
|
|
|
|
*
|
|
|
|
* @see nsTableFrame
|
|
|
|
* @see nsTableRowFrame
|
1998-04-13 20:24:54 +00:00
|
|
|
*/
|
2000-05-16 08:11:14 +00:00
|
|
|
class nsTableRowGroupFrame : public nsHTMLContainerFrame, public nsILineIteratorNavigator
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
public:
|
2000-05-11 01:04:39 +00:00
|
|
|
// nsISupports
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
1998-04-14 21:45:28 +00:00
|
|
|
|
1998-12-03 20:19:01 +00:00
|
|
|
// default constructor supplied by the compiler
|
|
|
|
|
1998-04-14 21:45:28 +00:00
|
|
|
/** instantiate a new instance of nsTableRowGroupFrame.
|
1998-09-15 17:58:24 +00:00
|
|
|
* @param aResult the new object is returned in this out-param
|
|
|
|
* @param aContent the table object to map
|
|
|
|
* @param aParent the parent of the new frame
|
1998-04-14 21:45:28 +00:00
|
|
|
*
|
|
|
|
* @return NS_OK if the frame was properly allocated, otherwise an error code
|
|
|
|
*/
|
1998-09-15 17:58:24 +00:00
|
|
|
friend nsresult
|
1999-12-04 23:49:50 +00:00
|
|
|
NS_NewTableRowGroupFrame(nsIPresShell* aPresShell, nsIFrame** aResult);
|
2001-01-25 15:55:51 +00:00
|
|
|
virtual ~nsTableRowGroupFrame();
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2001-02-23 12:35:34 +00:00
|
|
|
NS_IMETHOD Init(nsIPresContext* aPresContext,
|
|
|
|
nsIContent* aContent,
|
|
|
|
nsIFrame* aParent,
|
|
|
|
nsIStyleContext* aContext,
|
|
|
|
nsIFrame* aPrevInFlow);
|
|
|
|
|
1999-11-24 06:03:41 +00:00
|
|
|
NS_IMETHOD AppendFrames(nsIPresContext* aPresContext,
|
1999-08-01 22:01:37 +00:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList);
|
1999-08-02 02:18:33 +00:00
|
|
|
|
1999-11-24 06:03:41 +00:00
|
|
|
NS_IMETHOD InsertFrames(nsIPresContext* aPresContext,
|
1999-08-02 02:18:33 +00:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList);
|
|
|
|
|
1999-11-24 06:03:41 +00:00
|
|
|
NS_IMETHOD RemoveFrame(nsIPresContext* aPresContext,
|
1999-08-02 02:18:33 +00:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame);
|
1999-08-01 22:01:37 +00:00
|
|
|
|
1998-04-14 21:45:28 +00:00
|
|
|
/** @see nsIFrame::Paint */
|
2001-03-13 06:38:59 +00:00
|
|
|
NS_IMETHOD Paint(nsIPresContext* aPresContext,
|
1998-04-17 01:41:24 +00:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
2001-03-13 06:38:59 +00:00
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsFramePaintLayer aWhichLayer);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-04-14 21:45:28 +00:00
|
|
|
/** ask all children to paint themselves, without clipping (for cells with rowspan>1)
|
|
|
|
* @see nsIFrame::Paint
|
|
|
|
*/
|
1999-11-24 06:03:41 +00:00
|
|
|
virtual void PaintChildren(nsIPresContext* aPresContext,
|
1998-04-13 20:24:54 +00:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
1998-12-18 15:54:23 +00:00
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsFramePaintLayer aWhichLayer);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-11-07 00:36:37 +00:00
|
|
|
/**
|
1998-11-18 05:25:26 +00:00
|
|
|
* Find the correct descendant frame.
|
|
|
|
* Return PR_TRUE if a frame containing the point is found.
|
|
|
|
* @see nsContainerFrame::GetFrameForPoint
|
1998-11-07 00:36:37 +00:00
|
|
|
*/
|
2000-03-22 02:43:08 +00:00
|
|
|
NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
|
1998-11-07 00:36:37 +00:00
|
|
|
|
1998-11-18 05:25:26 +00:00
|
|
|
/** calls Reflow for all of its child rows.
|
1998-04-14 21:45:28 +00:00
|
|
|
* Rows are all set to the same width and stacked vertically.
|
|
|
|
* <P> rows are not split unless absolutely necessary.
|
|
|
|
*
|
|
|
|
* @param aDesiredSize width set to width of rows, height set to
|
|
|
|
* sum of height of rows that fit in aMaxSize.height.
|
|
|
|
*
|
1998-05-25 17:31:49 +00:00
|
|
|
* @see nsIFrame::Reflow
|
1998-04-14 21:45:28 +00:00
|
|
|
*/
|
2001-03-13 06:38:59 +00:00
|
|
|
NS_IMETHOD Reflow(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
1998-10-02 04:10:00 +00:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
2001-03-13 06:38:59 +00:00
|
|
|
nsReflowStatus& aStatus);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-02-24 05:54:31 +00:00
|
|
|
/**
|
|
|
|
* Get the "type" of the frame
|
|
|
|
*
|
|
|
|
* @see nsLayoutAtoms::tableRowGroupFrame
|
|
|
|
*/
|
|
|
|
NS_IMETHOD GetFrameType(nsIAtom** aType) const;
|
|
|
|
|
1999-09-01 01:02:16 +00:00
|
|
|
#ifdef DEBUG
|
1999-11-01 22:12:45 +00:00
|
|
|
NS_IMETHOD GetFrameName(nsString& aResult) const;
|
1999-08-31 03:09:40 +00:00
|
|
|
NS_IMETHOD SizeOf(nsISizeOfHandler* aSizer, PRUint32* aResult) const;
|
1999-09-01 01:02:16 +00:00
|
|
|
#endif
|
1999-08-31 03:09:40 +00:00
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
/** return the number of child rows (not necessarily == number of child frames) */
|
|
|
|
PRInt32 GetRowCount();
|
1998-10-20 17:45:07 +00:00
|
|
|
|
1998-12-23 15:47:43 +00:00
|
|
|
/** return the table-relative row index of the first row in this rowgroup.
|
|
|
|
* if there are no rows, -1 is returned.
|
|
|
|
*/
|
|
|
|
PRInt32 GetStartRowIndex();
|
|
|
|
|
1999-03-03 16:33:57 +00:00
|
|
|
/**
|
|
|
|
* Used for header and footer row group frames that are repeated when
|
|
|
|
* splitting a table frame.
|
|
|
|
*
|
|
|
|
* Performs any table specific initialization
|
|
|
|
*
|
|
|
|
* @param aHeaderFooterFrame the original header or footer row group frame
|
|
|
|
* that was repeated
|
|
|
|
*/
|
2000-01-22 01:16:50 +00:00
|
|
|
nsresult InitRepeatedFrame(nsIPresContext* aPresContext,
|
|
|
|
nsTableRowGroupFrame* aHeaderFooterFrame);
|
1999-03-03 16:33:57 +00:00
|
|
|
|
1999-06-14 08:22:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the total height of all the row rects
|
|
|
|
*/
|
2001-03-13 06:38:59 +00:00
|
|
|
nscoord GetHeightOfRows(nsIPresContext* aPresContext);
|
1999-06-14 08:22:47 +00:00
|
|
|
|
2000-05-11 01:04:39 +00:00
|
|
|
// nsILineIterator methods
|
|
|
|
public:
|
|
|
|
NS_IMETHOD GetNumLines(PRInt32* aResult);
|
|
|
|
NS_IMETHOD GetDirection(PRBool* aIsRightToLeft);
|
|
|
|
|
|
|
|
NS_IMETHOD GetLine(PRInt32 aLineNumber,
|
|
|
|
nsIFrame** aFirstFrameOnLine,
|
|
|
|
PRInt32* aNumFramesOnLine,
|
|
|
|
nsRect& aLineBounds,
|
|
|
|
PRUint32* aLineFlags);
|
|
|
|
|
|
|
|
NS_IMETHOD FindLineContaining(nsIFrame* aFrame, PRInt32* aLineNumberResult);
|
|
|
|
NS_IMETHOD FindLineAt(nscoord aY, PRInt32* aLineNumberResult);
|
|
|
|
|
|
|
|
NS_IMETHOD FindFrameAt(PRInt32 aLineNumber,
|
|
|
|
nscoord aX,
|
2001-03-12 22:25:55 +00:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
PRBool aCouldBeReordered,
|
|
|
|
#endif
|
2000-05-11 01:04:39 +00:00
|
|
|
nsIFrame** aFrameFound,
|
|
|
|
PRBool* aXIsBeforeFirstFrame,
|
|
|
|
PRBool* aXIsAfterLastFrame);
|
|
|
|
|
2001-03-12 22:25:55 +00:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
NS_IMETHOD CheckLineOrder(PRInt32 aLine,
|
|
|
|
PRBool *aIsReordered,
|
|
|
|
nsIFrame **aFirstVisual,
|
|
|
|
nsIFrame **aLastVisual);
|
|
|
|
#endif
|
2000-06-16 22:28:10 +00:00
|
|
|
NS_IMETHOD GetNextSiblingOnLine(nsIFrame*& aFrame, PRInt32 aLineNumber);
|
2000-05-11 01:04:39 +00:00
|
|
|
|
|
|
|
|
1998-10-20 17:45:07 +00:00
|
|
|
protected:
|
2001-01-25 15:55:51 +00:00
|
|
|
nsTableRowGroupFrame();
|
1998-10-20 17:45:07 +00:00
|
|
|
|
|
|
|
/** implement abstract method on nsHTMLContainerFrame */
|
|
|
|
virtual PRIntn GetSkipSides() const;
|
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
void PlaceChild(nsIPresContext* aPresContext,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsIFrame* aKidFrame,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize);
|
|
|
|
|
|
|
|
void CalculateRowHeights(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
1998-11-20 01:01:25 +00:00
|
|
|
const nsHTMLReflowState& aReflowState);
|
1998-10-20 17:45:07 +00:00
|
|
|
|
|
|
|
|
1998-10-14 16:32:45 +00:00
|
|
|
/** Incremental Reflow attempts to do column balancing with the minimum number of reflow
|
|
|
|
* commands to child elements. This is done by processing the reflow command,
|
|
|
|
* rebalancing column widths (if necessary), then comparing the resulting column widths
|
|
|
|
* to the prior column widths and reflowing only those cells that require a reflow.
|
|
|
|
*
|
|
|
|
* @see Reflow
|
|
|
|
*/
|
2001-03-13 06:38:59 +00:00
|
|
|
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus);
|
|
|
|
|
|
|
|
NS_IMETHOD IR_TargetIsChild(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus,
|
|
|
|
nsIFrame* aNextFrame);
|
|
|
|
|
|
|
|
NS_IMETHOD IR_TargetIsMe(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus);
|
|
|
|
|
|
|
|
NS_IMETHOD IR_StyleChanged(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus);
|
|
|
|
|
|
|
|
nsresult AdjustSiblingsAfterReflow(nsIPresContext* aPresContext,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsIFrame* aKidFrame,
|
|
|
|
nscoord aDeltaY);
|
1999-08-19 03:51:25 +00:00
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
nsresult RecoverState(nsRowGroupReflowState& aReflowState,
|
|
|
|
nsIFrame* aKidFrame);
|
1998-07-02 23:19:31 +00:00
|
|
|
|
1998-04-14 21:45:28 +00:00
|
|
|
/**
|
|
|
|
* Reflow the frames we've already created
|
|
|
|
*
|
|
|
|
* @param aPresContext presentation context to use
|
1998-10-14 16:32:45 +00:00
|
|
|
* @param aReflowState current inline state
|
1998-04-14 21:45:28 +00:00
|
|
|
* @return true if we successfully reflowed all the mapped children and false
|
|
|
|
* otherwise, e.g. we pushed children to the next in flow
|
|
|
|
*/
|
2001-03-13 06:38:59 +00:00
|
|
|
NS_METHOD ReflowChildren(nsIPresContext* aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
nsRowGroupReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus,
|
|
|
|
nsTableRowFrame* aStartFrame,
|
|
|
|
PRBool aDirtyOnly = PR_FALSE);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-04-14 21:45:28 +00:00
|
|
|
/**
|
1999-02-20 03:15:03 +00:00
|
|
|
* Pull-up all the row frames from our next-in-flow
|
1998-04-14 21:45:28 +00:00
|
|
|
*/
|
1999-11-24 06:03:41 +00:00
|
|
|
NS_METHOD PullUpAllRowFrames(nsIPresContext* aPresContext);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-11-24 06:03:41 +00:00
|
|
|
nsresult SplitRowGroup(nsIPresContext* aPresContext,
|
1998-12-14 01:24:11 +00:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
1999-02-22 03:28:00 +00:00
|
|
|
nsTableFrame* aTableFrame,
|
1998-12-14 01:24:11 +00:00
|
|
|
nsReflowStatus& aStatus);
|
|
|
|
|
2001-04-16 14:51:52 +00:00
|
|
|
nscoord SplitSpanningCells(nsIPresContext& aPresContext,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsIStyleSet& aStyleSet,
|
|
|
|
nsTableFrame& aTableFrame,
|
|
|
|
nsTableRowFrame& aRowFrame,
|
|
|
|
nscoord aRowEndY,
|
|
|
|
nsTableRowFrame* aContRowFrame);
|
|
|
|
|
|
|
|
void CreateContinuingRowFrame(nsIPresContext& aPresContext,
|
|
|
|
nsIStyleSet& aStyleSet,
|
|
|
|
nsIFrame& aRowFrame,
|
|
|
|
nsIFrame** aContRowFrame);
|
|
|
|
|
2001-03-13 06:38:59 +00:00
|
|
|
PRBool IsSimpleRowFrame(nsTableFrame* aTableFrame,
|
|
|
|
nsIFrame* aFrame);
|
1999-08-02 02:18:33 +00:00
|
|
|
|
1999-06-23 09:07:59 +00:00
|
|
|
void GetNextRowSibling(nsIFrame** aRowFrame);
|
|
|
|
|
|
|
|
public:
|
1999-06-23 03:02:21 +00:00
|
|
|
virtual nsIFrame* GetFirstFrame() { return mFrames.FirstChild(); };
|
|
|
|
virtual nsIFrame* GetLastFrame() { return mFrames.LastChild(); };
|
2001-03-13 06:38:59 +00:00
|
|
|
virtual void GetNextFrame(nsIFrame* aFrame,
|
|
|
|
nsIFrame** aResult) { aFrame->GetNextSibling(aResult); };
|
2000-11-15 22:26:35 +00:00
|
|
|
PRBool IsRepeatable();
|
|
|
|
void SetRepeatable(PRBool aRepeatable);
|
1999-06-23 03:02:21 +00:00
|
|
|
|
2001-01-25 15:55:51 +00:00
|
|
|
#ifdef DEBUG_TABLE_REFLOW_TIMING
|
|
|
|
public:
|
|
|
|
nsReflowTimer* mTimer;
|
|
|
|
#endif
|
1998-04-13 20:24:54 +00:00
|
|
|
};
|
|
|
|
|
1999-08-30 22:30:32 +00:00
|
|
|
|
2000-11-15 22:26:35 +00:00
|
|
|
inline PRBool nsTableRowGroupFrame::IsRepeatable()
|
|
|
|
{
|
|
|
|
return (mState & NS_ROWGROUP_REPEATABLE) == NS_ROWGROUP_REPEATABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void nsTableRowGroupFrame::SetRepeatable(PRBool aRepeatable)
|
|
|
|
{
|
|
|
|
if (aRepeatable) {
|
|
|
|
mState |= NS_ROWGROUP_REPEATABLE;
|
|
|
|
} else {
|
|
|
|
mState &= ~NS_ROWGROUP_REPEATABLE;
|
|
|
|
}
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
|
|
|
|
#endif
|