264 lines
10 KiB
C++
264 lines
10 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
#ifndef INCLUDED_SW_SOURCE_CORE_INC_TABFRM_HXX
|
|
#define INCLUDED_SW_SOURCE_CORE_INC_TABFRM_HXX
|
|
|
|
#include <swdllapi.h>
|
|
|
|
#include "layfrm.hxx"
|
|
#include "flowfrm.hxx"
|
|
|
|
class SwTable;
|
|
class SwBorderAttrs;
|
|
class SwAttrSetChg;
|
|
|
|
enum class SwTabFrameInvFlags : sal_uInt8
|
|
{
|
|
NONE = 0x00,
|
|
InvalidatePrt = 0x02,
|
|
InvalidateIndNextPrt = 0x04,
|
|
InvalidatePrevPrt = 0x08,
|
|
SetIndNextCompletePaint = 0x10,
|
|
InvalidateBrowseWidth = 0x20,
|
|
InvalidatePos = 0x40,
|
|
InvalidateNextPos = 0x80,
|
|
};
|
|
|
|
namespace o3tl {
|
|
template<> struct typed_flags<SwTabFrameInvFlags> : is_typed_flags<SwTabFrameInvFlags, 0xfe> {};
|
|
}
|
|
|
|
/// SwTabFrame is one table in the document layout, containing rows (which contain cells).
|
|
class SW_DLLPUBLIC SwTabFrame final: public SwLayoutFrame, public SwFlowFrame
|
|
{
|
|
friend void CalcContent( SwLayoutFrame *pLay, bool bNoColl );
|
|
|
|
// does the special treatment for Get_[Next|Prev]Leaf()
|
|
using SwFrame::GetLeaf;
|
|
|
|
SwTable * m_pTable;
|
|
|
|
bool m_bComplete :1; /// Set entries for Repaint without needing to
|
|
/// set the base class' CompletePaint
|
|
/// With that we would want to avoid unnecessary
|
|
/// table repaints
|
|
bool m_bCalcLowers :1; /// For stability of the content in MakeAll
|
|
bool m_bLowersFormatted :1; /// Communication between MakeAll and Layact
|
|
bool m_bLockBackMove :1; /// The Master took care of the BackMove test
|
|
bool m_bWantBackMove :1; /// Table wants to move back but was locked
|
|
bool m_bResizeHTMLTable :1; /// Call the Resize of the HTMLTableLayout in the MakeAll
|
|
/// This is an optimization, so that we don't have to call
|
|
/// it in ContentFrame::Grow; there it might be called for
|
|
/// _every_ Cell
|
|
|
|
bool m_bONECalcLowers :1; /// Primarily for the StarONE SS
|
|
/// The Contents are formatted via Calc() on MakeAll in any
|
|
/// case. There are no further invalidations and that path can
|
|
/// hardly give any guarantees
|
|
|
|
bool m_bHasFollowFlowLine :1; /// Means that the first line in the follow
|
|
/// is indented to contain content from a broken
|
|
/// cell
|
|
bool m_bIsRebuildLastLine :1; /// Means that currently the last line of the
|
|
/// TabFrame is rebuilt. In this case we do not
|
|
// want any notification to the master table
|
|
|
|
bool m_bRestrictTableGrowth :1; // Usually, the table may grow infinitely,
|
|
// as the table can be split in SwTabFrame::MakeAll
|
|
// In MakeAll, this flag is set to indicate that
|
|
// the table may only grow inside its upper. This
|
|
// is necessary, in order to let the text flow into
|
|
// the FollowFlowLine
|
|
|
|
bool m_bRemoveFollowFlowLinePending :1;
|
|
|
|
// #i26945#
|
|
bool m_bConsiderObjsForMinCellHeight :1; // Usually, the floating screen objects
|
|
// are considered during the calculation
|
|
// for the minimal cell height.
|
|
// For the splitting table rows algorithm
|
|
// we need not to consider floating
|
|
// screen object for the preparation
|
|
// of the re-calculation of the
|
|
// last table row.
|
|
// #i26945#
|
|
bool m_bObjsDoesFit :1; // For splitting table rows algorithm, this boolean
|
|
// indicates, if the floating screen objects fits
|
|
|
|
bool m_bInRecalcLowerRow : 1;
|
|
|
|
/**
|
|
* Split() splits the Frame at the specified position: a Follow is
|
|
* created and constructed and inserted directly after this.
|
|
* Join() gets the Follow's content and destroys it.
|
|
*/
|
|
bool Split(const SwTwips nCutPos, bool bTryToSplit, bool bTableRowKeep, bool & rIsFootnoteGrowth);
|
|
void Join();
|
|
|
|
void UpdateAttr_(
|
|
const SfxPoolItem*,
|
|
const SfxPoolItem*, SwTabFrameInvFlags &,
|
|
SwAttrSetChg *pa = nullptr,
|
|
SwAttrSetChg *pb = nullptr );
|
|
void Invalidate(SwTabFrameInvFlags);
|
|
void HandleTableHeadlineChange();
|
|
|
|
virtual bool ShouldBwdMoved( SwLayoutFrame *pNewUpper, bool &rReformat ) override;
|
|
|
|
virtual void DestroyImpl() override;
|
|
virtual ~SwTabFrame() override;
|
|
|
|
virtual void MakeAll(vcl::RenderContext* pRenderContext) override;
|
|
virtual void Format( vcl::RenderContext* pRenderContext, const SwBorderAttrs *pAttrs = nullptr ) override;
|
|
virtual void SwClientNotify(const SwModify&, const SfxHint&) override;
|
|
// only changes the Framesize, not the PrtArea size
|
|
virtual SwTwips GrowFrame(SwTwips, SwResizeLimitReason&, bool bTst, bool bInfo) override;
|
|
virtual const SwTabFrame* DynCastTabFrame() const override { return this; }
|
|
|
|
public:
|
|
SwTabFrame( SwTable &, SwFrame* ); // calling RegistFlys always after creation _and_pasting!
|
|
SwTabFrame( SwTabFrame & ); // _only_ for the creation of follows
|
|
|
|
void JoinAndDelFollows(); // for DelFrames of the TableNodes!
|
|
|
|
// calls thr RegistFlys of the rows
|
|
void RegistFlys();
|
|
|
|
inline const SwTabFrame *GetFollow() const;
|
|
inline SwTabFrame *GetFollow();
|
|
SwTabFrame* FindMaster( bool bFirstMaster = false ) const;
|
|
|
|
virtual void PaintSwFrame( vcl::RenderContext& rRenderContext, SwRect const&, PaintFrameMode mode = PAINT_ALL ) const override;
|
|
virtual void CheckDirection( bool bVert ) override;
|
|
|
|
virtual void Cut() override;
|
|
virtual void Paste( SwFrame* pParent, SwFrame* pSibling = nullptr ) override;
|
|
|
|
virtual bool Prepare( const PrepareHint ePrep = PrepareHint::Clear,
|
|
const void *pVoid = nullptr, bool bNotify = true ) override;
|
|
|
|
SwFrame *FindLastContentOrTable();
|
|
inline const SwFrame *FindLastContentOrTable() const;
|
|
SwContentFrame *FindLastContent();
|
|
inline const SwContentFrame *FindLastContent() const;
|
|
|
|
const SwTable *GetTable() const { return m_pTable; }
|
|
SwTable *GetTable() { return m_pTable; }
|
|
|
|
bool IsComplete() const { return m_bComplete; }
|
|
void SetComplete() { m_bComplete = true; }
|
|
void ResetComplete() { m_bComplete = false; }
|
|
|
|
bool IsLowersFormatted() const { return m_bLowersFormatted; }
|
|
void SetLowersFormatted(bool b) { m_bLowersFormatted = b; }
|
|
|
|
void SetCalcLowers() { m_bCalcLowers = true; } // use rarely
|
|
void SetResizeHTMLTable() { m_bResizeHTMLTable = true; } // same
|
|
void SetONECalcLowers() { m_bONECalcLowers = true; }
|
|
|
|
// Start: New stuff for breaking table rows
|
|
|
|
bool HasFollowFlowLine() const { return m_bHasFollowFlowLine; }
|
|
void SetFollowFlowLine(bool bNew) { m_bHasFollowFlowLine = bNew; }
|
|
|
|
bool IsRebuildLastLine() const { return m_bIsRebuildLastLine; }
|
|
void SetRebuildLastLine(bool bNew) { m_bIsRebuildLastLine = bNew; }
|
|
|
|
bool IsRestrictTableGrowth() const { return m_bRestrictTableGrowth; }
|
|
void SetRestrictTableGrowth( bool bNew ) { m_bRestrictTableGrowth = bNew; }
|
|
|
|
bool IsRemoveFollowFlowLinePending() const { return m_bRemoveFollowFlowLinePending; }
|
|
void SetRemoveFollowFlowLinePending(bool bNew) { m_bRemoveFollowFlowLinePending = bNew; }
|
|
|
|
bool IsInRecalcLowerRow() const
|
|
{
|
|
return m_bInRecalcLowerRow;
|
|
}
|
|
void SetInRecalcLowerRow( bool bNew )
|
|
{
|
|
m_bInRecalcLowerRow = bNew;
|
|
}
|
|
|
|
// #i26945#
|
|
bool IsConsiderObjsForMinCellHeight() const
|
|
{
|
|
return m_bConsiderObjsForMinCellHeight;
|
|
}
|
|
void SetConsiderObjsForMinCellHeight(bool const bConsiderObjsForMinCellHeight)
|
|
{
|
|
m_bConsiderObjsForMinCellHeight = bConsiderObjsForMinCellHeight;
|
|
}
|
|
|
|
// #i26945#
|
|
bool DoesObjsFit() const
|
|
{
|
|
return m_bObjsDoesFit;
|
|
}
|
|
void SetDoesObjsFit(bool const bObjsDoesFit)
|
|
{
|
|
m_bObjsDoesFit = bObjsDoesFit;
|
|
}
|
|
|
|
bool RemoveFollowFlowLine();
|
|
|
|
// End: New stuff for breaking table rows
|
|
|
|
bool CalcFlyOffsets(
|
|
SwTwips& rUpper,
|
|
tools::Long& rLeftOffset,
|
|
tools::Long& rRightOffset,
|
|
SwTwips * pSpaceBelowBottom) const;
|
|
|
|
SwTwips CalcHeightOfFirstContentLine() const;
|
|
|
|
bool IsInHeadline( const SwFrame& rFrame ) const;
|
|
SwRowFrame* GetFirstNonHeadlineRow() const;
|
|
|
|
bool IsLayoutSplitAllowed() const;
|
|
|
|
// #i29550#
|
|
bool IsCollapsingBorders() const;
|
|
|
|
sal_uInt16 GetBottomLineSize() const;
|
|
|
|
void dumpAsXml(xmlTextWriterPtr writer = nullptr) const override;
|
|
};
|
|
|
|
inline const SwFrame *SwTabFrame::FindLastContentOrTable() const
|
|
{
|
|
return const_cast<SwTabFrame*>(this)->FindLastContentOrTable();
|
|
}
|
|
|
|
inline const SwContentFrame *SwTabFrame::FindLastContent() const
|
|
{
|
|
return const_cast<SwTabFrame*>(this)->FindLastContent();
|
|
}
|
|
|
|
inline const SwTabFrame *SwTabFrame::GetFollow() const
|
|
{
|
|
return static_cast<const SwTabFrame*>(SwFlowFrame::GetFollow());
|
|
}
|
|
inline SwTabFrame *SwTabFrame::GetFollow()
|
|
{
|
|
return static_cast<SwTabFrame*>(SwFlowFrame::GetFollow());
|
|
}
|
|
|
|
#endif // INCLUDED_SW_SOURCE_CORE_INC_TABFRM_HXX
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|